diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh
index 3a491a63e6c..f9f0890f4fb 100644
--- a/source/blender/functions/FN_multi_function_builder.hh
+++ b/source/blender/functions/FN_multi_function_builder.hh
@@ -445,10 +445,9 @@ template<typename CallFn, typename... ParamTags> class CustomMF : public MultiFu
   CustomMF(const char *name, CallFn call_fn, TypeSequence<ParamTags...> /*param_tags*/)
       : call_fn_(std::move(call_fn))
   {
-    MFSignatureBuilder signature{name};
+    MFSignatureBuilder builder{name, signature_};
     /* Loop over all parameter types and add an entry for each in the signature. */
-    ([&] { signature.add(ParamTags(), ""); }(), ...);
-    signature_ = signature.build();
+    ([&] { builder.add(ParamTags(), ""); }(), ...);
     this->set_signature(&signature_);
   }
 
@@ -631,9 +630,8 @@ template<typename T> class CustomMF_Constant : public MultiFunction {
  public:
   template<typename U> CustomMF_Constant(U &&value) : value_(std::forward<U>(value))
   {
-    MFSignatureBuilder signature{"Constant"};
-    signature.single_output<T>("Value");
-    signature_ = signature.build();
+    MFSignatureBuilder builder{"Constant", signature_};
+    builder.single_output<T>("Value");
     this->set_signature(&signature_);
   }
 
diff --git a/source/blender/functions/FN_multi_function_signature.hh b/source/blender/functions/FN_multi_function_signature.hh
index 1c2d645c1fd..44f2b84867d 100644
--- a/source/blender/functions/FN_multi_function_signature.hh
+++ b/source/blender/functions/FN_multi_function_signature.hh
@@ -32,19 +32,15 @@ struct MFSignature {
 
 class MFSignatureBuilder {
  private:
-  MFSignature signature_;
+  MFSignature &signature_;
 
  public:
-  MFSignatureBuilder(const char *function_name)
+  MFSignatureBuilder(const char *function_name, MFSignature &signature_to_build)
+      : signature_(signature_to_build)
   {
     signature_.function_name = function_name;
   }
 
-  MFSignature build() const
-  {
-    return std::move(signature_);
-  }
-
   /* Input Parameter Types */
 
   template<typename T> void single_input(const char *name)
diff --git a/source/blender/functions/intern/multi_function_builder.cc b/source/blender/functions/intern/multi_function_builder.cc
index 32a41f99c48..bda5ec19cea 100644
--- a/source/blender/functions/intern/multi_function_builder.cc
+++ b/source/blender/functions/intern/multi_function_builder.cc
@@ -18,9 +18,8 @@ CustomMF_GenericConstant::CustomMF_GenericConstant(const CPPType &type,
   }
   value_ = value;
 
-  MFSignatureBuilder signature{"Constant"};
-  signature.single_output("Value", type);
-  signature_ = signature.build();
+  MFSignatureBuilder builder{"Constant", signature_};
+  builder.single_output("Value", type);
   this->set_signature(&signature_);
 }
 
@@ -58,9 +57,8 @@ bool CustomMF_GenericConstant::equals(const MultiFunction &other) const
 CustomMF_GenericConstantArray::CustomMF_GenericConstantArray(GSpan array) : array_(array)
 {
   const CPPType &type = array.type();
-  MFSignatureBuilder signature{"Constant Vector"};
-  signature.vector_output("Value", type);
-  signature_ = signature.build();
+  MFSignatureBuilder builder{"Constant Vector", signature_};
+  builder.vector_output("Value", type);
   this->set_signature(&signature_);
 }
 
@@ -78,14 +76,13 @@ CustomMF_DefaultOutput::CustomMF_DefaultOutput(Span<MFDataType> input_types,
                                                Span<MFDataType> output_types)
     : output_amount_(output_types.size())
 {
-  MFSignatureBuilder signature{"Default Output"};
+  MFSignatureBuilder builder{"Default Output", signature_};
   for (MFDataType data_type : input_types) {
-    signature.input("Input", data_type);
+    builder.input("Input", data_type);
   }
   for (MFDataType data_type : output_types) {
-    signature.output("Output", data_type);
+    builder.output("Output", data_type);
   }
-  signature_ = signature.build();
   this->set_signature(&signature_);
 }
 void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext /*context*/) const
@@ -106,10 +103,9 @@ void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext /*c
 
 CustomMF_GenericCopy::CustomMF_GenericCopy(MFDataType data_type)
 {
-  MFSignatureBuilder signature{"Copy"};
-  signature.input("Input", data_type);
-  signature.output("Output", data_type);
-  signature_ = signature.build();
+  MFSignatureBuilder builder{"Copy", signature_};
+  builder.input("Input", data_type);
+  builder.output("Output", data_type);
   this->set_signature(&signature_);
 }
 
diff --git a/source/blender/functions/intern/multi_function_procedure_executor.cc b/source/blender/functions/intern/multi_function_procedure_executor.cc
index 4fe3c27ea27..6c997e2e222 100644
--- a/source/blender/functions/intern/multi_function_procedure_executor.cc
+++ b/source/blender/functions/intern/multi_function_procedure_executor.cc
@@ -8,13 +8,12 @@ namespace blender::fn {
 
 MFProcedureExecutor::MFProcedureExecutor(const MFProcedure &procedure) : procedure_(procedure)
 {
-  MFSignatureBuilder signature("Procedure Executor");
+  MFSignatureBuilder builder("Procedure Executor", signature_);
 
   for (const ConstMFParameter &param : procedure.params()) {
-    signature.add("Parameter", MFParamType(param.type, param.variable->data_type()));
+    builder.add("Parameter", MFParamType(param.type, param.variable->data_type()));
   }
 
-  signature_ = signature.build();
   this->set_signature(&signature_);
 }
 
diff --git a/source/blender/functions/tests/FN_field_test.cc b/source/blender/functions/tests/FN_field_test.cc
index 3e5c201195f..5e3ae5676fc 100644
--- a/source/blender/functions/tests/FN_field_test.cc
+++ b/source/blender/functions/tests/FN_field_test.cc
@@ -156,12 +156,11 @@ class TwoOutputFunction : public MultiFunction {
  public:
   TwoOutputFunction()
   {
-    MFSignatureBuilder signature{"Two Outputs"};
-    signature.single_input<int>("In1");
-    signature.single_input<int>("In2");
-    signature.single_output<int>("Add");
-    signature.single_output<int>("Add10");
-    signature_ = signature.build();
+    MFSignatureBuilder builder{"Two Outputs", signature_};
+    builder.single_input<int>("In1");
+    builder.single_input<int>("In2");
+    builder.single_output<int>("Add");
+    builder.single_output<int>("Add10");
     this->set_signature(&signature_);
   }
 
diff --git a/source/blender/functions/tests/FN_multi_function_test.cc b/source/blender/functions/tests/FN_multi_function_test.cc
index 7a582805e98..5306fe0b20c 100644
--- a/source/blender/functions/tests/FN_multi_function_test.cc
+++ b/source/blender/functions/tests/FN_multi_function_test.cc
@@ -19,11 +19,12 @@ class AddFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature("Add");
-    signature.single_input<int>("A");
-    signature.single_input<int>("B");
-    signature.single_output<int>("Result");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder("Add", signature);
+    builder.single_input<int>("A");
+    builder.single_input<int>("B");
+    builder.single_output<int>("Result");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
diff --git a/source/blender/functions/tests/FN_multi_function_test_common.hh b/source/blender/functions/tests/FN_multi_function_test_common.hh
index 15e8baf2001..82433723760 100644
--- a/source/blender/functions/tests/FN_multi_function_test_common.hh
+++ b/source/blender/functions/tests/FN_multi_function_test_common.hh
@@ -14,10 +14,11 @@ class AddPrefixFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Add Prefix"};
-    signature.single_input<std::string>("Prefix");
-    signature.single_mutable<std::string>("Strings");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Add Prefix", signature};
+    builder.single_input<std::string>("Prefix");
+    builder.single_mutable<std::string>("Strings");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@@ -41,10 +42,11 @@ class CreateRangeFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Create Range"};
-    signature.single_input<int>("Size");
-    signature.vector_output<int>("Range");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Create Range", signature};
+    builder.single_input<int>("Size");
+    builder.vector_output<int>("Range");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@@ -68,10 +70,9 @@ class GenericAppendFunction : public MultiFunction {
  public:
   GenericAppendFunction(const CPPType &type)
   {
-    MFSignatureBuilder signature{"Append"};
-    signature.vector_mutable("Vector", type);
-    signature.single_input("Value", type);
-    signature_ = signature.build();
+    MFSignatureBuilder builder{"Append", signature_};
+    builder.vector_mutable("Vector", type);
+    builder.single_input("Value", type);
     this->set_signature(&signature_);
   }
 
@@ -99,10 +100,11 @@ class ConcatVectorsFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Concat Vectors"};
-    signature.vector_mutable<int>("A");
-    signature.vector_input<int>("B");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Concat Vectors", signature};
+    builder.vector_mutable<int>("A");
+    builder.vector_input<int>("B");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@@ -123,10 +125,11 @@ class AppendFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Append"};
-    signature.vector_mutable<int>("Vector");
-    signature.single_input<int>("Value");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Append", signature};
+    builder.vector_mutable<int>("Vector");
+    builder.single_input<int>("Value");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@@ -150,10 +153,11 @@ class SumVectorFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Sum Vectors"};
-    signature.vector_input<int>("Vector");
-    signature.single_output<int>("Sum");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Sum Vectors", signature};
+    builder.vector_input<int>("Vector");
+    builder.single_output<int>("Sum");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
@@ -181,10 +185,11 @@ class OptionalOutputsFunction : public MultiFunction {
 
   static MFSignature create_signature()
   {
-    MFSignatureBuilder signature{"Optional Outputs"};
-    signature.single_output<int>("Out 1");
-    signature.single_output<std::string>("Out 2");
-    return signature.build();
+    MFSignature signature;
+    MFSignatureBuilder builder{"Optional Outputs", signature};
+    builder.single_output<int>("Out 1");
+    builder.single_output<std::string>("Out 2");
+    return signature;
   }
 
   void call(IndexMask mask, MFParams params, MFContext /*context*/) const override
diff --git a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc
index 20180971127..21290220ff6 100644
--- a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc
+++ b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc
@@ -148,13 +148,14 @@ class MF_AlignEulerToVector : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Align Euler to Vector"};
-    signature.single_input<float3>("Rotation");
-    signature.single_input<float>("Factor");
-    signature.single_input<float3>("Vector");
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Align Euler to Vector", signature};
+    builder.single_input<float3>("Rotation");
+    builder.single_input<float>("Factor");
+    builder.single_input<float3>("Vector");
 
-    signature.single_output<float3>("Rotation");
-    return signature.build();
+    builder.single_output<float3>("Rotation");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc b/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc
index 44397d27121..fab8d13ffcb 100644
--- a/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc
+++ b/source/blender/nodes/function/nodes/node_fn_input_special_characters.cc
@@ -20,10 +20,11 @@ class MF_SpecialCharacters : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Special Characters"};
-    signature.single_output<std::string>("Line Break");
-    signature.single_output<std::string>("Tab");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Special Characters", signature};
+    builder.single_output<std::string>("Line Break");
+    builder.single_output<std::string>("Tab");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/function/nodes/node_fn_separate_color.cc b/source/blender/nodes/function/nodes/node_fn_separate_color.cc
index 4e48d7fa44b..bb663fb4427 100644
--- a/source/blender/nodes/function/nodes/node_fn_separate_color.cc
+++ b/source/blender/nodes/function/nodes/node_fn_separate_color.cc
@@ -47,13 +47,14 @@ class SeparateRGBAFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Separate Color"};
-    signature.single_input<ColorGeometry4f>("Color");
-    signature.single_output<float>("Red");
-    signature.single_output<float>("Green");
-    signature.single_output<float>("Blue");
-    signature.single_output<float>("Alpha");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Separate Color", signature};
+    builder.single_input<ColorGeometry4f>("Color");
+    builder.single_output<float>("Red");
+    builder.single_output<float>("Green");
+    builder.single_output<float>("Blue");
+    builder.single_output<float>("Alpha");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -108,13 +109,14 @@ class SeparateHSVAFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Separate Color"};
-    signature.single_input<ColorGeometry4f>("Color");
-    signature.single_output<float>("Hue");
-    signature.single_output<float>("Saturation");
-    signature.single_output<float>("Value");
-    signature.single_output<float>("Alpha");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Separate Color", signature};
+    builder.single_input<ColorGeometry4f>("Color");
+    builder.single_output<float>("Hue");
+    builder.single_output<float>("Saturation");
+    builder.single_output<float>("Value");
+    builder.single_output<float>("Alpha");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -148,13 +150,14 @@ class SeparateHSLAFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Separate Color"};
-    signature.single_input<ColorGeometry4f>("Color");
-    signature.single_output<float>("Hue");
-    signature.single_output<float>("Saturation");
-    signature.single_output<float>("Lightness");
-    signature.single_output<float>("Alpha");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Separate Color", signature};
+    builder.single_input<ColorGeometry4f>("Color");
+    builder.single_output<float>("Hue");
+    builder.single_output<float>("Saturation");
+    builder.single_output<float>("Lightness");
+    builder.single_output<float>("Alpha");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
index a18627f2142..4fb5889a057 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
@@ -217,12 +217,13 @@ class SampleFloatSegmentsFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Curve Index"};
-    signature.single_input<float>("Length");
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Curve Index", signature};
+    builder.single_input<float>("Length");
 
-    signature.single_output<int>("Curve Index");
-    signature.single_output<float>("Length in Curve");
-    return signature.build();
+    builder.single_output<int>("Curve Index");
+    builder.single_output<float>("Length in Curve");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -267,14 +268,15 @@ class SampleCurveFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Curve"};
-    signature.single_input<int>("Curve Index");
-    signature.single_input<float>("Length");
-    signature.single_output<float3>("Position");
-    signature.single_output<float3>("Tangent");
-    signature.single_output<float3>("Normal");
-    signature.single_output("Value", src_field_.cpp_type());
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Curve", signature};
+    builder.single_input<int>("Curve Index");
+    builder.single_input<float>("Length");
+    builder.single_output<float3>("Position");
+    builder.single_output<float3>("Tangent");
+    builder.single_output<float3>("Normal");
+    builder.single_output("Value", src_field_.cpp_type());
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
index a93956ba042..1fed3136ee1 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
@@ -93,11 +93,12 @@ class ImageFieldsFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"ImageFunction"};
-    signature.single_input<float3>("Vector");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Alpha");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"ImageFunction", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Alpha");
+    return signature;
   }
 
   static int wrap_periodic(int x, const int width)
diff --git a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
index c3c776e9067..9655df2ef8e 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
@@ -144,11 +144,12 @@ class ProximityFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Geometry Proximity"};
-    signature.single_input<float3>("Source Position");
-    signature.single_output<float3>("Position");
-    signature.single_output<float>("Distance");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Geometry Proximity", signature};
+    builder.single_input<float3>("Source Position");
+    builder.single_output<float3>("Position");
+    builder.single_output<float>("Distance");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
index dbaabbea799..85e545271ec 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
@@ -231,18 +231,19 @@ class RaycastFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Geometry Proximity"};
-    signature.single_input<float3>("Source Position");
-    signature.single_input<float3>("Ray Direction");
-    signature.single_input<float>("Ray Length");
-    signature.single_output<bool>("Is Hit");
-    signature.single_output<float3>("Hit Position");
-    signature.single_output<float3>("Hit Normal");
-    signature.single_output<float>("Distance");
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Geometry Proximity", signature};
+    builder.single_input<float3>("Source Position");
+    builder.single_input<float3>("Ray Direction");
+    builder.single_input<float>("Ray Length");
+    builder.single_output<bool>("Is Hit");
+    builder.single_output<float3>("Hit Position");
+    builder.single_output<float3>("Hit Normal");
+    builder.single_output<float>("Distance");
     if (target_data_) {
-      signature.single_output("Attribute", target_data_->type());
+      builder.single_output("Attribute", target_data_->type());
     }
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc
index 3dd47d37ea8..48b45106f61 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_sample_index.cc
@@ -208,10 +208,11 @@ class SampleIndexFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Index"};
-    signature.single_input<int>("Index");
-    signature.single_output("Value", src_field_.cpp_type());
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Index", signature};
+    builder.single_input<int>("Index");
+    builder.single_output("Value", src_field_.cpp_type());
+    return signature;
   }
 
   void evaluate_field()
diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc
index b38d7f2fec4..cb9e6ca8edd 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc
@@ -253,10 +253,11 @@ class SampleNearestFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Nearest"};
-    signature.single_input<float3>("Position");
-    signature.single_output<int>("Index");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Nearest", signature};
+    builder.single_input<float3>("Position");
+    builder.single_output<int>("Index");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc
index 2628fcf3321..29361251e91 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest_surface.cc
@@ -146,10 +146,11 @@ class SampleNearestSurfaceFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Nearest Surface"};
-    signature.single_input<float3>("Position");
-    signature.single_output("Value", src_field_.cpp_type());
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Nearest Surface", signature};
+    builder.single_input<float3>("Position");
+    builder.single_output("Value", src_field_.cpp_type());
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc
index 7fb4596dfbe..6291c9b4e28 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_sample_uv_surface.cc
@@ -136,11 +136,12 @@ class SampleMeshBarycentricFunction : public fn::MultiFunction {
 
   fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample Barycentric Triangles"};
-    signature.single_input<int>("Triangle Index");
-    signature.single_input<float3>("Barycentric Weight");
-    signature.single_output("Value", src_field_.cpp_type());
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample Barycentric Triangles", signature};
+    builder.single_input<int>("Triangle Index");
+    builder.single_input<float3>("Barycentric Weight");
+    builder.single_output("Value", src_field_.cpp_type());
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -206,12 +207,13 @@ class ReverseUVSampleFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Sample UV Surface"};
-    signature.single_input<float2>("Sample UV");
-    signature.single_output<bool>("Is Valid");
-    signature.single_output<int>("Triangle Index");
-    signature.single_output<float3>("Barycentric Weights");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Sample UV Surface", signature};
+    builder.single_input<float2>("Sample UV");
+    builder.single_output<bool>("Is Valid");
+    builder.single_output<int>("Triangle Index");
+    builder.single_output<float3>("Barycentric Weights");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc b/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc
index f5d405c7678..1f82a91aa1c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc
@@ -100,11 +100,12 @@ class ColorBandFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Color Band"};
-    signature.single_input<float>("Value");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Alpha");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Color Band", signature};
+    builder.single_input<float>("Value");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Alpha");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.cc b/source/blender/nodes/shader/nodes/node_shader_curves.cc
index 0945c39ee50..30452861ff4 100644
--- a/source/blender/nodes/shader/nodes/node_shader_curves.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_curves.cc
@@ -76,11 +76,12 @@ class CurveVecFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Curve Vec"};
-    signature.single_input<float>("Fac");
-    signature.single_input<float3>("Vector");
-    signature.single_output<float3>("Vector");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Curve Vec", signature};
+    builder.single_input<float>("Fac");
+    builder.single_input<float3>("Vector");
+    builder.single_output<float3>("Vector");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -221,11 +222,12 @@ class CurveRGBFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Curve RGB"};
-    signature.single_input<float>("Fac");
-    signature.single_input<ColorGeometry4f>("Color");
-    signature.single_output<ColorGeometry4f>("Color");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Curve RGB", signature};
+    builder.single_input<float>("Fac");
+    builder.single_input<ColorGeometry4f>("Color");
+    builder.single_output<ColorGeometry4f>("Color");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -343,11 +345,12 @@ class CurveFloatFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Curve Float"};
-    signature.single_input<float>("Factor");
-    signature.single_input<float>("Value");
-    signature.single_output<float>("Value");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Curve Float", signature};
+    builder.single_input<float>("Factor");
+    builder.single_input<float>("Value");
+    builder.single_output<float>("Value");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_mix.cc b/source/blender/nodes/shader/nodes/node_shader_mix.cc
index e8255f1f6af..243e752bed7 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mix.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mix.cc
@@ -367,12 +367,13 @@ class MixColorFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"MixColor"};
-    signature.single_input<float>("Factor");
-    signature.single_input<ColorGeometry4f>("A");
-    signature.single_input<ColorGeometry4f>("B");
-    signature.single_output<ColorGeometry4f>("Result");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"MixColor", signature};
+    builder.single_input<float>("Factor");
+    builder.single_input<ColorGeometry4f>("A");
+    builder.single_input<ColorGeometry4f>("B");
+    builder.single_output<ColorGeometry4f>("Result");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc
index aadbdbe4716..74d3a90b13f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc
@@ -105,12 +105,13 @@ class MixRGBFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"MixRGB"};
-    signature.single_input<float>("Fac");
-    signature.single_input<ColorGeometry4f>("Color1");
-    signature.single_input<ColorGeometry4f>("Color2");
-    signature.single_output<ColorGeometry4f>("Color");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"MixRGB", signature};
+    builder.single_input<float>("Fac");
+    builder.single_input<ColorGeometry4f>("Color1");
+    builder.single_input<ColorGeometry4f>("Color2");
+    builder.single_output<ColorGeometry4f>("Color");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc
index 219f31eefd7..9c7e632ebd4 100644
--- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_rgb.cc
@@ -37,12 +37,13 @@ class SeparateRGBFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Separate RGB"};
-    signature.single_input<ColorGeometry4f>("Color");
-    signature.single_output<float>("R");
-    signature.single_output<float>("G");
-    signature.single_output<float>("B");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Separate RGB", signature};
+    builder.single_input<ColorGeometry4f>("Color");
+    builder.single_output<float>("R");
+    builder.single_output<float>("G");
+    builder.single_output<float>("B");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc b/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc
index 1ee6947480c..83f580782a9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcomb_xyz.cc
@@ -37,12 +37,13 @@ class MF_SeparateXYZ : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Separate XYZ"};
-    signature.single_input<float3>("XYZ");
-    signature.single_output<float>("X");
-    signature.single_output<float>("Y");
-    signature.single_output<float>("Z");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Separate XYZ", signature};
+    builder.single_input<float3>("XYZ");
+    builder.single_output<float>("X");
+    builder.single_output<float>("Y");
+    builder.single_output<float>("Z");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
index 502f5db3bf3..80f1b5a73e8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
@@ -128,20 +128,21 @@ class BrickFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"BrickTexture"};
-    signature.single_input<float3>("Vector");
-    signature.single_input<ColorGeometry4f>("Color1");
-    signature.single_input<ColorGeometry4f>("Color2");
-    signature.single_input<ColorGeometry4f>("Mortar");
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Mortar Size");
-    signature.single_input<float>("Mortar Smooth");
-    signature.single_input<float>("Bias");
-    signature.single_input<float>("Brick Width");
-    signature.single_input<float>("Row Height");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Fac");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"BrickTexture", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_input<ColorGeometry4f>("Color1");
+    builder.single_input<ColorGeometry4f>("Color2");
+    builder.single_input<ColorGeometry4f>("Mortar");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Mortar Size");
+    builder.single_input<float>("Mortar Smooth");
+    builder.single_input<float>("Bias");
+    builder.single_input<float>("Brick Width");
+    builder.single_input<float>("Row Height");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    return signature;
   }
 
   /* Fast integer noise. */
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
index bef3eb990eb..61c85b136f8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
@@ -54,14 +54,15 @@ class NodeTexChecker : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"Checker"};
-    signature.single_input<float3>("Vector");
-    signature.single_input<ColorGeometry4f>("Color1");
-    signature.single_input<ColorGeometry4f>("Color2");
-    signature.single_input<float>("Scale");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Fac");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Checker", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_input<ColorGeometry4f>("Color1");
+    builder.single_input<ColorGeometry4f>("Color2");
+    builder.single_input<float>("Scale");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
index f7bff442420..d1c2990d7e2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
@@ -60,11 +60,12 @@ class GradientFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"GradientFunction"};
-    signature.single_input<float3>("Vector");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Fac");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"GradientFunction", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
index f68f1747b21..5692bfe7770 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
@@ -61,13 +61,14 @@ class MagicFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"MagicFunction"};
-    signature.single_input<float3>("Vector");
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Distortion");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Fac");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"MagicFunction", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Distortion");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
index e79b12b78b9..45b9d42e76c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
@@ -167,31 +167,32 @@ class MusgraveFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(const int dimensions, const int musgrave_type)
   {
-    fn::MFSignatureBuilder signature{"Musgrave"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Musgrave", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Detail");
-    signature.single_input<float>("Dimension");
-    signature.single_input<float>("Lacunarity");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Detail");
+    builder.single_input<float>("Dimension");
+    builder.single_input<float>("Lacunarity");
     if (ELEM(musgrave_type,
              SHD_MUSGRAVE_RIDGED_MULTIFRACTAL,
              SHD_MUSGRAVE_HYBRID_MULTIFRACTAL,
              SHD_MUSGRAVE_HETERO_TERRAIN)) {
-      signature.single_input<float>("Offset");
+      builder.single_input<float>("Offset");
     }
     if (ELEM(musgrave_type, SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, SHD_MUSGRAVE_HYBRID_MULTIFRACTAL)) {
-      signature.single_input<float>("Gain");
+      builder.single_input<float>("Gain");
     }
 
-    signature.single_output<float>("Fac");
+    builder.single_output<float>("Fac");
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
index d72e9c3c451..3a4a97d0a1a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
@@ -100,24 +100,25 @@ class NoiseFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(int dimensions)
   {
-    fn::MFSignatureBuilder signature{"Noise"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"Noise", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
 
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Detail");
-    signature.single_input<float>("Roughness");
-    signature.single_input<float>("Distortion");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Detail");
+    builder.single_input<float>("Roughness");
+    builder.single_input<float>("Distortion");
 
-    signature.single_output<float>("Fac");
-    signature.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    builder.single_output<ColorGeometry4f>("Color");
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
index f07ef1b6c60..a02cb3c046a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
@@ -209,31 +209,32 @@ class VoronoiMinowskiFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(int dimensions, int feature)
   {
-    fn::MFSignatureBuilder signature{"voronoi_minowski"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"voronoi_minowski", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
-    signature.single_input<float>("Scale");
+    builder.single_input<float>("Scale");
     if (feature == SHD_VORONOI_SMOOTH_F1) {
-      signature.single_input<float>("Smoothness");
+      builder.single_input<float>("Smoothness");
     }
-    signature.single_input<float>("Exponent");
-    signature.single_input<float>("Randomness");
-    signature.single_output<float>("Distance");
-    signature.single_output<ColorGeometry4f>("Color");
+    builder.single_input<float>("Exponent");
+    builder.single_input<float>("Randomness");
+    builder.single_output<float>("Distance");
+    builder.single_output<ColorGeometry4f>("Color");
 
     if (dimensions != 1) {
-      signature.single_output<float3>("Position");
+      builder.single_output<float3>("Position");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_output<float>("W");
+      builder.single_output<float>("W");
     }
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -646,30 +647,31 @@ class VoronoiMetricFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(int dimensions, int feature)
   {
-    fn::MFSignatureBuilder signature{"voronoi_metric"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"voronoi_metric", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
-    signature.single_input<float>("Scale");
+    builder.single_input<float>("Scale");
     if (feature == SHD_VORONOI_SMOOTH_F1) {
-      signature.single_input<float>("Smoothness");
+      builder.single_input<float>("Smoothness");
     }
-    signature.single_input<float>("Randomness");
-    signature.single_output<float>("Distance");
-    signature.single_output<ColorGeometry4f>("Color");
+    builder.single_input<float>("Randomness");
+    builder.single_output<float>("Distance");
+    builder.single_output<ColorGeometry4f>("Color");
 
     if (dimensions != 1) {
-      signature.single_output<float3>("Position");
+      builder.single_output<float3>("Position");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_output<float>("W");
+      builder.single_output<float>("W");
     }
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
@@ -1158,25 +1160,26 @@ class VoronoiEdgeFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(int dimensions, int feature)
   {
-    fn::MFSignatureBuilder signature{"voronoi_edge"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"voronoi_edge", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Randomness");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Randomness");
 
     if (feature == SHD_VORONOI_DISTANCE_TO_EDGE) {
-      signature.single_output<float>("Distance");
+      builder.single_output<float>("Distance");
     }
     if (feature == SHD_VORONOI_N_SPHERE_RADIUS) {
-      signature.single_output<float>("Radius");
+      builder.single_output<float>("Radius");
     }
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
index f4effe28815..d2be2487489 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
@@ -100,17 +100,18 @@ class WaveFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature()
   {
-    fn::MFSignatureBuilder signature{"MagicFunction"};
-    signature.single_input<float3>("Vector");
-    signature.single_input<float>("Scale");
-    signature.single_input<float>("Distortion");
-    signature.single_input<float>("Detail");
-    signature.single_input<float>("Detail Scale");
-    signature.single_input<float>("Detail Roughness");
-    signature.single_input<float>("Phase Offset");
-    signature.single_output<ColorGeometry4f>("Color");
-    signature.single_output<float>("Fac");
-    return signature.build();
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"MagicFunction", signature};
+    builder.single_input<float3>("Vector");
+    builder.single_input<float>("Scale");
+    builder.single_input<float>("Distortion");
+    builder.single_input<float>("Detail");
+    builder.single_input<float>("Detail Scale");
+    builder.single_input<float>("Detail Roughness");
+    builder.single_input<float>("Phase Offset");
+    builder.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Fac");
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
index 58787a9afa3..0a4ac73b277 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
@@ -82,19 +82,20 @@ class WhiteNoiseFunction : public fn::MultiFunction {
 
   static fn::MFSignature create_signature(int dimensions)
   {
-    fn::MFSignatureBuilder signature{"WhiteNoise"};
+    fn::MFSignature signature;
+    fn::MFSignatureBuilder builder{"WhiteNoise", signature};
 
     if (ELEM(dimensions, 2, 3, 4)) {
-      signature.single_input<float3>("Vector");
+      builder.single_input<float3>("Vector");
     }
     if (ELEM(dimensions, 1, 4)) {
-      signature.single_input<float>("W");
+      builder.single_input<float>("W");
     }
 
-    signature.single_output<float>("Value");
-    signature.single_output<ColorGeometry4f>("Color");
+    builder.single_output<float>("Value");
+    builder.single_output<ColorGeometry4f>("Color");
 
-    return signature.build();
+    return signature;
   }
 
   void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override