Geometry Nodes: add namespace for every file

This puts all static functions in geometry node files into a new
namespace. This allows using unity build which can improve
compile times significantly (P2578).

* The name space name is derived from the file name. That makes
  it possible to write some tooling that checks the names later on.
  The file name extension (`cc`) is added to the namespace name as
  well. This also possibly simplifies tooling but also makes it more
  obvious that this namespace is specific to a file.
* In the register function of every node, I added a namespace alias
  `namespace file_ns = blender::nodes::node_geo_*_cc;`. This avoids
  some duplication of the file name and may also simplify tooling,
  because this line is easy to detect. The name `file_ns` stands for "file
  namespace" and also indicates that this namespace corresponds to
  the current file. In the beginning I used `node_ns` but `file_ns` is more
  generic which may make it more suitable when we want to use unity
  builds outside of the nodes modules in the future.
* Some node files contain code that is actually shared between
  different nodes. For now I left that code in the `blender::nodes`
  namespace and moved it to the top of the file (couldn't move it to
  the bottom in all cases, so I just moved it to the top everywhere).
  As a separate cleanup step, this shared code should actually be
  moved to a separate file.

Differential Revision: https://developer.blender.org/D13330

135 files changed, 1348 insertions, 1041 deletions

diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc
index dc7c251d034..c99db5b1f3f 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc
@@ -22,7 +22,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_align_rotation_to_vector_cc {
 
 static void geo_node_align_rotation_to_vector_declare(NodeDeclarationBuilder &b)
 {
@@ -219,10 +219,12 @@ static void geo_node_align_rotation_to_vector_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_align_rotation_to_vector_cc
 
 void register_node_type_geo_align_rotation_to_vector()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_align_rotation_to_vector_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -230,14 +232,14 @@ void register_node_type_geo_align_rotation_to_vector()
                      "Align Rotation to Vector",
                      NODE_CLASS_GEOMETRY,
                      0);
-  node_type_init(&ntype, blender::nodes::geo_node_align_rotation_to_vector_init);
-  node_type_update(&ntype, blender::nodes::geo_node_align_rotation_to_vector_update);
+  node_type_init(&ntype, file_ns::geo_node_align_rotation_to_vector_init);
+  node_type_update(&ntype, file_ns::geo_node_align_rotation_to_vector_update);
   node_type_storage(&ntype,
                     "NodeGeometryAlignRotationToVector",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_align_rotation_to_vector_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_align_rotation_to_vector_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_align_rotation_to_vector_layout;
+  ntype.declare = file_ns::geo_node_align_rotation_to_vector_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_align_rotation_to_vector_exec;
+  ntype.draw_buttons = file_ns::geo_node_align_rotation_to_vector_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_clamp.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_clamp.cc
index a11a1bd3825..96ca3b6739e 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_clamp.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_clamp.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_clamp_cc {
 
 static void geo_node_attribute_clamp_declare(NodeDeclarationBuilder &b)
 {
@@ -262,19 +262,21 @@ static void geo_node_attribute_clamp_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_clamp_cc
 
 void register_node_type_geo_attribute_clamp()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_clamp_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_CLAMP, "Attribute Clamp", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_clamp_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_clamp_update);
-  ntype.declare = blender::nodes::geo_node_attribute_clamp_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_clamp_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_clamp_layout;
+  node_type_init(&ntype, file_ns::geo_node_attribute_clamp_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_clamp_update);
+  ntype.declare = file_ns::geo_node_attribute_clamp_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_clamp_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_clamp_layout;
   node_type_storage(
       &ntype, "NodeAttributeClamp", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_color_ramp.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_color_ramp.cc
index 061f5f3d7ee..a1ce2f6b005 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_color_ramp.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_color_ramp.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attributes_color_ramp_cc {
 
 static void geo_node_attribute_color_ramp_declare(NodeDeclarationBuilder &b)
 {
@@ -119,10 +119,12 @@ static void geo_node_attribute_color_ramp_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attributes_color_ramp_cc
 
 void register_node_type_geo_attribute_color_ramp()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attributes_color_ramp_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -132,10 +134,10 @@ void register_node_type_geo_attribute_color_ramp()
                      0);
   node_type_storage(
       &ntype, "NodeAttributeColorRamp", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_color_ramp_init);
+  node_type_init(&ntype, file_ns::geo_node_attribute_color_ramp_init);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  ntype.declare = blender::nodes::geo_node_attribute_color_ramp_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_color_ramp_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_color_ramp_layout;
+  ntype.declare = file_ns::geo_node_attribute_color_ramp_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_color_ramp_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_color_ramp_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_combine_xyz.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_combine_xyz.cc
index a610356955b..31721bf7c6a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_combine_xyz.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_combine_xyz.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_combine_xyz_cc {
 
 static void geo_node_attribute_combine_xyz_declare(NodeDeclarationBuilder &b)
 {
@@ -130,10 +130,12 @@ static void geo_node_attribute_combine_xyz_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_combine_xyz_cc
 
 void register_node_type_geo_attribute_combine_xyz()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_combine_xyz_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -141,13 +143,13 @@ void register_node_type_geo_attribute_combine_xyz()
                      "Attribute Combine XYZ",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_combine_xyz_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_combine_xyz_update);
+  node_type_init(&ntype, file_ns::geo_node_attribute_combine_xyz_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_combine_xyz_update);
   node_type_storage(
       &ntype, "NodeAttributeCombineXYZ", node_free_standard_storage, node_copy_standard_storage);
 
-  ntype.declare = blender::nodes::geo_node_attribute_combine_xyz_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_combine_xyz_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_combine_xyz_layout;
+  ntype.declare = file_ns::geo_node_attribute_combine_xyz_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_combine_xyz_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_combine_xyz_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_compare.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_compare.cc
index a4ffe884999..94c0652819b 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_compare.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_compare.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_compare_cc {
 
 static void geo_node_attribute_compare_declare(NodeDeclarationBuilder &b)
 {
@@ -341,20 +341,22 @@ static void geo_node_attribute_compare_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_compare_cc
 
 void register_node_type_geo_attribute_compare()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_compare_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_COMPARE, "Attribute Compare", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.declare = blender::nodes::geo_node_attribute_compare_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_compare_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_compare_layout;
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_compare_update);
+  ntype.declare = file_ns::geo_node_attribute_compare_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_compare_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_compare_layout;
+  node_type_update(&ntype, file_ns::geo_node_attribute_compare_update);
   node_type_storage(
       &ntype, "NodeAttributeCompare", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_compare_init);
+  node_type_init(&ntype, file_ns::geo_node_attribute_compare_init);
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_convert.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_convert.cc
index 13ba8d13618..f2e12a4be8a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_convert.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_convert.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_convert_cc {
 
 static void geo_node_attribute_convert_declare(NodeDeclarationBuilder &b)
 {
@@ -175,18 +175,20 @@ static void geo_node_attribute_convert_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_convert_cc
 
 void register_node_type_geo_attribute_convert()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_convert_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_CONVERT, "Attribute Convert", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.declare = blender::nodes::geo_node_attribute_convert_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_convert_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_convert_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_convert_init);
+  ntype.declare = file_ns::geo_node_attribute_convert_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_convert_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_convert_layout;
+  node_type_init(&ntype, file_ns::geo_node_attribute_convert_init);
   node_type_storage(
       &ntype, "NodeAttributeConvert", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_curve_map.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_curve_map.cc
index af56df0dc3f..9b6a48118c0 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_curve_map.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_curve_map.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_curve_map_cc {
 
 static void geo_node_attribute_curve_map_declare(NodeDeclarationBuilder &b)
 {
@@ -203,23 +203,25 @@ static void geo_node_attribute_curve_map_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_curve_map_cc
 
 void register_node_type_geo_attribute_curve_map()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_curve_map_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_CURVE_MAP, "Attribute Curve Map", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_curve_map_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_curve_map_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_curve_map_update);
+  node_type_init(&ntype, file_ns::geo_node_attribute_curve_map_init);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
   node_type_storage(&ntype,
                     "NodeAttributeCurveMap",
-                    blender::nodes::geo_node_attribute_curve_map_free_storage,
-                    blender::nodes::geo_node_attribute_curve_map_copy_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_curve_map_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_curve_map_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_curve_map_layout;
+                    file_ns::geo_node_attribute_curve_map_free_storage,
+                    file_ns::geo_node_attribute_curve_map_copy_storage);
+  ntype.declare = file_ns::geo_node_attribute_curve_map_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_curve_map_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_curve_map_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_fill.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_fill.cc
index a1b537e9657..3c911cfe3d7 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_fill.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_fill.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_fill_cc {
 
 static void geo_node_attribute_fill_declare(NodeDeclarationBuilder &b)
 {
@@ -146,18 +146,20 @@ static void geo_node_attribute_fill_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_fill_cc
 
 void register_node_type_geo_attribute_fill()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_fill_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_FILL, "Attribute Fill", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_fill_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_fill_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_fill_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_fill_layout;
-  ntype.declare = blender::nodes::geo_node_attribute_fill_declare;
+  node_type_init(&ntype, file_ns::geo_node_attribute_fill_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_fill_update);
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_fill_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_fill_layout;
+  ntype.declare = file_ns::geo_node_attribute_fill_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_map_range.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_map_range.cc
index 2c70157d586..9776cc9fd18 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_map_range.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_map_range.cc
@@ -22,7 +22,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_map_range_cc {
 
 static void geo_node_attribute_map_range_declare(NodeDeclarationBuilder &b)
 {
@@ -416,20 +416,22 @@ static void geo_node_attribute_map_range_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_map_range_cc
 
 void register_node_type_geo_attribute_map_range()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_map_range_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MAP_RANGE, "Attribute Map Range", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_map_range_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_map_range_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_map_range_update);
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_map_range_exec;
+  node_type_init(&ntype, file_ns::geo_node_attribute_map_range_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_map_range_update);
   node_type_storage(
       &ntype, "NodeAttributeMapRange", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_map_range_declare;
-  ntype.draw_buttons = blender::nodes::fn_attribute_map_range_layout;
+  ntype.declare = file_ns::geo_node_attribute_map_range_declare;
+  ntype.draw_buttons = file_ns::fn_attribute_map_range_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_math.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_math.cc
index 193db7355f9..4e53e57b4d0 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_math.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_math.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_math_cc {
 
 static void geo_node_attribute_math_declare(NodeDeclarationBuilder &b)
 {
@@ -297,20 +297,22 @@ static void geo_node_attribute_math_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_math_cc
 
 void register_node_type_geo_attribute_math()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_math_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MATH, "Attribute Math", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.declare = blender::nodes::geo_node_attribute_math_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_math_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_math_layout;
-  node_type_label(&ntype, blender::nodes::geo_node_math_label);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_math_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_math_init);
+  ntype.declare = file_ns::geo_node_attribute_math_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_math_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_math_layout;
+  node_type_label(&ntype, file_ns::geo_node_math_label);
+  node_type_update(&ntype, file_ns::geo_node_attribute_math_update);
+  node_type_init(&ntype, file_ns::geo_node_attribute_math_init);
   node_type_storage(
       &ntype, "NodeAttributeMath", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_mix.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_mix.cc
index 6c7f2313633..af9e42be9a4 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_mix.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_mix.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_mix_cc {
 
 static void geo_node_mix_attribute_declare(NodeDeclarationBuilder &b)
 {
@@ -241,19 +241,21 @@ static void geo_node_attribute_mix_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_mix_cc
 
 void register_node_type_geo_attribute_mix()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_mix_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MIX, "Attribute Mix", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_mix_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_mix_update);
-  ntype.declare = blender::nodes::geo_node_mix_attribute_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_mix_layout;
+  node_type_init(&ntype, file_ns::geo_node_attribute_mix_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_mix_update);
+  ntype.declare = file_ns::geo_node_mix_attribute_declare;
+  ntype.draw_buttons = file_ns::geo_node_attribute_mix_layout;
   node_type_storage(
       &ntype, "NodeAttributeMix", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_mix_exec;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_mix_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc
index 0122f9b7598..152e09afcd4 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_proximity_cc {
 
 static void geo_node_attribute_proximity_declare(NodeDeclarationBuilder &b)
 {
@@ -230,22 +230,24 @@ static void geo_node_attribute_proximity_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_proximity_cc
 
 void register_node_type_geo_legacy_attribute_proximity()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_proximity_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_PROXIMITY, "Attribute Proximity", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_attribute_proximity_init);
+  node_type_init(&ntype, file_ns::geo_attribute_proximity_init);
   node_type_storage(&ntype,
                     "NodeGeometryAttributeProximity",
                     node_free_standard_storage,
                     node_copy_standard_storage);
 
-  ntype.declare = blender::nodes::geo_node_attribute_proximity_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_proximity_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_proximity_layout;
+  ntype.declare = file_ns::geo_node_attribute_proximity_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_proximity_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_proximity_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_randomize.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_randomize.cc
index f8d9dcdaf87..8f87e3c5cce 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_randomize.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_randomize.cc
@@ -25,6 +25,40 @@
 
 namespace blender::nodes {
 
+Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
+                                                  const AttributeDomain domain)
+{
+  const int domain_size = component.attribute_domain_size(domain);
+
+  /* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
+  GVArray hash_attribute = component.attribute_try_get_for_read("id", domain);
+  Array<uint32_t> hashes(domain_size);
+  if (hash_attribute) {
+    BLI_assert(hashes.size() == hash_attribute.size());
+    const CPPType &cpp_type = hash_attribute.type();
+    BLI_assert(cpp_type.is_hashable());
+    GVArray_GSpan items{hash_attribute};
+    threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
+      for (const int i : range) {
+        hashes[i] = cpp_type.hash(items[i]);
+      }
+    });
+  }
+  else {
+    /* If there is no "id" attribute for per-point variation, just create it here. */
+    RandomNumberGenerator rng(0);
+    for (const int i : hashes.index_range()) {
+      hashes[i] = rng.get_uint32();
+    }
+  }
+
+  return hashes;
+}
+
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_legacy_attribute_randomize_cc {
+
 static void geo_node_legacy_attribute_randomize_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Geometry"));
@@ -174,36 +208,6 @@ static void randomize_attribute_bool(MutableSpan<bool> span,
   });
 }
 
-Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
-                                                  const AttributeDomain domain)
-{
-  const int domain_size = component.attribute_domain_size(domain);
-
-  /* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
-  GVArray hash_attribute = component.attribute_try_get_for_read("id", domain);
-  Array<uint32_t> hashes(domain_size);
-  if (hash_attribute) {
-    BLI_assert(hashes.size() == hash_attribute.size());
-    const CPPType &cpp_type = hash_attribute.type();
-    BLI_assert(cpp_type.is_hashable());
-    GVArray_GSpan items{hash_attribute};
-    threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
-      for (const int i : range) {
-        hashes[i] = cpp_type.hash(items[i]);
-      }
-    });
-  }
-  else {
-    /* If there is no "id" attribute for per-point variation, just create it here. */
-    RandomNumberGenerator rng(0);
-    for (const int i : hashes.index_range()) {
-      hashes[i] = rng.get_uint32();
-    }
-  }
-
-  return hashes;
-}
-
 static AttributeDomain get_result_domain(const GeometryComponent &component,
                                          const GeoNodeExecParams &params,
                                          const StringRef name)
@@ -324,20 +328,22 @@ static void geo_node_legacy_random_attribute_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_randomize_cc
 
 void register_node_type_geo_legacy_attribute_randomize()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_randomize_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_init);
-  node_type_update(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_update);
+  node_type_init(&ntype, file_ns::geo_node_legacy_attribute_randomize_init);
+  node_type_update(&ntype, file_ns::geo_node_legacy_attribute_randomize_update);
 
-  ntype.declare = blender::nodes::geo_node_legacy_attribute_randomize_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_random_attribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_legacy_attribute_random_layout;
+  ntype.declare = file_ns::geo_node_legacy_attribute_randomize_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_random_attribute_exec;
+  ntype.draw_buttons = file_ns::geo_node_legacy_attribute_random_layout;
   node_type_storage(
       &ntype, "NodeAttributeRandomize", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_sample_texture.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_sample_texture.cc
index 9748ca3f2ad..f2d45651d32 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_sample_texture.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_sample_texture.cc
@@ -28,7 +28,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_sample_texture_cc {
 
 static void geo_node_attribute_sample_texture_declare(NodeDeclarationBuilder &b)
 {
@@ -119,10 +119,12 @@ static void geo_node_attribute_sample_texture_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_sample_texture_cc
 
 void register_node_type_geo_sample_texture()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_sample_texture_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -131,7 +133,7 @@ void register_node_type_geo_sample_texture()
                      NODE_CLASS_ATTRIBUTE,
                      0);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  ntype.declare = blender::nodes::geo_node_attribute_sample_texture_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_sample_texture_exec;
+  ntype.declare = file_ns::geo_node_attribute_sample_texture_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_sample_texture_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_separate_xyz.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_separate_xyz.cc
index bfc69780bf6..e31f76028bd 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_separate_xyz.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_separate_xyz.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_separate_xyz_cc {
 
 static void geo_node_attribute_separate_xyz_declare(NodeDeclarationBuilder &b)
 {
@@ -151,10 +151,12 @@ static void geo_node_attribute_separate_xyz_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_separate_xyz_cc
 
 void register_node_type_geo_attribute_separate_xyz()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_separate_xyz_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -162,12 +164,12 @@ void register_node_type_geo_attribute_separate_xyz()
                      "Attribute Separate XYZ",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  ntype.declare = blender::nodes::geo_node_attribute_separate_xyz_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_separate_xyz_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_separate_xyz_update);
+  ntype.declare = file_ns::geo_node_attribute_separate_xyz_declare;
+  node_type_init(&ntype, file_ns::geo_node_attribute_separate_xyz_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_separate_xyz_update);
   node_type_storage(
       &ntype, "NodeAttributeSeparateXYZ", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_separate_xyz_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_separate_xyz_layout;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_separate_xyz_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_separate_xyz_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc
index b8827f82efc..fbad539951b 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc
@@ -29,7 +29,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_transfer_cc {
 
 static void geo_node_attribute_transfer_declare(NodeDeclarationBuilder &b)
 {
@@ -510,21 +510,23 @@ static void geo_node_attribute_transfer_exec(GeoNodeExecParams params)
   params.set_output("Geometry", dst_geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_transfer_cc
 
 void register_node_type_geo_legacy_attribute_transfer()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_transfer_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_TRANSFER, "Attribute Transfer", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_transfer_init);
+  node_type_init(&ntype, file_ns::geo_node_attribute_transfer_init);
   node_type_storage(&ntype,
                     "NodeGeometryAttributeTransfer",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_transfer_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_transfer_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_transfer_layout;
+  ntype.declare = file_ns::geo_node_attribute_transfer_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_transfer_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_transfer_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_math.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_math.cc
index e7fdd0f2eef..98404530e24 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_math.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_math.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_vector_math_cc {
 
 static void geo_node_attribute_vector_math_declare(NodeDeclarationBuilder &b)
 {
@@ -551,10 +551,12 @@ static void geo_node_attribute_vector_math_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_vector_math_cc
 
 void register_node_type_geo_attribute_vector_math()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_vector_math_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -562,12 +564,12 @@ void register_node_type_geo_attribute_vector_math()
                      "Attribute Vector Math",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  ntype.declare = blender::nodes::geo_node_attribute_vector_math_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_math_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_math_layout;
-  node_type_label(&ntype, blender::nodes::geo_node_vector_math_label);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_math_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_math_init);
+  ntype.declare = file_ns::geo_node_attribute_vector_math_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_vector_math_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_vector_math_layout;
+  node_type_label(&ntype, file_ns::geo_node_vector_math_label);
+  node_type_update(&ntype, file_ns::geo_node_attribute_vector_math_update);
+  node_type_init(&ntype, file_ns::geo_node_attribute_vector_math_init);
   node_type_storage(
       &ntype, "NodeAttributeVectorMath", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_rotate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_rotate.cc
index a6cd24ed72d..4fe7fa0bb80 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_rotate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_rotate.cc
@@ -21,7 +21,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_attribute_vector_rotate_cc {
 
 static void geo_node_attribute_vector_rotate_declare(NodeDeclarationBuilder &b)
 {
@@ -328,10 +328,12 @@ static void geo_node_attribute_vector_rotate_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_attribute_vector_rotate_cc
 
 void register_node_type_geo_attribute_vector_rotate()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_attribute_vector_rotate_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -339,13 +341,13 @@ void register_node_type_geo_attribute_vector_rotate()
                      "Attribute Vector Rotate",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_rotate_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_rotate_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_vector_rotate_update);
+  node_type_init(&ntype, file_ns::geo_node_attribute_vector_rotate_init);
   node_type_size(&ntype, 165, 100, 600);
   node_type_storage(
       &ntype, "NodeAttributeVectorRotate", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_rotate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_rotate_layout;
-  ntype.declare = blender::nodes::geo_node_attribute_vector_rotate_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_vector_rotate_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_vector_rotate_layout;
+  ntype.declare = file_ns::geo_node_attribute_vector_rotate_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_endpoints.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_endpoints.cc
index 67c8200a9c2..2fe82dd1ab4 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_endpoints.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_endpoints.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_endpoints_cc {
 
 static void geo_node_curve_endpoints_declare(NodeDeclarationBuilder &b)
 {
@@ -206,16 +206,18 @@ static void geo_node_curve_endpoints_exec(GeoNodeExecParams params)
   params.set_output("End Points", std::move(end_result));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_endpoints_cc
 
 void register_node_type_geo_legacy_curve_endpoints()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_endpoints_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_ENDPOINTS, "Curve Endpoints", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_endpoints_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoints_exec;
+  ntype.declare = file_ns::geo_node_curve_endpoints_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_endpoints_exec;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_reverse.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_reverse.cc
index bc4612e2b8b..33f0d4bc495 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_reverse.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_reverse.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_reverse_cc {
 
 static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
 {
@@ -58,14 +58,16 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
   params.set_output("Curve", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_reverse_cc
 
 void register_node_type_geo_legacy_curve_reverse()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_reverse_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_REVERSE, "Curve Reverse", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
+  ntype.declare = file_ns::geo_node_curve_reverse_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_reverse_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_select_by_handle_type.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_select_by_handle_type.cc
index 40d827ae141..b8dc3aa1c3a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_select_by_handle_type.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_select_by_handle_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc {
 
 static void geo_node_select_by_handle_type_declare(NodeDeclarationBuilder &b)
 {
@@ -121,10 +121,12 @@ static void geo_node_select_by_handle_type_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc
 
 void register_node_type_geo_legacy_select_by_handle_type()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -132,14 +134,14 @@ void register_node_type_geo_legacy_select_by_handle_type()
                      "Select by Handle Type",
                      NODE_CLASS_GEOMETRY,
                      0);
-  ntype.declare = blender::nodes::geo_node_select_by_handle_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_select_by_handle_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_select_by_handle_type_init);
+  ntype.declare = file_ns::geo_node_select_by_handle_type_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_select_by_handle_type_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_select_by_handle_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSelectHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_select_by_handle_type_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_select_by_handle_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_set_handles.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_set_handles.cc
index b92db315d94..ab669f03942 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_set_handles.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_set_handles.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_set_handles_cc {
 
 static void geo_node_curve_set_handles_decalre(NodeDeclarationBuilder &b)
 {
@@ -124,21 +124,23 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
 
   params.set_output("Curve", geometry_set);
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_set_handles_cc
 
 void register_node_type_geo_legacy_curve_set_handles()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_set_handles_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_set_handles_decalre;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
+  ntype.declare = file_ns::geo_node_curve_set_handles_decalre;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_set_handles_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_set_handles_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSetHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_set_handles_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_spline_type.cc
index 36d4519cac3..4448f94c7cb 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_spline_type.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_spline_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_spline_type_cc {
 
 static void geo_node_legacy_curve_spline_type_declare(NodeDeclarationBuilder &b)
 {
@@ -282,21 +282,23 @@ static void geo_node_legacy_curve_spline_type_exec(GeoNodeExecParams params)
   params.set_output("Curve", GeometrySet::create_with_curve(new_curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_spline_type_cc
 
 void register_node_type_geo_legacy_curve_spline_type()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_spline_type_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_curve_spline_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_curve_spline_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_legacy_curve_spline_type_init);
+  ntype.declare = file_ns::geo_node_legacy_curve_spline_type_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_curve_spline_type_exec;
+  node_type_init(&ntype, file_ns::geo_node_legacy_curve_spline_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSplineType",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_legacy_curve_spline_type_layout;
+  ntype.draw_buttons = file_ns::geo_node_legacy_curve_spline_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_subdivide.cc
index 603547a8e69..76092cb8b79 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_subdivide.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_curve_subdivide_cc {
 
 static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
 {
@@ -370,22 +370,24 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
   params.set_output("Geometry", GeometrySet::create_with_curve(output_curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_subdivide_cc
 
 void register_node_type_geo_legacy_curve_subdivide()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_subdivide_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_SUBDIVIDE, "Curve Subdivide", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_subdivide_layout;
+  ntype.declare = file_ns::geo_node_curve_subdivide_declare;
+  ntype.draw_buttons = file_ns::geo_node_curve_subdivide_layout;
   node_type_storage(&ntype,
                     "NodeGeometryCurveSubdivide",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_subdivide_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_subdivide_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_subdivide_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_subdivide_update);
+  ntype.geometry_node_execute = file_ns::geo_node_subdivide_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc
index ab51258cc69..ede186bc272 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc
@@ -28,6 +28,58 @@
 
 namespace blender::nodes {
 
+static GMutableSpan create_attribute_and_retrieve_span(PointCloudComponent &points,
+                                                       const AttributeIDRef &attribute_id,
+                                                       const CustomDataType data_type)
+{
+  points.attribute_try_create(attribute_id, ATTR_DOMAIN_POINT, data_type, AttributeInitDefault());
+  WriteAttributeLookup attribute = points.attribute_try_get_for_write(attribute_id);
+  BLI_assert(attribute);
+  return attribute.varray.get_internal_span();
+}
+
+template<typename T>
+static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &points,
+                                                         const AttributeIDRef &attribute_id)
+{
+  GMutableSpan attribute = create_attribute_and_retrieve_span(
+      points, attribute_id, bke::cpp_type_to_custom_data_type(CPPType::get<T>()));
+  return attribute.typed<T>();
+}
+
+CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
+                                                              const CurveEval &curve)
+{
+  CurveToPointsResults attributes;
+
+  attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
+
+  attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
+  attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
+  attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
+
+  /* Because of the invariants of the curve component, we use the attributes of the
+   * first spline as a representative for the attribute meta data all splines. */
+  curve.splines().first()->attributes.foreach_attribute(
+      [&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
+        attributes.point_attributes.add_new(
+            attribute_id,
+            create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
+        return true;
+      },
+      ATTR_DOMAIN_POINT);
+
+  attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
+  attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
+  attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
+
+  return attributes;
+}
+
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_legacy_curve_to_points_cc {
+
 static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Geometry"));
@@ -114,54 +166,6 @@ static Array<int> calculate_spline_point_offsets(GeoNodeExecParams &params,
   return {0};
 }
 
-static GMutableSpan create_attribute_and_retrieve_span(PointCloudComponent &points,
-                                                       const AttributeIDRef &attribute_id,
-                                                       const CustomDataType data_type)
-{
-  points.attribute_try_create(attribute_id, ATTR_DOMAIN_POINT, data_type, AttributeInitDefault());
-  WriteAttributeLookup attribute = points.attribute_try_get_for_write(attribute_id);
-  BLI_assert(attribute);
-  return attribute.varray.get_internal_span();
-}
-
-template<typename T>
-static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &points,
-                                                         const AttributeIDRef &attribute_id)
-{
-  GMutableSpan attribute = create_attribute_and_retrieve_span(
-      points, attribute_id, bke::cpp_type_to_custom_data_type(CPPType::get<T>()));
-  return attribute.typed<T>();
-}
-
-CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
-                                                              const CurveEval &curve)
-{
-  CurveToPointsResults attributes;
-
-  attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
-
-  attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
-  attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
-  attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
-
-  /* Because of the invariants of the curve component, we use the attributes of the
-   * first spline as a representative for the attribute meta data all splines. */
-  curve.splines().first()->attributes.foreach_attribute(
-      [&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
-        attributes.point_attributes.add_new(
-            attribute_id,
-            create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
-        return true;
-      },
-      ATTR_DOMAIN_POINT);
-
-  attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
-  attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
-  attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
-
-  return attributes;
-}
-
 /**
  * TODO: For non-poly splines, this has double copies that could be avoided as part
  * of a general look at optimizing uses of #Spline::interpolate_to_evaluated.
@@ -340,21 +344,23 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(result));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_curve_to_points_cc
 
 void register_node_type_geo_legacy_curve_to_points()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_curve_to_points_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
+  ntype.declare = file_ns::geo_node_curve_to_points_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_to_points_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_to_points_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_to_points_update);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_delete_geometry.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_delete_geometry.cc
index 8d7c05ea533..cd43e3c8643 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_delete_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_delete_geometry.cc
@@ -43,7 +43,7 @@ void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
                                    blender::Span<int> masked_poly_indices,
                                    blender::Span<int> new_loop_starts);
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_delete_geometry_cc {
 
 static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -662,16 +662,18 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(out_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_delete_geometry_cc
 
 void register_node_type_geo_legacy_delete_geometry()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_delete_geometry_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
 
-  ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
+  ntype.declare = file_ns::geo_node_delete_geometry_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_delete_geometry_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_edge_split.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_edge_split.cc
index 8f2bf05d2b4..3c147004d6b 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_edge_split.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_edge_split.cc
@@ -22,7 +22,7 @@ extern "C" {
 Mesh *doEdgeSplit(const Mesh *mesh, EdgeSplitModifierData *emd);
 }
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_edge_split_cc {
 
 static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
 {
@@ -76,14 +76,16 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_edge_split_cc
 
 void register_node_type_geo_legacy_edge_split()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_edge_split_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_EDGE_SPLIT, "Edge Split", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
-  ntype.declare = blender::nodes::geo_node_edge_split_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_edge_split_exec;
+  ntype.declare = file_ns::geo_node_edge_split_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_material_assign.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_material_assign.cc
index 58374679a95..c524178c2e4 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_material_assign.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_material_assign.cc
@@ -24,7 +24,7 @@
 
 #include "BKE_material.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_material_assign_cc {
 
 static void geo_node_legacy_material_assign_declare(NodeDeclarationBuilder &b)
 {
@@ -81,15 +81,17 @@ static void geo_node_legacy_material_assign_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_material_assign_cc
 
 void register_node_type_geo_legacy_material_assign()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_material_assign_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_MATERIAL_ASSIGN, "Material Assign", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_material_assign_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_material_assign_exec;
+  ntype.declare = file_ns::geo_node_legacy_material_assign_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_material_assign_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_mesh_to_curve.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_mesh_to_curve.cc
index 321de24a3dc..4461c861fc3 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_mesh_to_curve.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_mesh_to_curve.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_mesh_to_curve_cc {
 
 static void geo_node_legacy_mesh_to_curve_declare(NodeDeclarationBuilder &b)
 {
@@ -65,15 +65,17 @@ static void geo_node_legacy_mesh_to_curve_exec(GeoNodeExecParams params)
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_mesh_to_curve_cc
 
 void register_node_type_geo_legacy_mesh_to_curve()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_mesh_to_curve_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_MESH_TO_CURVE, "Mesh to Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_mesh_to_curve_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_mesh_to_curve_exec;
+  ntype.declare = file_ns::geo_node_legacy_mesh_to_curve_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_mesh_to_curve_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_distribute.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_distribute.cc
index 4e13a490d89..b1ce8a95bbc 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_distribute.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_distribute.cc
@@ -36,9 +36,9 @@
 
 #include "node_geometry_util.hh"
 
-using blender::bke::GeometryInstanceGroup;
+namespace blender::nodes::node_geo_legacy_point_distribute_cc {
 
-namespace blender::nodes {
+using blender::bke::GeometryInstanceGroup;
 
 static void geo_node_point_distribute_declare(NodeDeclarationBuilder &b)
 {
@@ -655,17 +655,19 @@ static void geo_node_point_distribute_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set_out));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_distribute_cc
 
 void register_node_type_geo_point_distribute()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_distribute_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_DISTRIBUTE, "Point Distribute", NODE_CLASS_GEOMETRY, 0);
-  node_type_update(&ntype, blender::nodes::node_point_distribute_update);
-  ntype.declare = blender::nodes::geo_node_point_distribute_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_distribute_layout;
+  node_type_update(&ntype, file_ns::node_point_distribute_update);
+  ntype.declare = file_ns::geo_node_point_distribute_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_point_distribute_exec;
+  ntype.draw_buttons = file_ns::geo_node_point_distribute_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_instance.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_instance.cc
index 713971941ea..69ebe7d3604 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_instance.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_instance.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_point_instance_cc {
 
 static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
 {
@@ -255,20 +255,22 @@ static void geo_node_point_instance_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set_out));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_instance_cc
 
 void register_node_type_geo_point_instance()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_instance_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_INSTANCE, "Point Instance", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_point_instance_init);
+  node_type_init(&ntype, file_ns::geo_node_point_instance_init);
   node_type_storage(
       &ntype, "NodeGeometryPointInstance", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_point_instance_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_point_instance_layout;
-  node_type_update(&ntype, blender::nodes::geo_node_point_instance_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_instance_exec;
+  ntype.declare = file_ns::geo_node_point_instance_declare;
+  ntype.draw_buttons = file_ns::geo_node_point_instance_layout;
+  node_type_update(&ntype, file_ns::geo_node_point_instance_update);
+  ntype.geometry_node_execute = file_ns::geo_node_point_instance_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_rotate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_rotate.cc
index ab1d68bfe4f..bd2064fa22a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_rotate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_rotate.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_point_rotate_cc {
 
 static void geo_node_point_rotate_declare(NodeDeclarationBuilder &b)
 {
@@ -218,19 +218,21 @@ static void geo_node_point_rotate_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_rotate_cc
 
 void register_node_type_geo_point_rotate()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_rotate_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_ROTATE, "Point Rotate", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_point_rotate_init);
-  node_type_update(&ntype, blender::nodes::geo_node_point_rotate_update);
+  node_type_init(&ntype, file_ns::geo_node_point_rotate_init);
+  node_type_update(&ntype, file_ns::geo_node_point_rotate_update);
   node_type_storage(
       &ntype, "NodeGeometryRotatePoints", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_point_rotate_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_rotate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_rotate_layout;
+  ntype.declare = file_ns::geo_node_point_rotate_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_point_rotate_exec;
+  ntype.draw_buttons = file_ns::geo_node_point_rotate_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_scale.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_scale.cc
index 8d6345ce6b1..b48bf3a4556 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_scale.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_scale.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_point_scale_cc {
 
 static void geo_node_point_scale_declare(NodeDeclarationBuilder &b)
 {
@@ -120,20 +120,22 @@ static void geo_node_point_scale_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_scale_cc
 
 void register_node_type_geo_point_scale()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_scale_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_SCALE, "Point Scale", NODE_CLASS_GEOMETRY, 0);
 
-  ntype.declare = blender::nodes::geo_node_point_scale_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_point_scale_init);
-  node_type_update(&ntype, blender::nodes::geo_node_point_scale_update);
+  ntype.declare = file_ns::geo_node_point_scale_declare;
+  node_type_init(&ntype, file_ns::geo_node_point_scale_init);
+  node_type_update(&ntype, file_ns::geo_node_point_scale_update);
   node_type_storage(
       &ntype, "NodeGeometryPointScale", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_scale_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_scale_layout;
+  ntype.geometry_node_execute = file_ns::geo_node_point_scale_exec;
+  ntype.draw_buttons = file_ns::geo_node_point_scale_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_separate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_separate.cc
index 3539fe2de64..f420dc549a0 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_separate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_separate.cc
@@ -25,14 +25,6 @@
 
 namespace blender::nodes {
 
-static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Geometry>(N_("Geometry"));
-  b.add_input<decl::String>(N_("Mask"));
-  b.add_output<decl::Geometry>(N_("Geometry 1"));
-  b.add_output<decl::Geometry>(N_("Geometry 2"));
-}
-
 template<typename T>
 static void copy_data_based_on_mask(Span<T> data,
                                     Span<bool> masks,
@@ -78,6 +70,18 @@ void copy_point_attributes_based_on_mask(const GeometryComponent &in_component,
   }
 }
 
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_legacy_point_separate_cc {
+
+static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Geometry>(N_("Geometry"));
+  b.add_input<decl::String>(N_("Mask"));
+  b.add_output<decl::Geometry>(N_("Geometry 1"));
+  b.add_output<decl::Geometry>(N_("Geometry 2"));
+}
+
 static void create_component_points(GeometryComponent &component, const int total)
 {
   switch (component.type()) {
@@ -158,16 +162,18 @@ static void geo_node_point_separate_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_separate_cc
 
 void register_node_type_geo_point_separate()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_separate_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_SEPARATE, "Point Separate", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_point_instance_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_separate_exec;
+  ntype.declare = file_ns::geo_node_point_instance_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_point_separate_exec;
   ntype.geometry_node_execute_supports_laziness = true;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_translate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_translate.cc
index 3b2959beb86..cf9d4f2fdcd 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_translate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_translate.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_point_translate_cc {
 
 static void geo_node_point_translate_declare(NodeDeclarationBuilder &b)
 {
@@ -89,22 +89,24 @@ static void geo_node_point_translate_update(bNodeTree *ntree, bNode *node)
       *ntree, *node, "Translation", (GeometryNodeAttributeInputMode)node_storage.input_type);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_point_translate_cc
 
 void register_node_type_geo_point_translate()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_point_translate_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_TRANSLATE, "Point Translate", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_point_translate_init);
-  node_type_update(&ntype, blender::nodes::geo_node_point_translate_update);
+  node_type_init(&ntype, file_ns::geo_node_point_translate_init);
+  node_type_update(&ntype, file_ns::geo_node_point_translate_update);
   node_type_storage(&ntype,
                     "NodeGeometryPointTranslate",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_point_translate_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_translate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_translate_layout;
+  ntype.declare = file_ns::geo_node_point_translate_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_point_translate_exec;
+  ntype.draw_buttons = file_ns::geo_node_point_translate_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc
index d465a9ab1a8..d134377e56f 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc
@@ -28,7 +28,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_points_to_volume_cc {
 
 static void geo_node_points_to_volume_declare(NodeDeclarationBuilder &b)
 {
@@ -259,10 +259,12 @@ static void geo_node_points_to_volume_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set_out));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_points_to_volume_cc
 
 void register_node_type_geo_legacy_points_to_volume()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_points_to_volume_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
@@ -272,10 +274,10 @@ void register_node_type_geo_legacy_points_to_volume()
                     node_free_standard_storage,
                     node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_points_to_volume_init);
-  node_type_update(&ntype, blender::nodes::geo_node_points_to_volume_update);
-  ntype.declare = blender::nodes::geo_node_points_to_volume_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_points_to_volume_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_points_to_volume_layout;
+  node_type_init(&ntype, file_ns::geo_node_points_to_volume_init);
+  node_type_update(&ntype, file_ns::geo_node_points_to_volume_update);
+  ntype.declare = file_ns::geo_node_points_to_volume_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_points_to_volume_exec;
+  ntype.draw_buttons = file_ns::geo_node_points_to_volume_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc
index 5aa683ca232..e3d092e9413 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_raycast_cc {
 
 static void geo_node_raycast_declare(NodeDeclarationBuilder &b)
 {
@@ -307,20 +307,22 @@ static void geo_node_raycast_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_raycast_cc
 
 void register_node_type_geo_legacy_raycast()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_raycast_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_RAYCAST, "Raycast", NODE_CLASS_GEOMETRY, 0);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  node_type_init(&ntype, blender::nodes::geo_node_raycast_init);
-  node_type_update(&ntype, blender::nodes::geo_node_raycast_update);
+  node_type_init(&ntype, file_ns::geo_node_raycast_init);
+  node_type_update(&ntype, file_ns::geo_node_raycast_update);
   node_type_storage(
       &ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_raycast_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_raycast_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_raycast_layout;
+  ntype.declare = file_ns::geo_node_raycast_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_raycast_exec;
+  ntype.draw_buttons = file_ns::geo_node_raycast_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_select_by_material.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_select_by_material.cc
index a8d6f33a5fd..681cd1547d2 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_select_by_material.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_select_by_material.cc
@@ -26,7 +26,7 @@
 
 #include "BKE_material.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_select_by_material_cc {
 
 static void geo_node_legacy_select_by_material_declare(NodeDeclarationBuilder &b)
 {
@@ -78,15 +78,17 @@ static void geo_node_legacy_select_by_material_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_select_by_material_cc
 
 void register_node_type_geo_legacy_select_by_material()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_select_by_material_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_SELECT_BY_MATERIAL, "Select by Material", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_select_by_material_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_select_by_material_exec;
+  ntype.declare = file_ns::geo_node_legacy_select_by_material_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_select_by_material_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_subdivision_surface.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_subdivision_surface.cc
index 295cd05fd01..2cdcdd7f35c 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_subdivision_surface.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_subdivision_surface.cc
@@ -23,7 +23,7 @@
 #include "UI_resources.h"
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_subdivision_surface_cc {
 
 static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
 {
@@ -126,18 +126,20 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_subdivision_surface_cc
 
 void register_node_type_geo_legacy_subdivision_surface()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_subdivision_surface_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
+  ntype.declare = file_ns::geo_node_subdivision_surface_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_subdivision_surface_exec;
+  ntype.draw_buttons = file_ns::geo_node_subdivision_surface_layout;
+  node_type_init(&ntype, file_ns::geo_node_subdivision_surface_init);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
   node_type_storage(&ntype,
                     "NodeGeometrySubdivisionSurface",
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_volume_to_mesh.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_volume_to_mesh.cc
index 6a52b943967..5ae9d4ea0c6 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_volume_to_mesh.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_volume_to_mesh.cc
@@ -35,7 +35,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_legacy_volume_to_mesh_cc {
 
 static void geo_node_volume_to_mesh_declare(NodeDeclarationBuilder &b)
 {
@@ -155,21 +155,23 @@ static void geo_node_volume_to_mesh_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set_out);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_legacy_volume_to_mesh_cc
 
 void register_node_type_geo_legacy_volume_to_mesh()
 {
+  namespace file_ns = blender::nodes::node_geo_legacy_volume_to_mesh_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_VOLUME_TO_MESH, "Volume to Mesh", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_volume_to_mesh_declare;
+  ntype.declare = file_ns::geo_node_volume_to_mesh_declare;
   node_type_storage(
       &ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_volume_to_mesh_init);
-  node_type_update(&ntype, blender::nodes::geo_node_volume_to_mesh_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_volume_to_mesh_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_volume_to_mesh_layout;
+  node_type_init(&ntype, file_ns::geo_node_volume_to_mesh_init);
+  node_type_update(&ntype, file_ns::geo_node_volume_to_mesh_update);
+  ntype.geometry_node_execute = file_ns::geo_node_volume_to_mesh_exec;
+  ntype.draw_buttons = file_ns::geo_node_volume_to_mesh_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
index 1cb26646d5a..5916ecddebe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_attribute_capture_cc {
 
 static void geo_node_attribute_capture_declare(NodeDeclarationBuilder &b)
 {
@@ -200,10 +200,12 @@ static void geo_node_attribute_capture_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_attribute_capture_cc
 
 void register_node_type_geo_attribute_capture()
 {
+  namespace file_ns = blender::nodes::node_geo_attribute_capture_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
@@ -212,10 +214,10 @@ void register_node_type_geo_attribute_capture()
                     "NodeGeometryAttributeCapture",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_capture_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_capture_update);
-  ntype.declare = blender::nodes::geo_node_attribute_capture_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_capture_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_capture_layout;
+  node_type_init(&ntype, file_ns::geo_node_attribute_capture_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_capture_update);
+  ntype.declare = file_ns::geo_node_attribute_capture_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_capture_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_capture_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_remove.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_remove.cc
index f80b8ccc971..fa3e40bc425 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_remove.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_remove.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_attribute_remove_cc {
 
 static void geo_node_attribute_remove_declare(NodeDeclarationBuilder &b)
 {
@@ -66,15 +66,17 @@ static void geo_node_attribute_remove_exec(GeoNodeExecParams params)
 
   params.set_output("Geometry", geometry_set);
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_attribute_remove_cc
 
 void register_node_type_geo_attribute_remove()
 {
+  namespace file_ns = blender::nodes::node_geo_attribute_remove_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_ATTRIBUTE_REMOVE, "Attribute Remove", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_remove_exec;
-  ntype.declare = blender::nodes::geo_node_attribute_remove_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_remove_exec;
+  ntype.declare = file_ns::geo_node_attribute_remove_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
index d9513332078..39998ebc81c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_attribute_statistic_cc {
 
 static void geo_node_attribute_statistic_declare(NodeDeclarationBuilder &b)
 {
@@ -360,19 +360,21 @@ static void geo_node_attribute_statistic_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_attribute_statistic_cc
 
 void register_node_type_geo_attribute_statistic()
 {
+  namespace file_ns = blender::nodes::node_geo_attribute_statistic_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_ATTRIBUTE_STATISTIC, "Attribute Statistic", NODE_CLASS_ATTRIBUTE, 0);
 
-  ntype.declare = blender::nodes::geo_node_attribute_statistic_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_statistic_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_statistic_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_statistic_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_statistic_layout;
+  ntype.declare = file_ns::geo_node_attribute_statistic_declare;
+  node_type_init(&ntype, file_ns::geo_node_attribute_statistic_init);
+  node_type_update(&ntype, file_ns::geo_node_attribute_statistic_update);
+  ntype.geometry_node_execute = file_ns::geo_node_attribute_statistic_exec;
+  ntype.draw_buttons = file_ns::geo_node_attribute_statistic_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_boolean.cc b/source/blender/nodes/geometry/nodes/node_geo_boolean.cc
index dba051fe13d..31ecbf7b9d4 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_boolean.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_boolean.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_boolean_cc {
 
 static void geo_node_boolean_declare(NodeDeclarationBuilder &b)
 {
@@ -119,17 +119,19 @@ static void geo_node_boolean_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(result));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_boolean_cc
 
 void register_node_type_geo_boolean()
 {
+  namespace file_ns = blender::nodes::node_geo_boolean_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_BOOLEAN, "Mesh Boolean", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_boolean_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_boolean_layout;
-  ntype.updatefunc = blender::nodes::geo_node_boolean_update;
-  node_type_init(&ntype, blender::nodes::geo_node_boolean_init);
-  ntype.geometry_node_execute = blender::nodes::geo_node_boolean_exec;
+  ntype.declare = file_ns::geo_node_boolean_declare;
+  ntype.draw_buttons = file_ns::geo_node_boolean_layout;
+  ntype.updatefunc = file_ns::geo_node_boolean_update;
+  node_type_init(&ntype, file_ns::geo_node_boolean_init);
+  ntype.geometry_node_execute = file_ns::geo_node_boolean_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc b/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc
index e7c9715934a..6a40fe5c25c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_bounding_box_cc {
 
 static void geo_node_bounding_box_declare(NodeDeclarationBuilder &b)
 {
@@ -78,14 +78,16 @@ static void geo_node_bounding_box_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_bounding_box_cc
 
 void register_node_type_geo_bounding_box()
 {
+  namespace file_ns = blender::nodes::node_geo_bounding_box_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_BOUNDING_BOX, "Bounding Box", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_bounding_box_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_bounding_box_exec;
+  ntype.declare = file_ns::geo_node_bounding_box_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_bounding_box_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc b/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc
index 503711fedfe..a4836e6ca39 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_collection_info.cc
@@ -27,7 +27,7 @@
 
 #include <algorithm>
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_collection_info_cc {
 
 static void geo_node_collection_info_declare(NodeDeclarationBuilder &b)
 {
@@ -155,20 +155,22 @@ static void geo_node_collection_info_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set_out);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_collection_info_cc
 
 void register_node_type_geo_collection_info()
 {
+  namespace file_ns = blender::nodes::node_geo_collection_info_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_COLLECTION_INFO, "Collection Info", NODE_CLASS_INPUT, 0);
-  ntype.declare = blender::nodes::geo_node_collection_info_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_collection_info_node_init);
+  ntype.declare = file_ns::geo_node_collection_info_declare;
+  node_type_init(&ntype, file_ns::geo_node_collection_info_node_init);
   node_type_storage(&ntype,
                     "NodeGeometryCollectionInfo",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_collection_info_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_collection_info_layout;
+  ntype.geometry_node_execute = file_ns::geo_node_collection_info_exec;
+  ntype.draw_buttons = file_ns::geo_node_collection_info_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
index 221fb421ab4..0da9b69609d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
@@ -28,7 +28,7 @@
 #  include "RBI_hull_api.h"
 #endif
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_convex_hull_cc {
 
 static void geo_node_convex_hull_declare(NodeDeclarationBuilder &b)
 {
@@ -316,14 +316,16 @@ static void geo_node_convex_hull_exec(GeoNodeExecParams params)
 #endif /* WITH_BULLET */
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_convex_hull_cc
 
 void register_node_type_geo_convex_hull()
 {
+  namespace file_ns = blender::nodes::node_geo_convex_hull_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CONVEX_HULL, "Convex Hull", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_convex_hull_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_convex_hull_exec;
+  ntype.declare = file_ns::geo_node_convex_hull_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_convex_hull_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
index c41b76412e9..0293c259865 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_endpoint_select_cc {
 
 static void geo_node_curve_endpoint_selection_declare(NodeDeclarationBuilder &b)
 {
@@ -138,16 +138,18 @@ static void geo_node_curve_endpoint_selection_exec(GeoNodeExecParams params)
   Field<bool> selection_field{std::make_shared<EndpointFieldInput>(start_size, end_size)};
   params.set_output("Selection", std::move(selection_field));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_endpoint_select_cc
 
 void register_node_type_geo_curve_endpoint_selection()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_endpoint_select_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_ENDPOINT_SELECTION, "Endpoint Selection", NODE_CLASS_INPUT, 0);
-  ntype.declare = blender::nodes::geo_node_curve_endpoint_selection_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoint_selection_exec;
+  ntype.declare = file_ns::geo_node_curve_endpoint_selection_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_endpoint_selection_exec;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
index 219effadec4..60b55f45dbe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
@@ -31,7 +31,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_fill_cc {
 
 static void geo_node_curve_fill_declare(NodeDeclarationBuilder &b)
 {
@@ -160,19 +160,21 @@ static void geo_node_curve_fill_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_fill_cc
 
 void register_node_type_geo_curve_fill()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_fill_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_FILL_CURVE, "Fill Curve", NODE_CLASS_GEOMETRY, 0);
 
-  node_type_init(&ntype, blender::nodes::geo_node_curve_fill_init);
+  node_type_init(&ntype, file_ns::geo_node_curve_fill_init);
   node_type_storage(
       &ntype, "NodeGeometryCurveFill", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_curve_fill_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_fill_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_fill_layout;
+  ntype.declare = file_ns::geo_node_curve_fill_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_fill_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_fill_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
index a320f35c539..8b7f6874d22 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
@@ -25,7 +25,7 @@
 
 #include "BKE_spline.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_fillet_cc {
 
 static void geo_node_curve_fillet_declare(NodeDeclarationBuilder &b)
 {
@@ -629,19 +629,21 @@ static void geo_node_fillet_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_fillet_cc
 
 void register_node_type_geo_curve_fillet()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_fillet_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_FILLET_CURVE, "Fillet Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_fillet_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_fillet_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_curve_fillet_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_fillet_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_fillet_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_fillet_exec;
+  ntype.declare = file_ns::geo_node_curve_fillet_declare;
+  node_type_init(&ntype, file_ns::geo_node_curve_fillet_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_fillet_update);
+  ntype.geometry_node_execute = file_ns::geo_node_fillet_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
index 5fb17270301..0be5b83c4b0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_handle_type_selection_cc {
 
 static void geo_node_curve_handle_type_selection_declare(NodeDeclarationBuilder &b)
 {
@@ -152,22 +152,24 @@ static void geo_node_curve_handle_type_selection_exec(GeoNodeExecParams params)
   params.set_output("Selection", std::move(selection_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_handle_type_selection_cc
 
 void register_node_type_geo_curve_handle_type_selection()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_handle_type_selection_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_HANDLE_TYPE_SELECTION, "Handle Type Selection", NODE_CLASS_INPUT, 0);
-  ntype.declare = blender::nodes::geo_node_curve_handle_type_selection_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_handle_type_selection_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_handle_type_selection_init);
+  ntype.declare = file_ns::geo_node_curve_handle_type_selection_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_handle_type_selection_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_handle_type_selection_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSelectHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_handle_type_selection_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_handle_type_selection_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc
index 0d0dc0ec89c..65138cc6aef 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_length.cc
@@ -17,7 +17,7 @@
 #include "BKE_spline.hh"
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_length_cc {
 
 static void geo_node_curve_length_declare(NodeDeclarationBuilder &b)
 {
@@ -40,14 +40,16 @@ static void geo_node_curve_length_exec(GeoNodeExecParams params)
   params.set_output("Length", length);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_length_cc
 
 void register_node_type_geo_curve_length()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_length_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CURVE_LENGTH, "Curve Length", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_length_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_length_exec;
+  ntype.declare = file_ns::geo_node_curve_length_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_length_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_parameter.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_parameter.cc
index 63518b38090..b8ff8b1fd94 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_parameter.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_parameter.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_parameter_cc {
 
 static void geo_node_curve_parameter_declare(NodeDeclarationBuilder &b)
 {
@@ -269,13 +269,15 @@ static void geo_node_curve_parameter_exec(GeoNodeExecParams params)
   params.set_output("Length", std::move(length_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_parameter_cc
 
 void register_node_type_geo_curve_parameter()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_parameter_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_CURVE_PARAMETER, "Curve Parameter", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_parameter_exec;
-  ntype.declare = blender::nodes::geo_node_curve_parameter_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_parameter_exec;
+  ntype.declare = file_ns::geo_node_curve_parameter_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc
index 673a5095044..6f5b3bf44be 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_bezier_segment_cc {
 
 static void geo_node_curve_primitive_bezier_segment_declare(NodeDeclarationBuilder &b)
 {
@@ -137,20 +137,22 @@ static void geo_node_curve_primitive_bezier_segment_exec(GeoNodeExecParams param
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_bezier_segment_cc
 
 void register_node_type_geo_curve_primitive_bezier_segment()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_bezier_segment_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT, "Bezier Segment", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_bezier_segment_init);
+  node_type_init(&ntype, file_ns::geo_node_curve_primitive_bezier_segment_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurvePrimitiveBezierSegment",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_bezier_segment_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_bezier_segment_layout;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_bezier_segment_exec;
+  ntype.declare = file_ns::geo_node_curve_primitive_bezier_segment_declare;
+  ntype.draw_buttons = file_ns::geo_node_curve_primitive_bezier_segment_layout;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_bezier_segment_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc
index 5d8beb9c9d8..acffd984e31 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_circle_cc {
 
 static void geo_node_curve_primitive_circle_declare(NodeDeclarationBuilder &b)
 {
@@ -226,22 +226,24 @@ static void geo_node_curve_primitive_circle_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_circle_cc
 
 void register_node_type_geo_curve_primitive_circle()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_circle_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_PRIMITIVE_CIRCLE, "Curve Circle", NODE_CLASS_GEOMETRY, 0);
 
-  node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_circle_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_circle_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_primitive_circle_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_primitive_circle_update);
   node_type_storage(&ntype,
                     "NodeGeometryCurvePrimitiveCircle",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_circle_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_circle_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_circle_layout;
+  ntype.declare = file_ns::geo_node_curve_primitive_circle_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_circle_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_primitive_circle_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc
index 238fc77e1cc..4fac456d81a 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_line_cc {
 
 static void geo_node_curve_primitive_line_declare(NodeDeclarationBuilder &b)
 {
@@ -134,20 +134,22 @@ static void geo_node_curve_primitive_line_exec(GeoNodeExecParams params)
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_line_cc
 
 void register_node_type_geo_curve_primitive_line()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_line_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_LINE, "Curve Line", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_line_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_line_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_primitive_line_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_primitive_line_update);
   node_type_storage(&ntype,
                     "NodeGeometryCurvePrimitiveLine",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_line_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_line_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_line_layout;
+  ntype.declare = file_ns::geo_node_curve_primitive_line_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_line_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_primitive_line_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc
index 27bf4a310df..4e344fd31f7 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc
@@ -17,7 +17,7 @@
 #include "BKE_spline.hh"
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc {
 
 static void geo_node_curve_primitive_quadratic_bezier_declare(NodeDeclarationBuilder &b)
 {
@@ -74,17 +74,19 @@ static void geo_node_curve_primitive_quadratic_bezier_exec(GeoNodeExecParams par
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc
 
 void register_node_type_geo_curve_primitive_quadratic_bezier()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype,
                      GEO_NODE_CURVE_PRIMITIVE_QUADRATIC_BEZIER,
                      "Quadratic Bezier",
                      NODE_CLASS_GEOMETRY,
                      0);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_quadratic_bezier_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_quadratic_bezier_exec;
+  ntype.declare = file_ns::geo_node_curve_primitive_quadratic_bezier_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_quadratic_bezier_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc
index 114ae441d99..2ad6230eeaf 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc
@@ -19,7 +19,7 @@
 #include "UI_resources.h"
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_quadrilaterial_cc {
 
 static void geo_node_curve_primitive_quadrilateral_declare(NodeDeclarationBuilder &b)
 {
@@ -255,18 +255,20 @@ static void geo_node_curve_primitive_quadrilateral_exec(GeoNodeExecParams params
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_quadrilaterial_cc
 
 void register_node_type_geo_curve_primitive_quadrilateral()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_quadrilaterial_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_PRIMITIVE_QUADRILATERAL, "Quadrilateral", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_quadrilateral_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_quadrilateral_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_quadrilateral_layout;
-  node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_quadrilateral_update);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_quadrilateral_init);
+  ntype.declare = file_ns::geo_node_curve_primitive_quadrilateral_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_quadrilateral_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_primitive_quadrilateral_layout;
+  node_type_update(&ntype, file_ns::geo_node_curve_primitive_quadrilateral_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_primitive_quadrilateral_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurvePrimitiveQuad",
                     node_free_standard_storage,
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc
index 1384165e520..eddfa334d99 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_spiral_cc {
 
 static void geo_node_curve_primitive_spiral_declare(NodeDeclarationBuilder &b)
 {
@@ -99,14 +99,16 @@ static void geo_node_curve_primitive_spiral_exec(GeoNodeExecParams params)
   params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_spiral_cc
 
 void register_node_type_geo_curve_primitive_spiral()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_spiral_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_SPIRAL, "Spiral", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_spiral_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_spiral_exec;
+  ntype.declare = file_ns::geo_node_curve_primitive_spiral_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_spiral_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc
index 9004681c246..2c54e412cbe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_primitive_star_cc {
 
 static void geo_node_curve_primitive_star_declare(NodeDeclarationBuilder &b)
 {
@@ -103,13 +103,15 @@ static void geo_node_curve_primitive_star_exec(GeoNodeExecParams params)
   }
   params.set_output("Curve", std::move(output));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_primitive_star_cc
 
 void register_node_type_geo_curve_primitive_star()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_primitive_star_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_STAR, "Star", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_primitive_star_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_star_exec;
+  ntype.declare = file_ns::geo_node_curve_primitive_star_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_star_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc
index f72978bae50..8ac092e77c8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_resample_cc {
 
 static void geo_node_curve_resample_declare(NodeDeclarationBuilder &b)
 {
@@ -285,19 +285,21 @@ static void geo_node_resample_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_resample_cc
 
 void register_node_type_geo_curve_resample()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_resample_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_RESAMPLE_CURVE, "Resample Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_resample_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_resample_layout;
+  ntype.declare = file_ns::geo_node_curve_resample_declare;
+  ntype.draw_buttons = file_ns::geo_node_curve_resample_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveResample", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_resample_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_resample_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_resample_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_resample_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_resample_update);
+  ntype.geometry_node_execute = file_ns::geo_node_resample_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
index b1dc45a426a..5d487c5e038 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_reverse_cc {
 
 static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
 {
@@ -60,13 +60,15 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_reverse_cc
 
 void register_node_type_geo_curve_reverse()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_reverse_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_REVERSE_CURVE, "Reverse Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
+  ntype.declare = file_ns::geo_node_curve_reverse_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_reverse_exec;
   nodeRegisterType(&ntype);
 }
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 8f42aacab43..e69b0e84134 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_sample_cc {
 
 static void geo_node_curve_sample_declare(NodeDeclarationBuilder &b)
 {
@@ -271,20 +271,22 @@ static void geo_node_curve_sample_exec(GeoNodeExecParams params)
   params.set_output("Normal", Field<float3>(sample_op, 2));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_sample_cc
 
 void register_node_type_geo_curve_sample()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_sample_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SAMPLE_CURVE, " Sample Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_sample_exec;
-  ntype.declare = blender::nodes::geo_node_curve_sample_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_sample_type_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_sample_update);
+  ntype.geometry_node_execute = file_ns::geo_node_curve_sample_exec;
+  ntype.declare = file_ns::geo_node_curve_sample_declare;
+  node_type_init(&ntype, file_ns::geo_node_curve_sample_type_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_sample_update);
   node_type_storage(
       &ntype, "NodeGeometryCurveSample", node_free_standard_storage, node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_sample_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_sample_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
index 8b0a6ca840c..672c935ae37 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_set_handles_cc {
 
 static void geo_node_curve_set_handles_declare(NodeDeclarationBuilder &b)
 {
@@ -130,21 +130,23 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
   }
   params.set_output("Curve", std::move(geometry_set));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_set_handles_cc
 
 void register_node_type_geo_curve_set_handles()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_set_handles_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_set_handles_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
+  ntype.declare = file_ns::geo_node_curve_set_handles_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_set_handles_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_set_handles_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSetHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_set_handles_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
index ae4453929ac..8be496312e3 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_spline_type_cc {
 
 static void geo_node_curve_spline_type_declare(NodeDeclarationBuilder &b)
 {
@@ -288,21 +288,23 @@ static void geo_node_curve_spline_type_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_spline_type_cc
 
 void register_node_type_geo_curve_spline_type()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_spline_type_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_spline_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_spline_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_spline_type_init);
+  ntype.declare = file_ns::geo_node_curve_spline_type_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_spline_type_exec;
+  node_type_init(&ntype, file_ns::geo_node_curve_spline_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSplineType",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_spline_type_layout;
+  ntype.draw_buttons = file_ns::geo_node_curve_spline_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
index 7c4c17e69e0..215ba84a8f5 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_subdivide_cc {
 
 static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
 {
@@ -351,14 +351,16 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
   params.set_output("Curve", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_subdivide_cc
 
 void register_node_type_geo_curve_subdivide()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_subdivide_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SUBDIVIDE_CURVE, "Subdivide Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
+  ntype.declare = file_ns::geo_node_curve_subdivide_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_subdivide_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc
index 1977b465de4..0d7751add85 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_curve_to_mesh_cc {
 
 static void geo_node_curve_to_mesh_declare(NodeDeclarationBuilder &b)
 {
@@ -72,14 +72,16 @@ static void geo_node_curve_to_mesh_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(curve_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_to_mesh_cc
 
 void register_node_type_geo_curve_to_mesh()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_to_mesh_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_MESH, "Curve to Mesh", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_to_mesh_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_mesh_exec;
+  ntype.declare = file_ns::geo_node_curve_to_mesh_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_to_mesh_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
index b9f129a5f75..41a6646f9f8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
@@ -27,6 +27,20 @@
 #include "node_geometry_util.hh"
 
 namespace blender::nodes {
+void curve_create_default_rotation_attribute(Span<float3> tangents,
+                                             Span<float3> normals,
+                                             MutableSpan<float3> rotations)
+{
+  threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
+    for (const int i : range) {
+      rotations[i] =
+          float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
+    }
+  });
+}
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_curve_to_points_cc {
 
 static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -289,18 +303,6 @@ static void copy_spline_domain_attributes(const CurveEval &curve,
       ATTR_DOMAIN_CURVE);
 }
 
-void curve_create_default_rotation_attribute(Span<float3> tangents,
-                                             Span<float3> normals,
-                                             MutableSpan<float3> rotations)
-{
-  threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
-    for (const int i : range) {
-      rotations[i] =
-          float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
-    }
-  });
-}
-
 static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
 {
   NodeGeometryCurveToPoints &node_storage = *(NodeGeometryCurveToPoints *)params.node().storage;
@@ -374,20 +376,22 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_to_points_cc
 
 void register_node_type_geo_curve_to_points()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_to_points_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
+  ntype.declare = file_ns::geo_node_curve_to_points_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_to_points_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_to_points_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_to_points_update);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
index b281876d314..559cf51ccbd 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
@@ -22,9 +22,9 @@
 
 #include "node_geometry_util.hh"
 
-using blender::attribute_math::mix2;
+namespace blender::nodes::node_geo_curve_trim_cc {
 
-namespace blender::nodes {
+using blender::attribute_math::mix2;
 
 static void geo_node_curve_trim_declare(NodeDeclarationBuilder &b)
 {
@@ -557,18 +557,20 @@ static void geo_node_curve_trim_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_curve_trim_cc
 
 void register_node_type_geo_curve_trim()
 {
+  namespace file_ns = blender::nodes::node_geo_curve_trim_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_TRIM_CURVE, "Trim Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_trim_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_trim_layout;
-  ntype.declare = blender::nodes::geo_node_curve_trim_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_curve_trim_exec;
+  ntype.draw_buttons = file_ns::geo_node_curve_trim_layout;
+  ntype.declare = file_ns::geo_node_curve_trim_declare;
   node_type_storage(
       &ntype, "NodeGeometryCurveTrim", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_trim_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_trim_update);
+  node_type_init(&ntype, file_ns::geo_node_curve_trim_init);
+  node_type_update(&ntype, file_ns::geo_node_curve_trim_update);
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
index bbc7c337508..517f69ec623 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
@@ -29,8 +29,6 @@
 
 #include "node_geometry_util.hh"
 
-using blender::bke::CustomDataAttributes;
-
 /* Code from the mask modifier in MOD_mask.cc. */
 void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
                                       Mesh &dst_mesh,
@@ -48,39 +46,7 @@ void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
 
 namespace blender::nodes {
 
-static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Geometry>(N_("Geometry"));
-  b.add_input<decl::Bool>(N_("Selection"))
-      .default_value(true)
-      .hide_value()
-      .supports_field()
-      .description(N_("The parts of the geometry to be deleted"));
-  b.add_output<decl::Geometry>(N_("Geometry"));
-}
-
-static void geo_node_delete_geometry_layout(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
-{
-  const bNode *node = static_cast<bNode *>(ptr->data);
-  const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node->storage;
-  const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
-
-  uiItemR(layout, ptr, "domain", 0, "", ICON_NONE);
-  /* Only show the mode when it is relevant. */
-  if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE)) {
-    uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
-  }
-}
-
-static void geo_node_delete_geometry_init(bNodeTree *UNUSED(tree), bNode *node)
-{
-  NodeGeometryDeleteGeometry *data = (NodeGeometryDeleteGeometry *)MEM_callocN(
-      sizeof(NodeGeometryDeleteGeometry), __func__);
-  data->domain = ATTR_DOMAIN_POINT;
-  data->mode = GEO_NODE_DELETE_GEOMETRY_MODE_ALL;
-
-  node->storage = data;
-}
+using blender::bke::CustomDataAttributes;
 
 template<typename T> static void copy_data(Span<T> data, MutableSpan<T> r_data, IndexMask mask)
 {
@@ -1177,6 +1143,44 @@ void separate_geometry(GeometrySet &geometry_set,
   r_is_error = !some_valid_domain && geometry_set.has_realized_data();
 }
 
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_delete_geometry_cc {
+
+static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Geometry>(N_("Geometry"));
+  b.add_input<decl::Bool>(N_("Selection"))
+      .default_value(true)
+      .hide_value()
+      .supports_field()
+      .description(N_("The parts of the geometry to be deleted"));
+  b.add_output<decl::Geometry>(N_("Geometry"));
+}
+
+static void geo_node_delete_geometry_layout(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
+{
+  const bNode *node = static_cast<bNode *>(ptr->data);
+  const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node->storage;
+  const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
+
+  uiItemR(layout, ptr, "domain", 0, "", ICON_NONE);
+  /* Only show the mode when it is relevant. */
+  if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE)) {
+    uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
+  }
+}
+
+static void geo_node_delete_geometry_init(bNodeTree *UNUSED(tree), bNode *node)
+{
+  NodeGeometryDeleteGeometry *data = (NodeGeometryDeleteGeometry *)MEM_callocN(
+      sizeof(NodeGeometryDeleteGeometry), __func__);
+  data->domain = ATTR_DOMAIN_POINT;
+  data->mode = GEO_NODE_DELETE_GEOMETRY_MODE_ALL;
+
+  node->storage = data;
+}
+
 static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
 {
   GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
@@ -1204,10 +1208,12 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_delete_geometry_cc
 
 void register_node_type_geo_delete_geometry()
 {
+  namespace file_ns = blender::nodes::node_geo_delete_geometry_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
@@ -1217,10 +1223,10 @@ void register_node_type_geo_delete_geometry()
                     node_free_standard_storage,
                     node_copy_standard_storage);
 
-  node_type_init(&ntype, blender::nodes::geo_node_delete_geometry_init);
+  node_type_init(&ntype, file_ns::geo_node_delete_geometry_init);
 
-  ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_delete_geometry_layout;
+  ntype.declare = file_ns::geo_node_delete_geometry_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_delete_geometry_exec;
+  ntype.draw_buttons = file_ns::geo_node_delete_geometry_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
index b2c76b76590..def328d3293 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
@@ -36,9 +36,7 @@
 
 #include "node_geometry_util.hh"
 
-using blender::bke::GeometryInstanceGroup;
-
-namespace blender::nodes {
+namespace blender::nodes::node_geo_distribute_points_on_faces_cc {
 
 static void geo_node_point_distribute_points_on_faces_declare(NodeDeclarationBuilder &b)
 {
@@ -570,10 +568,12 @@ static void geo_node_point_distribute_points_on_faces_exec(GeoNodeExecParams par
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_distribute_points_on_faces_cc
 
 void register_node_type_geo_distribute_points_on_faces()
 {
+  namespace file_ns = blender::nodes::node_geo_distribute_points_on_faces_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype,
@@ -581,10 +581,10 @@ void register_node_type_geo_distribute_points_on_faces()
                      "Distribute Points on Faces",
                      NODE_CLASS_GEOMETRY,
                      0);
-  node_type_update(&ntype, blender::nodes::node_point_distribute_points_on_faces_update);
+  node_type_update(&ntype, file_ns::node_point_distribute_points_on_faces_update);
   node_type_size(&ntype, 170, 100, 320);
-  ntype.declare = blender::nodes::geo_node_point_distribute_points_on_faces_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_points_on_faces_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_distribute_points_on_faces_layout;
+  ntype.declare = file_ns::geo_node_point_distribute_points_on_faces_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_point_distribute_points_on_faces_exec;
+  ntype.draw_buttons = file_ns::geo_node_point_distribute_points_on_faces_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
index ca6254be182..7890322e0ec 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
@@ -22,7 +22,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_edge_split_cc {
 
 static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
 {
@@ -82,14 +82,16 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_edge_split_cc
 
 void register_node_type_geo_edge_split()
 {
+  namespace file_ns = blender::nodes::node_geo_edge_split_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SPLIT_EDGES, "Split Edges", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
-  ntype.declare = blender::nodes::geo_node_edge_split_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_edge_split_exec;
+  ntype.declare = file_ns::geo_node_edge_split_declare;
   nodeRegisterType(&ntype);
 }
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 7bbe0716f78..62dd6deeaf7 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
@@ -32,7 +32,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_image_texture_cc {
 
 static void geo_node_image_texture_declare(NodeDeclarationBuilder &b)
 {
@@ -410,20 +410,22 @@ static void geo_node_image_texture_exec(GeoNodeExecParams params)
   params.set_output("Alpha", Field<float>(image_op, 1));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_image_texture_cc
 
 void register_node_type_geo_image_texture(void)
 {
+  namespace file_ns = blender::nodes::node_geo_image_texture_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_IMAGE_TEXTURE, "Image Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = blender::nodes::geo_node_image_texture_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_image_texture_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_image_texture_init);
+  ntype.declare = file_ns::geo_node_image_texture_declare;
+  ntype.draw_buttons = file_ns::geo_node_image_texture_layout;
+  node_type_init(&ntype, file_ns::geo_node_image_texture_init);
   node_type_storage(
       &ntype, "NodeGeometryImageTexture", node_free_standard_storage, node_copy_standard_storage);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  ntype.geometry_node_execute = blender::nodes::geo_node_image_texture_exec;
+  ntype.geometry_node_execute = file_ns::geo_node_image_texture_exec;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc
index b8df545d073..dde3e3cb9fd 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_curve_handles_cc {
 
 static void geo_node_input_curve_handles_declare(NodeDeclarationBuilder &b)
 {
@@ -32,15 +32,17 @@ static void geo_node_input_curve_handles_exec(GeoNodeExecParams params)
   params.set_output("Right", std::move(right_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_curve_handles_cc
 
 void register_node_type_geo_input_curve_handles()
 {
+  namespace file_ns = blender::nodes::node_geo_input_curve_handles_cc;
+
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_INPUT_CURVE_HANDLES, "Curve Handle Positions", NODE_CLASS_INPUT, 0);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_curve_handles_exec;
-  ntype.declare = blender::nodes::geo_node_input_curve_handles_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_curve_handles_exec;
+  ntype.declare = file_ns::geo_node_input_curve_handles_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc b/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc
index f32db3842db..7272ce16bb0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_curve_tilt_cc {
 
 static void geo_node_input_curve_tilt_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_curve_tilt_exec(GeoNodeExecParams params)
   params.set_output("Tilt", std::move(tilt_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_curve_tilt_cc
 
 void register_node_type_geo_input_curve_tilt()
 {
+  namespace file_ns = blender::nodes::node_geo_input_curve_tilt_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_CURVE_TILT, "Curve Tilt", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_curve_tilt_exec;
-  ntype.declare = blender::nodes::geo_node_input_curve_tilt_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_curve_tilt_exec;
+  ntype.declare = file_ns::geo_node_input_curve_tilt_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
index 37d5bac0325..30686038472 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_id.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_id_cc {
 
 static void geo_node_input_id_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_id_exec(GeoNodeExecParams params)
   params.set_output("ID", std::move(position_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_id_cc
 
 void register_node_type_geo_input_id()
 {
+  namespace file_ns = blender::nodes::node_geo_input_id_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_ID, "ID", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_id_exec;
-  ntype.declare = blender::nodes::geo_node_input_id_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_id_exec;
+  ntype.declare = file_ns::geo_node_input_id_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_index.cc b/source/blender/nodes/geometry/nodes/node_geo_input_index.cc
index 6200ac5e7a8..6500e5f351c 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_index.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_index_cc {
 
 static void geo_node_input_index_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_index_exec(GeoNodeExecParams params)
   params.set_output("Index", std::move(index_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_index_cc
 
 void register_node_type_geo_input_index()
 {
+  namespace file_ns = blender::nodes::node_geo_input_index_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_INDEX, "Index", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_index_exec;
-  ntype.declare = blender::nodes::geo_node_input_index_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_index_exec;
+  ntype.declare = file_ns::geo_node_input_index_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_material.cc b/source/blender/nodes/geometry/nodes/node_geo_input_material.cc
index fc41188dee5..53b1d17978e 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_material.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_material.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_material_cc {
 
 static void geo_node_input_material_declare(NodeDeclarationBuilder &b)
 {
@@ -37,15 +37,17 @@ static void geo_node_input_material_exec(GeoNodeExecParams params)
   params.set_output("Material", material);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_material_cc
 
 void register_node_type_geo_input_material()
 {
+  namespace file_ns = blender::nodes::node_geo_input_material_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_MATERIAL, "Material", NODE_CLASS_INPUT, 0);
-  ntype.draw_buttons = blender::nodes::geo_node_input_material_layout;
-  ntype.declare = blender::nodes::geo_node_input_material_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_material_exec;
+  ntype.draw_buttons = file_ns::geo_node_input_material_layout;
+  ntype.declare = file_ns::geo_node_input_material_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_material_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc b/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc
index 5d5d9e40032..774c8edf5d1 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_material_index_cc {
 
 static void geo_node_input_material_index_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_material_index_exec(GeoNodeExecParams params)
   params.set_output("Material Index", std::move(material_index_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_material_index_cc
 
 void register_node_type_geo_input_material_index()
 {
+  namespace file_ns = blender::nodes::node_geo_input_material_index_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_MATERIAL_INDEX, "Material Index", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_material_index_exec;
-  ntype.declare = blender::nodes::geo_node_input_material_index_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_material_index_exec;
+  ntype.declare = file_ns::geo_node_input_material_index_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc b/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc
index 6c95ad73bf7..7946de01563 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_normal.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_normal_cc {
 
 static void geo_node_input_normal_declare(NodeDeclarationBuilder &b)
 {
@@ -283,14 +283,16 @@ static void geo_node_input_normal_exec(GeoNodeExecParams params)
   params.set_output("Normal", std::move(normal_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_normal_cc
 
 void register_node_type_geo_input_normal()
 {
+  namespace file_ns = blender::nodes::node_geo_input_normal_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_NORMAL, "Normal", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_normal_exec;
-  ntype.declare = blender::nodes::geo_node_input_normal_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_normal_exec;
+  ntype.declare = file_ns::geo_node_input_normal_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_position.cc b/source/blender/nodes/geometry/nodes/node_geo_input_position.cc
index a8477d4bc4f..5b87f902189 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_position.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_position.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_position_cc {
 
 static void geo_node_input_position_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_position_exec(GeoNodeExecParams params)
   params.set_output("Position", std::move(position_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_position_cc
 
 void register_node_type_geo_input_position()
 {
+  namespace file_ns = blender::nodes::node_geo_input_position_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_POSITION, "Position", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_position_exec;
-  ntype.declare = blender::nodes::geo_node_input_position_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_position_exec;
+  ntype.declare = file_ns::geo_node_input_position_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc
index 6d2c4c38cbe..2f8f4732d99 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_radius.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_radius_cc {
 
 static void geo_node_input_radius_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_radius_exec(GeoNodeExecParams params)
   params.set_output("Radius", std::move(radius_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_radius_cc
 
 void register_node_type_geo_input_radius()
 {
+  namespace file_ns = blender::nodes::node_geo_input_radius_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_RADIUS, "Radius", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_radius_exec;
-  ntype.declare = blender::nodes::geo_node_input_radius_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_radius_exec;
+  ntype.declare = file_ns::geo_node_input_radius_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_shade_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_input_shade_smooth.cc
index dcd14b1c054..72cd3c13f77 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_shade_smooth.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_shade_smooth.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_shade_smooth_cc {
 
 static void geo_node_input_shade_smooth_declare(NodeDeclarationBuilder &b)
 {
@@ -29,14 +29,16 @@ static void geo_node_input_shade_smooth_exec(GeoNodeExecParams params)
   params.set_output("Smooth", std::move(shade_smooth_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_shade_smooth_cc
 
 void register_node_type_geo_input_shade_smooth()
 {
+  namespace file_ns = blender::nodes::node_geo_input_shade_smooth_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_SHADE_SMOOTH, "Is Shade Smooth", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_shade_smooth_exec;
-  ntype.declare = blender::nodes::geo_node_input_shade_smooth_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_shade_smooth_exec;
+  ntype.declare = file_ns::geo_node_input_shade_smooth_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc
index a8ee6dd8b12..0a089ac35eb 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_spline_cyclic_cc {
 
 static void geo_node_input_spline_cyclic_declare(NodeDeclarationBuilder &b)
 {
@@ -29,15 +29,17 @@ static void geo_node_input_spline_cyclic_exec(GeoNodeExecParams params)
   params.set_output("Cyclic", std::move(cyclic_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_spline_cyclic_cc
 
 void register_node_type_geo_input_spline_cyclic()
 {
+  namespace file_ns = blender::nodes::node_geo_input_spline_cyclic_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_INPUT_SPLINE_CYCLIC, "Is Spline Cyclic", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_cyclic_exec;
-  ntype.declare = blender::nodes::geo_node_input_spline_cyclic_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_spline_cyclic_exec;
+  ntype.declare = file_ns::geo_node_input_spline_cyclic_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
index a976e0b193f..f94c7b52f69 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
@@ -18,7 +18,7 @@
 
 #include "BKE_spline.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_spline_length_cc {
 
 static void geo_node_input_spline_length_declare(NodeDeclarationBuilder &b)
 {
@@ -91,14 +91,16 @@ static void geo_node_input_spline_length_exec(GeoNodeExecParams params)
   params.set_output("Length", std::move(length_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_spline_length_cc
 
 void register_node_type_geo_input_spline_length()
 {
+  namespace file_ns = blender::nodes::node_geo_input_spline_length_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_SPLINE_LENGTH, "Spline Length", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_length_exec;
-  ntype.declare = blender::nodes::geo_node_input_spline_length_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_spline_length_exec;
+  ntype.declare = file_ns::geo_node_input_spline_length_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc b/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc
index 75fb8a13d38..0aa7133bb80 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_spline_resolution_cc {
 
 static void geo_node_input_spline_resolution_declare(NodeDeclarationBuilder &b)
 {
@@ -29,15 +29,17 @@ static void geo_node_input_spline_resolution_exec(GeoNodeExecParams params)
   params.set_output("Resolution", std::move(resolution_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_spline_resolution_cc
 
 void register_node_type_geo_input_spline_resolution()
 {
+  namespace file_ns = blender::nodes::node_geo_input_spline_resolution_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_INPUT_SPLINE_RESOLUTION, "Spline Resolution", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_resolution_exec;
-  ntype.declare = blender::nodes::geo_node_input_spline_resolution_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_spline_resolution_exec;
+  ntype.declare = file_ns::geo_node_input_spline_resolution_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc b/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc
index 49885f29d44..231f808a1e1 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_input_tangent_cc {
 
 static void geo_node_input_tangent_declare(NodeDeclarationBuilder &b)
 {
@@ -161,14 +161,16 @@ static void geo_node_input_tangent_exec(GeoNodeExecParams params)
   params.set_output("Tangent", std::move(tangent_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_input_tangent_cc
 
 void register_node_type_geo_input_tangent()
 {
+  namespace file_ns = blender::nodes::node_geo_input_tangent_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_INPUT_TANGENT, "Curve Tangent", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_input_tangent_exec;
-  ntype.declare = blender::nodes::geo_node_input_tangent_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_input_tangent_exec;
+  ntype.declare = file_ns::geo_node_input_tangent_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
index 2a68030aba7..ff2b4f4d36b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_instance_on_points_cc {
 
 static void geo_node_instance_on_points_declare(NodeDeclarationBuilder &b)
 {
@@ -214,15 +214,17 @@ static void geo_node_instance_on_points_exec(GeoNodeExecParams params)
   params.set_output("Instances", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_instance_on_points_cc
 
 void register_node_type_geo_instance_on_points()
 {
+  namespace file_ns = blender::nodes::node_geo_instance_on_points_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_INSTANCE_ON_POINTS, "Instance on Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_instance_on_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_instance_on_points_exec;
+  ntype.declare = file_ns::geo_node_instance_on_points_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_instance_on_points_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
index f8c146833ba..acd9d467ee9 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_instances_to_points_cc {
 
 static void geo_node_instances_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -104,15 +104,17 @@ static void geo_node_instances_to_points_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_instances_to_points_cc
 
 void register_node_type_geo_instances_to_points()
 {
+  namespace file_ns = blender::nodes::node_geo_instances_to_points_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_INSTANCES_TO_POINTS, "Instances to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_instances_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_instances_to_points_exec;
+  ntype.declare = file_ns::geo_node_instances_to_points_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_instances_to_points_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc b/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc
index 8e0e98f7bd5..47d67f713d1 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_is_viewport_cc {
 
 static void geo_node_is_viewport_declare(NodeDeclarationBuilder &b)
 {
@@ -34,14 +34,16 @@ static void geo_node_is_viewport_exec(GeoNodeExecParams params)
   params.set_output("Is Viewport", is_viewport);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_is_viewport_cc
 
 void register_node_type_geo_is_viewport()
 {
+  namespace file_ns = blender::nodes::node_geo_is_viewport_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_IS_VIEWPORT, "Is Viewport", NODE_CLASS_INPUT, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_is_viewport_exec;
-  ntype.declare = blender::nodes::geo_node_is_viewport_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_is_viewport_exec;
+  ntype.declare = file_ns::geo_node_is_viewport_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
index fcdf7c2da01..e585af9d7c2 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
@@ -27,7 +27,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_join_geometry_cc {
 
 static void geo_node_join_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -508,14 +508,16 @@ static void geo_node_join_geometry_exec(GeoNodeExecParams params)
 
   params.set_output("Geometry", std::move(geometry_set_result));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_join_geometry_cc
 
 void register_node_type_geo_join_geometry()
 {
+  namespace file_ns = blender::nodes::node_geo_join_geometry_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_JOIN_GEOMETRY, "Join Geometry", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_join_geometry_exec;
-  ntype.declare = blender::nodes::geo_node_join_geometry_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_join_geometry_exec;
+  ntype.declare = file_ns::geo_node_join_geometry_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc b/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc
index e4a62bd5267..7a92c413f79 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_material_replace.cc
@@ -24,7 +24,7 @@
 
 #include "BKE_material.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_material_replace_cc {
 
 static void geo_node_material_replace_declare(NodeDeclarationBuilder &b)
 {
@@ -55,15 +55,17 @@ static void geo_node_material_replace_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_material_replace_cc
 
 void register_node_type_geo_material_replace()
 {
+  namespace file_ns = blender::nodes::node_geo_material_replace_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_REPLACE_MATERIAL, "Replace Material", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_material_replace_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_material_replace_exec;
+  ntype.declare = file_ns::geo_node_material_replace_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_material_replace_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc
index 12ffa21762e..b718d49d2a8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_material_selection.cc
@@ -26,7 +26,7 @@
 
 #include "BKE_material.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_material_selection_cc {
 
 static void geo_node_material_selection_declare(NodeDeclarationBuilder &b)
 {
@@ -118,15 +118,17 @@ static void geo_node_material_selection_exec(GeoNodeExecParams params)
   params.set_output("Selection", std::move(material_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_material_selection_cc
 
 void register_node_type_geo_material_selection()
 {
+  namespace file_ns = blender::nodes::node_geo_material_selection_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_MATERIAL_SELECTION, "Material Selection", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_material_selection_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_material_selection_exec;
+  ntype.declare = file_ns::geo_node_material_selection_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_material_selection_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc
index f1f95be107a..837b6bd8ef6 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_primitive_circle_cc {
 
 static void geo_node_mesh_primitive_circle_declare(NodeDeclarationBuilder &b)
 {
@@ -222,19 +222,21 @@ static void geo_node_mesh_primitive_circle_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_circle_cc
 
 void register_node_type_geo_mesh_primitive_circle()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_circle_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_MESH_PRIMITIVE_CIRCLE, "Mesh Circle", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_circle_init);
+  node_type_init(&ntype, file_ns::geo_node_mesh_primitive_circle_init);
   node_type_storage(
       &ntype, "NodeGeometryMeshCircle", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_circle_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_circle_layout;
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_circle_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_circle_exec;
+  ntype.draw_buttons = file_ns::geo_node_mesh_primitive_circle_layout;
+  ntype.declare = file_ns::geo_node_mesh_primitive_circle_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc
index fc93f6e72b5..9d30e132e61 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc
@@ -29,75 +29,6 @@
 
 namespace blender::nodes {
 
-static void geo_node_mesh_primitive_cone_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Int>(N_("Vertices"))
-      .default_value(32)
-      .min(3)
-      .max(512)
-      .description(N_("Number of points on the circle at the top and bottom"));
-  b.add_input<decl::Int>(N_("Side Segments"))
-      .default_value(1)
-      .min(1)
-      .max(512)
-      .description(N_("The number of edges running vertically along the side of the cone"));
-  b.add_input<decl::Int>(N_("Fill Segments"))
-      .default_value(1)
-      .min(1)
-      .max(512)
-      .description(N_("Number of concentric rings used to fill the round face"));
-  b.add_input<decl::Float>(N_("Radius Top"))
-      .min(0.0f)
-      .subtype(PROP_DISTANCE)
-      .description(N_("Radius of the top circle of the cone"));
-  b.add_input<decl::Float>(N_("Radius Bottom"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .subtype(PROP_DISTANCE)
-      .description(N_("Radius of the bottom circle of the cone"));
-  b.add_input<decl::Float>(N_("Depth"))
-      .default_value(2.0f)
-      .min(0.0f)
-      .subtype(PROP_DISTANCE)
-      .description(N_("Height of the generated cone"));
-  b.add_output<decl::Geometry>(N_("Mesh"));
-  b.add_output<decl::Bool>(N_("Top")).field_source();
-  b.add_output<decl::Bool>(N_("Bottom")).field_source();
-  b.add_output<decl::Bool>(N_("Side")).field_source();
-}
-
-static void geo_node_mesh_primitive_cone_init(bNodeTree *UNUSED(ntree), bNode *node)
-{
-  NodeGeometryMeshCone *node_storage = (NodeGeometryMeshCone *)MEM_callocN(
-      sizeof(NodeGeometryMeshCone), __func__);
-
-  node_storage->fill_type = GEO_NODE_MESH_CIRCLE_FILL_NGON;
-
-  node->storage = node_storage;
-}
-
-static void geo_node_mesh_primitive_cone_update(bNodeTree *ntree, bNode *node)
-{
-  bNodeSocket *vertices_socket = (bNodeSocket *)node->inputs.first;
-  bNodeSocket *rings_socket = vertices_socket->next;
-  bNodeSocket *fill_subdiv_socket = rings_socket->next;
-
-  const NodeGeometryMeshCone &storage = *(const NodeGeometryMeshCone *)node->storage;
-  const GeometryNodeMeshCircleFillType fill_type =
-      static_cast<const GeometryNodeMeshCircleFillType>(storage.fill_type);
-  const bool has_fill = fill_type != GEO_NODE_MESH_CIRCLE_FILL_NONE;
-  nodeSetSocketAvailability(ntree, fill_subdiv_socket, has_fill);
-}
-
-static void geo_node_mesh_primitive_cone_layout(uiLayout *layout,
-                                                bContext *UNUSED(C),
-                                                PointerRNA *ptr)
-{
-  uiLayoutSetPropSep(layout, true);
-  uiLayoutSetPropDecorate(layout, false);
-  uiItemR(layout, ptr, "fill_type", 0, nullptr, ICON_NONE);
-}
-
 struct ConeConfig {
   float radius_top;
   float radius_bottom;
@@ -794,6 +725,79 @@ Mesh *create_cylinder_or_cone_mesh(const float radius_top,
   return mesh;
 }
 
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_mesh_primitive_cone_cc {
+
+static void geo_node_mesh_primitive_cone_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Int>(N_("Vertices"))
+      .default_value(32)
+      .min(3)
+      .max(512)
+      .description(N_("Number of points on the circle at the top and bottom"));
+  b.add_input<decl::Int>(N_("Side Segments"))
+      .default_value(1)
+      .min(1)
+      .max(512)
+      .description(N_("The number of edges running vertically along the side of the cone"));
+  b.add_input<decl::Int>(N_("Fill Segments"))
+      .default_value(1)
+      .min(1)
+      .max(512)
+      .description(N_("Number of concentric rings used to fill the round face"));
+  b.add_input<decl::Float>(N_("Radius Top"))
+      .min(0.0f)
+      .subtype(PROP_DISTANCE)
+      .description(N_("Radius of the top circle of the cone"));
+  b.add_input<decl::Float>(N_("Radius Bottom"))
+      .default_value(1.0f)
+      .min(0.0f)
+      .subtype(PROP_DISTANCE)
+      .description(N_("Radius of the bottom circle of the cone"));
+  b.add_input<decl::Float>(N_("Depth"))
+      .default_value(2.0f)
+      .min(0.0f)
+      .subtype(PROP_DISTANCE)
+      .description(N_("Height of the generated cone"));
+  b.add_output<decl::Geometry>(N_("Mesh"));
+  b.add_output<decl::Bool>(N_("Top")).field_source();
+  b.add_output<decl::Bool>(N_("Bottom")).field_source();
+  b.add_output<decl::Bool>(N_("Side")).field_source();
+}
+
+static void geo_node_mesh_primitive_cone_init(bNodeTree *UNUSED(ntree), bNode *node)
+{
+  NodeGeometryMeshCone *node_storage = (NodeGeometryMeshCone *)MEM_callocN(
+      sizeof(NodeGeometryMeshCone), __func__);
+
+  node_storage->fill_type = GEO_NODE_MESH_CIRCLE_FILL_NGON;
+
+  node->storage = node_storage;
+}
+
+static void geo_node_mesh_primitive_cone_update(bNodeTree *ntree, bNode *node)
+{
+  bNodeSocket *vertices_socket = (bNodeSocket *)node->inputs.first;
+  bNodeSocket *rings_socket = vertices_socket->next;
+  bNodeSocket *fill_subdiv_socket = rings_socket->next;
+
+  const NodeGeometryMeshCone &storage = *(const NodeGeometryMeshCone *)node->storage;
+  const GeometryNodeMeshCircleFillType fill_type =
+      static_cast<const GeometryNodeMeshCircleFillType>(storage.fill_type);
+  const bool has_fill = fill_type != GEO_NODE_MESH_CIRCLE_FILL_NONE;
+  nodeSetSocketAvailability(ntree, fill_subdiv_socket, has_fill);
+}
+
+static void geo_node_mesh_primitive_cone_layout(uiLayout *layout,
+                                                bContext *UNUSED(C),
+                                                PointerRNA *ptr)
+{
+  uiLayoutSetPropSep(layout, true);
+  uiLayoutSetPropDecorate(layout, false);
+  uiItemR(layout, ptr, "fill_type", 0, nullptr, ICON_NONE);
+}
+
 static void geo_node_mesh_primitive_cone_exec(GeoNodeExecParams params)
 {
   const bNode &node = params.node();
@@ -874,19 +878,21 @@ static void geo_node_mesh_primitive_cone_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_cone_cc
 
 void register_node_type_geo_mesh_primitive_cone()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_cone_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CONE, "Cone", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_cone_init);
-  node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_cone_update);
+  node_type_init(&ntype, file_ns::geo_node_mesh_primitive_cone_init);
+  node_type_update(&ntype, file_ns::geo_node_mesh_primitive_cone_update);
   node_type_storage(
       &ntype, "NodeGeometryMeshCone", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cone_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_cone_layout;
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_cone_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cone_exec;
+  ntype.draw_buttons = file_ns::geo_node_mesh_primitive_cone_layout;
+  ntype.declare = file_ns::geo_node_mesh_primitive_cone_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc
index b5903f7b71e..1079cc48040 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc
@@ -24,31 +24,6 @@
 
 namespace blender::nodes {
 
-static void geo_node_mesh_primitive_cube_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Vector>(N_("Size"))
-      .default_value(float3(1))
-      .min(0.0f)
-      .subtype(PROP_TRANSLATION)
-      .description(N_("Side length along each axis"));
-  b.add_input<decl::Int>(N_("Vertices X"))
-      .default_value(2)
-      .min(2)
-      .max(1000)
-      .description(N_("Number of vertices for the X side of the shape"));
-  b.add_input<decl::Int>(N_("Vertices Y"))
-      .default_value(2)
-      .min(2)
-      .max(1000)
-      .description(N_("Number of vertices for the Y side of the shape"));
-  b.add_input<decl::Int>(N_("Vertices Z"))
-      .default_value(2)
-      .min(2)
-      .max(1000)
-      .description(N_("Number of vertices for the Z side of the shape"));
-  b.add_output<decl::Geometry>(N_("Mesh"));
-}
-
 struct CuboidConfig {
   float3 size;
   int verts_x;
@@ -439,6 +414,35 @@ Mesh *create_cuboid_mesh(const float3 size,
   return mesh;
 }
 
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_mesh_primitive_cube_cc {
+
+static void geo_node_mesh_primitive_cube_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Vector>(N_("Size"))
+      .default_value(float3(1))
+      .min(0.0f)
+      .subtype(PROP_TRANSLATION)
+      .description(N_("Side length along each axis"));
+  b.add_input<decl::Int>(N_("Vertices X"))
+      .default_value(2)
+      .min(2)
+      .max(1000)
+      .description(N_("Number of vertices for the X side of the shape"));
+  b.add_input<decl::Int>(N_("Vertices Y"))
+      .default_value(2)
+      .min(2)
+      .max(1000)
+      .description(N_("Number of vertices for the Y side of the shape"));
+  b.add_input<decl::Int>(N_("Vertices Z"))
+      .default_value(2)
+      .min(2)
+      .max(1000)
+      .description(N_("Number of vertices for the Z side of the shape"));
+  b.add_output<decl::Geometry>(N_("Mesh"));
+}
+
 static Mesh *create_cube_mesh(const float3 size,
                               const int verts_x,
                               const int verts_y,
@@ -501,14 +505,16 @@ static void geo_node_mesh_primitive_cube_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_cube_cc
 
 void register_node_type_geo_mesh_primitive_cube()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_cube_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CUBE, "Cube", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_cube_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cube_exec;
+  ntype.declare = file_ns::geo_node_mesh_primitive_cube_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cube_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc
index a2ac46190b3..444570a63f0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_primitive_cylinder_cc {
 
 static void geo_node_mesh_primitive_cylinder_declare(NodeDeclarationBuilder &b)
 {
@@ -169,18 +169,20 @@ static void geo_node_mesh_primitive_cylinder_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_cylinder_cc
 
 void register_node_type_geo_mesh_primitive_cylinder()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_cylinder_cc;
+
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CYLINDER, "Cylinder", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_cylinder_init);
-  node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_cylinder_update);
+  node_type_init(&ntype, file_ns::geo_node_mesh_primitive_cylinder_init);
+  node_type_update(&ntype, file_ns::geo_node_mesh_primitive_cylinder_update);
   node_type_storage(
       &ntype, "NodeGeometryMeshCylinder", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_cylinder_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cylinder_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_cylinder_layout;
+  ntype.declare = file_ns::geo_node_mesh_primitive_cylinder_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cylinder_exec;
+  ntype.draw_buttons = file_ns::geo_node_mesh_primitive_cylinder_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc
index 73c679e18f8..82593151204 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc
@@ -27,31 +27,6 @@
 
 namespace blender::nodes {
 
-static void geo_node_mesh_primitive_grid_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Float>(N_("Size X"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .subtype(PROP_DISTANCE)
-      .description(N_("Side length of the plane in the X direction"));
-  b.add_input<decl::Float>(N_("Size Y"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .subtype(PROP_DISTANCE)
-      .description(N_("Side length of the plane in the Y direction"));
-  b.add_input<decl::Int>(N_("Vertices X"))
-      .default_value(3)
-      .min(2)
-      .max(1000)
-      .description(N_("Number of vertices in the X direction"));
-  b.add_input<decl::Int>(N_("Vertices Y"))
-      .default_value(3)
-      .min(2)
-      .max(1000)
-      .description(N_("Number of vertices in the Y direction"));
-  b.add_output<decl::Geometry>(N_("Mesh"));
-}
-
 static void calculate_uvs(
     Mesh *mesh, Span<MVert> verts, Span<MLoop> loops, const float size_x, const float size_y)
 {
@@ -169,6 +144,35 @@ Mesh *create_grid_mesh(const int verts_x,
   return mesh;
 }
 
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_mesh_primitive_grid_cc {
+
+static void geo_node_mesh_primitive_grid_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Float>(N_("Size X"))
+      .default_value(1.0f)
+      .min(0.0f)
+      .subtype(PROP_DISTANCE)
+      .description(N_("Side length of the plane in the X direction"));
+  b.add_input<decl::Float>(N_("Size Y"))
+      .default_value(1.0f)
+      .min(0.0f)
+      .subtype(PROP_DISTANCE)
+      .description(N_("Side length of the plane in the Y direction"));
+  b.add_input<decl::Int>(N_("Vertices X"))
+      .default_value(3)
+      .min(2)
+      .max(1000)
+      .description(N_("Number of vertices in the X direction"));
+  b.add_input<decl::Int>(N_("Vertices Y"))
+      .default_value(3)
+      .min(2)
+      .max(1000)
+      .description(N_("Number of vertices in the Y direction"));
+  b.add_output<decl::Geometry>(N_("Mesh"));
+}
+
 static void geo_node_mesh_primitive_grid_exec(GeoNodeExecParams params)
 {
   const float size_x = params.extract_input<float>("Size X");
@@ -187,14 +191,16 @@ static void geo_node_mesh_primitive_grid_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_grid_cc
 
 void register_node_type_geo_mesh_primitive_grid()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_grid_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_GRID, "Grid", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_grid_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_grid_exec;
+  ntype.declare = file_ns::geo_node_mesh_primitive_grid_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_grid_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc
index e4bf5e31dbf..97155c3b0c6 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_primitive_ico_sphere_cc {
 
 static void geo_node_mesh_primitive_ico_sphere_declare(NodeDeclarationBuilder &b)
 {
@@ -78,15 +78,17 @@ static void geo_node_mesh_primitive_ico_sphere_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_ico_sphere_cc
 
 void register_node_type_geo_mesh_primitive_ico_sphere()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_ico_sphere_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_MESH_PRIMITIVE_ICO_SPHERE, "Ico Sphere", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_ico_sphere_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_ico_sphere_exec;
+  ntype.declare = file_ns::geo_node_mesh_primitive_ico_sphere_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_ico_sphere_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc
index 1a92be1c05d..6e61c494a05 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_primitive_line_cc {
 
 static void geo_node_mesh_primitive_line_declare(NodeDeclarationBuilder &b)
 {
@@ -100,39 +100,6 @@ static void geo_node_mesh_primitive_line_update(bNodeTree *ntree, bNode *node)
                                 count_mode == GEO_NODE_MESH_LINE_COUNT_TOTAL);
 }
 
-static void fill_edge_data(MutableSpan<MEdge> edges)
-{
-  for (const int i : edges.index_range()) {
-    edges[i].v1 = i;
-    edges[i].v2 = i + 1;
-    edges[i].flag |= ME_LOOSEEDGE;
-  }
-}
-
-Mesh *create_line_mesh(const float3 start, const float3 delta, const int count)
-{
-  if (count < 1) {
-    return nullptr;
-  }
-
-  Mesh *mesh = BKE_mesh_new_nomain(count, count - 1, 0, 0, 0);
-  BKE_id_material_eval_ensure_default_slot(&mesh->id);
-  MutableSpan<MVert> verts{mesh->mvert, mesh->totvert};
-  MutableSpan<MEdge> edges{mesh->medge, mesh->totedge};
-
-  short normal[3];
-  normal_float_to_short_v3(normal, delta.normalized());
-
-  for (const int i : verts.index_range()) {
-    copy_v3_v3(verts[i].co, start + delta * i);
-    copy_v3_v3_short(verts[i].no, normal);
-  }
-
-  fill_edge_data(edges);
-
-  return mesh;
-}
-
 static void geo_node_mesh_primitive_line_exec(GeoNodeExecParams params)
 {
   const NodeGeometryMeshLine &storage = *(const NodeGeometryMeshLine *)params.node().storage;
@@ -174,19 +141,58 @@ static void geo_node_mesh_primitive_line_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
+}  // namespace blender::nodes::node_geo_mesh_primitive_line_cc
+
+namespace blender::nodes {
+
+static void fill_edge_data(MutableSpan<MEdge> edges)
+{
+  for (const int i : edges.index_range()) {
+    edges[i].v1 = i;
+    edges[i].v2 = i + 1;
+    edges[i].flag |= ME_LOOSEEDGE;
+  }
+}
+
+Mesh *create_line_mesh(const float3 start, const float3 delta, const int count)
+{
+  if (count < 1) {
+    return nullptr;
+  }
+
+  Mesh *mesh = BKE_mesh_new_nomain(count, count - 1, 0, 0, 0);
+  BKE_id_material_eval_ensure_default_slot(&mesh->id);
+  MutableSpan<MVert> verts{mesh->mvert, mesh->totvert};
+  MutableSpan<MEdge> edges{mesh->medge, mesh->totedge};
+
+  short normal[3];
+  normal_float_to_short_v3(normal, delta.normalized());
+
+  for (const int i : verts.index_range()) {
+    copy_v3_v3(verts[i].co, start + delta * i);
+    copy_v3_v3_short(verts[i].no, normal);
+  }
+
+  fill_edge_data(edges);
+
+  return mesh;
+}
+
 }  // namespace blender::nodes
 
 void register_node_type_geo_mesh_primitive_line()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_line_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_LINE, "Mesh Line", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_line_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_line_init);
-  node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_line_update);
+  ntype.declare = file_ns::geo_node_mesh_primitive_line_declare;
+  node_type_init(&ntype, file_ns::geo_node_mesh_primitive_line_init);
+  node_type_update(&ntype, file_ns::geo_node_mesh_primitive_line_update);
   node_type_storage(
       &ntype, "NodeGeometryMeshLine", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_line_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_line_layout;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_line_exec;
+  ntype.draw_buttons = file_ns::geo_node_mesh_primitive_line_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc
index 3197a94c27b..03e6528c86a 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_primitive_uv_sphere_cc {
 
 static void geo_node_mesh_primitive_uv_shpere_declare(NodeDeclarationBuilder &b)
 {
@@ -313,15 +313,17 @@ static void geo_node_mesh_primitive_uv_sphere_exec(GeoNodeExecParams params)
   params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_primitive_uv_sphere_cc
 
 void register_node_type_geo_mesh_primitive_uv_sphere()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_primitive_uv_sphere_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_MESH_PRIMITIVE_UV_SPHERE, "UV Sphere", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_primitive_uv_shpere_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_uv_sphere_exec;
+  ntype.declare = file_ns::geo_node_mesh_primitive_uv_shpere_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_uv_sphere_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc
index d99c0c851a8..49da9c1ff9d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_subdivide.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_subdivide_cc {
 
 static void geo_node_mesh_subdivide_declare(NodeDeclarationBuilder &b)
 {
@@ -97,14 +97,16 @@ static void geo_node_mesh_subdivide_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_subdivide_cc
 
 void register_node_type_geo_mesh_subdivide()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_subdivide_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SUBDIVIDE_MESH, "Subdivide Mesh", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_subdivide_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_subdivide_exec;
+  ntype.declare = file_ns::geo_node_mesh_subdivide_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_subdivide_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
index 11865c635b8..4fe57d89bb8 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_to_curve_cc {
 
 static void geo_node_legacy_mesh_to_curve_declare(NodeDeclarationBuilder &b)
 {
@@ -56,14 +56,16 @@ static void geo_node_legacy_mesh_to_curve_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_to_curve_cc
 
 void register_node_type_geo_mesh_to_curve()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_to_curve_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_TO_CURVE, "Mesh to Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_mesh_to_curve_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_mesh_to_curve_exec;
+  ntype.declare = file_ns::geo_node_legacy_mesh_to_curve_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_legacy_mesh_to_curve_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
index a37e3e34777..7c87c959200 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
@@ -26,7 +26,7 @@
 
 using blender::Array;
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_mesh_to_points_cc {
 
 static void geo_node_mesh_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -172,17 +172,19 @@ static void geo_node_mesh_to_points_exec(GeoNodeExecParams params)
   params.set_output("Points", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_mesh_to_points_cc
 
 void register_node_type_geo_mesh_to_points()
 {
+  namespace file_ns = blender::nodes::node_geo_mesh_to_points_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_TO_POINTS, "Mesh to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_to_points_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_to_points_init);
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_to_points_layout;
+  ntype.declare = file_ns::geo_node_mesh_to_points_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_mesh_to_points_exec;
+  node_type_init(&ntype, file_ns::geo_node_mesh_to_points_init);
+  ntype.draw_buttons = file_ns::geo_node_mesh_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryMeshToPoints", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_object_info.cc b/source/blender/nodes/geometry/nodes/node_geo_object_info.cc
index bb8e5f7e29b..f01f1930bc0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_object_info.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_object_info.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_object_info_cc {
 
 static void geo_node_object_info_declare(NodeDeclarationBuilder &b)
 {
@@ -115,18 +115,20 @@ static void geo_node_object_info_node_init(bNodeTree *UNUSED(tree), bNode *node)
   node->storage = data;
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_object_info_cc
 
 void register_node_type_geo_object_info()
 {
+  namespace file_ns = blender::nodes::node_geo_object_info_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_object_info_node_init);
+  node_type_init(&ntype, file_ns::geo_node_object_info_node_init);
   node_type_storage(
       &ntype, "NodeGeometryObjectInfo", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_object_info_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_object_info_layout;
-  ntype.declare = blender::nodes::geo_node_object_info_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_object_info_exec;
+  ntype.draw_buttons = file_ns::geo_node_object_info_layout;
+  ntype.declare = file_ns::geo_node_object_info_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
index 5a6a3b25a45..722d08295a7 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_vertices.cc
@@ -21,9 +21,9 @@
 
 #include "node_geometry_util.hh"
 
-using blender::Array;
+namespace blender::nodes::node_geo_points_to_vertices_cc {
 
-namespace blender::nodes {
+using blender::Array;
 
 static void geo_node_points_to_vertices_declare(NodeDeclarationBuilder &b)
 {
@@ -104,15 +104,17 @@ static void geo_node_points_to_vertices_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_points_to_vertices_cc
 
 void register_node_type_geo_points_to_vertices()
 {
+  namespace file_ns = blender::nodes::node_geo_points_to_vertices_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_POINTS_TO_VERTICES, "Points to Vertices", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_points_to_vertices_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_points_to_vertices_exec;
+  ntype.declare = file_ns::geo_node_points_to_vertices_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_points_to_vertices_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
index 31c16cb95e0..d283bab9b9f 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc
@@ -28,7 +28,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_points_to_volume_cc {
 
 static void geo_node_points_to_volume_declare(NodeDeclarationBuilder &b)
 {
@@ -252,10 +252,12 @@ static void geo_node_points_to_volume_exec(GeoNodeExecParams params)
 #endif
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_points_to_volume_cc
 
 void register_node_type_geo_points_to_volume()
 {
+  namespace file_ns = blender::nodes::node_geo_points_to_volume_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
@@ -265,10 +267,10 @@ void register_node_type_geo_points_to_volume()
                     node_free_standard_storage,
                     node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_points_to_volume_init);
-  node_type_update(&ntype, blender::nodes::geo_node_points_to_volume_update);
-  ntype.declare = blender::nodes::geo_node_points_to_volume_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_points_to_volume_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_points_to_volume_layout;
+  node_type_init(&ntype, file_ns::geo_node_points_to_volume_init);
+  node_type_update(&ntype, file_ns::geo_node_points_to_volume_update);
+  ntype.declare = file_ns::geo_node_points_to_volume_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_points_to_volume_exec;
+  ntype.draw_buttons = file_ns::geo_node_points_to_volume_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
index c05476b982b..68c4dd8bbee 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc
@@ -27,7 +27,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_proximity_cc {
 
 static void geo_node_proximity_declare(NodeDeclarationBuilder &b)
 {
@@ -233,18 +233,20 @@ static void geo_node_proximity_exec(GeoNodeExecParams params)
   params.set_output("Distance", Field<float>(proximity_op, 1));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_proximity_cc
 
 void register_node_type_geo_proximity()
 {
+  namespace file_ns = blender::nodes::node_geo_proximity_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_PROXIMITY, "Geometry Proximity", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_proximity_init);
+  node_type_init(&ntype, file_ns::geo_proximity_init);
   node_type_storage(
       &ntype, "NodeGeometryProximity", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_proximity_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_proximity_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_proximity_layout;
+  ntype.declare = file_ns::geo_node_proximity_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_proximity_exec;
+  ntype.draw_buttons = file_ns::geo_node_proximity_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
index 150be6b4695..e7638ffe00d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
@@ -25,9 +25,9 @@
 
 #include "node_geometry_util.hh"
 
-using namespace blender::bke::mesh_surface_sample;
+namespace blender::nodes::node_geo_raycast_cc {
 
-namespace blender::nodes {
+using namespace blender::bke::mesh_surface_sample;
 
 static void geo_node_raycast_declare(NodeDeclarationBuilder &b)
 {
@@ -426,20 +426,22 @@ static void geo_node_raycast_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_raycast_cc
 
 void register_node_type_geo_raycast()
 {
+  namespace file_ns = blender::nodes::node_geo_raycast_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_RAYCAST, "Raycast", NODE_CLASS_GEOMETRY, 0);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, blender::nodes::geo_node_raycast_init);
-  node_type_update(&ntype, blender::nodes::geo_node_raycast_update);
+  node_type_init(&ntype, file_ns::geo_node_raycast_init);
+  node_type_update(&ntype, file_ns::geo_node_raycast_update);
   node_type_storage(
       &ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_raycast_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_raycast_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_raycast_layout;
+  ntype.declare = file_ns::geo_node_raycast_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_raycast_exec;
+  ntype.draw_buttons = file_ns::geo_node_raycast_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc
index 6c51c1f738f..e879d275e3a 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_realize_instances.cc
@@ -19,7 +19,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_realize_instances_cc {
 
 static void geo_node_realize_instances_declare(NodeDeclarationBuilder &b)
 {
@@ -34,15 +34,17 @@ static void geo_node_realize_instances_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_realize_instances_cc
 
 void register_node_type_geo_realize_instances()
 {
+  namespace file_ns = blender::nodes::node_geo_realize_instances_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_REALIZE_INSTANCES, "Realize Instances", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_realize_instances_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_realize_instances_exec;
+  ntype.declare = file_ns::geo_node_realize_instances_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_realize_instances_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
index c53eaa2ded9..da835421040 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_rotate_instances.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_rotate_instances_cc {
 
 static void geo_node_rotate_instances_declare(NodeDeclarationBuilder &b)
 {
@@ -106,15 +106,17 @@ static void geo_node_rotate_instances_exec(GeoNodeExecParams params)
   params.set_output("Instances", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_rotate_instances_cc
 
 void register_node_type_geo_rotate_instances()
 {
+  namespace file_ns = blender::nodes::node_geo_rotate_instances_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_ROTATE_INSTANCES, "Rotate Instances", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_rotate_instances_exec;
-  ntype.declare = blender::nodes::geo_node_rotate_instances_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_rotate_instances_exec;
+  ntype.declare = file_ns::geo_node_rotate_instances_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
index fa2501515a9..a3de4a25077 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_scale_instances.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_scale_instances_cc {
 
 static void geo_node_scale_instances_declare(NodeDeclarationBuilder &b)
 {
@@ -85,14 +85,16 @@ static void geo_node_scale_instances_exec(GeoNodeExecParams params)
   params.set_output("Instances", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_scale_instances_cc
 
 void register_node_type_geo_scale_instances()
 {
+  namespace file_ns = blender::nodes::node_geo_scale_instances_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SCALE_INSTANCES, "Scale Instances", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_scale_instances_exec;
-  ntype.declare = blender::nodes::geo_node_scale_instances_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_scale_instances_exec;
+  ntype.declare = file_ns::geo_node_scale_instances_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc
index a16fb712b13..a7deee2bb98 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_separate_components.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_separate_components_cc {
 
 static void geo_node_join_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -61,15 +61,17 @@ static void geo_node_separate_components_exec(GeoNodeExecParams params)
   params.set_output("Instances", instances);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_separate_components_cc
 
 void register_node_type_geo_separate_components()
 {
+  namespace file_ns = blender::nodes::node_geo_separate_components_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SEPARATE_COMPONENTS, "Separate Components", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_join_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_separate_components_exec;
+  ntype.declare = file_ns::geo_node_join_geometry_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_separate_components_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
index 28e214c0ccc..ebec3143396 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_separate_geometry_cc {
 
 static void geo_node_separate_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -95,10 +95,12 @@ static void geo_node_separate_geometry_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_separate_geometry_cc
 
 void register_node_type_geo_separate_geometry()
 {
+  namespace file_ns = blender::nodes::node_geo_separate_geometry_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
@@ -109,10 +111,10 @@ void register_node_type_geo_separate_geometry()
                     node_free_standard_storage,
                     node_copy_standard_storage);
 
-  node_type_init(&ntype, blender::nodes::geo_node_separate_geometry_init);
+  node_type_init(&ntype, file_ns::geo_node_separate_geometry_init);
 
-  ntype.declare = blender::nodes::geo_node_separate_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_separate_geometry_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_separate_geometry_layout;
+  ntype.declare = file_ns::geo_node_separate_geometry_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_separate_geometry_exec;
+  ntype.draw_buttons = file_ns::geo_node_separate_geometry_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
index 30b445da58c..363a2c424fd 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_handles.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_curve_handles_cc {
 
 static void geo_node_set_curve_handles_declare(NodeDeclarationBuilder &b)
 {
@@ -162,22 +162,24 @@ static void geo_node_set_curve_handles_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_curve_handles_cc
 
 void register_node_type_geo_set_curve_handles()
 {
+  namespace file_ns = blender::nodes::node_geo_set_curve_handles_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_CURVE_HANDLES, "Set Handle Positions", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_curve_handles_exec;
-  ntype.declare = blender::nodes::geo_node_set_curve_handles_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_curve_handles_exec;
+  ntype.declare = file_ns::geo_node_set_curve_handles_declare;
   ntype.minwidth = 100.0f;
-  node_type_init(&ntype, blender::nodes::geo_node_set_curve_handles_init);
+  node_type_init(&ntype, file_ns::geo_node_set_curve_handles_init);
   node_type_storage(&ntype,
                     "NodeGeometrySetCurveHandlePositions",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_set_curve_handles_layout;
+  ntype.draw_buttons = file_ns::geo_node_set_curve_handles_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
index e47ce7dea30..14192d777a3 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_curve_radius_cc {
 
 static void geo_node_set_curve_radius_declare(NodeDeclarationBuilder &b)
 {
@@ -69,15 +69,17 @@ static void geo_node_set_curve_radius_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_curve_radius_cc
 
 void register_node_type_geo_set_curve_radius()
 {
+  namespace file_ns = blender::nodes::node_geo_set_curve_radius_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_CURVE_RADIUS, "Set Curve Radius", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_curve_radius_exec;
-  ntype.declare = blender::nodes::geo_node_set_curve_radius_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_curve_radius_exec;
+  ntype.declare = file_ns::geo_node_set_curve_radius_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
index a861c35f738..12440d5241f 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_tilt.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_curve_tilt_cc {
 
 static void geo_node_set_curve_tilt_declare(NodeDeclarationBuilder &b)
 {
@@ -65,14 +65,16 @@ static void geo_node_set_curve_tilt_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_curve_tilt_cc
 
 void register_node_type_geo_set_curve_tilt()
 {
+  namespace file_ns = blender::nodes::node_geo_set_curve_tilt_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SET_CURVE_TILT, "Set Curve Tilt", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_curve_tilt_exec;
-  ntype.declare = blender::nodes::geo_node_set_curve_tilt_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_curve_tilt_exec;
+  ntype.declare = file_ns::geo_node_set_curve_tilt_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
index 77d8e786501..282faa9fddb 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_id.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_id_cc {
 
 static void geo_node_set_id_declare(NodeDeclarationBuilder &b)
 {
@@ -81,14 +81,16 @@ static void geo_node_set_id_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_id_cc
 
 void register_node_type_geo_set_id()
 {
+  namespace file_ns = blender::nodes::node_geo_set_id_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SET_ID, "Set ID", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_id_exec;
-  ntype.declare = blender::nodes::geo_node_set_id_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_id_exec;
+  ntype.declare = file_ns::geo_node_set_id_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_material.cc b/source/blender/nodes/geometry/nodes/node_geo_set_material.cc
index 3817de02a38..39e9b4da93e 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_material.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_material.cc
@@ -25,7 +25,7 @@
 
 #include "BKE_material.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_material_cc {
 
 static void geo_node_set_material_declare(NodeDeclarationBuilder &b)
 {
@@ -103,14 +103,16 @@ static void geo_node_set_material_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_material_cc
 
 void register_node_type_geo_set_material()
 {
+  namespace file_ns = blender::nodes::node_geo_set_material_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SET_MATERIAL, "Set Material", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_set_material_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_material_exec;
+  ntype.declare = file_ns::geo_node_set_material_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_material_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
index a8bb1bd8644..10821631fcf 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_material_index.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_material_index_cc {
 
 static void geo_node_set_material_index_declare(NodeDeclarationBuilder &b)
 {
@@ -64,15 +64,17 @@ static void geo_node_set_material_index_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_material_index_cc
 
 void register_node_type_geo_set_material_index()
 {
+  namespace file_ns = blender::nodes::node_geo_set_material_index_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_MATERIAL_INDEX, "Set Material Index", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_material_index_exec;
-  ntype.declare = blender::nodes::geo_node_set_material_index_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_material_index_exec;
+  ntype.declare = file_ns::geo_node_set_material_index_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
index 9ff299542b4..b85323eb640 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_point_radius_cc {
 
 static void geo_node_set_point_radius_declare(NodeDeclarationBuilder &b)
 {
@@ -70,15 +70,17 @@ static void geo_node_set_point_radius_exec(GeoNodeExecParams params)
   params.set_output("Points", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_point_radius_cc
 
 void register_node_type_geo_set_point_radius()
 {
+  namespace file_ns = blender::nodes::node_geo_set_point_radius_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_POINT_RADIUS, "Set Point Radius", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_point_radius_exec;
-  ntype.declare = blender::nodes::geo_node_set_point_radius_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_point_radius_exec;
+  ntype.declare = file_ns::geo_node_set_point_radius_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
index 5fe9fb1b3d4..99349da451b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_position_cc {
 
 static void geo_node_set_position_declare(NodeDeclarationBuilder &b)
 {
@@ -89,14 +89,16 @@ static void geo_node_set_position_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_position_cc
 
 void register_node_type_geo_set_position()
 {
+  namespace file_ns = blender::nodes::node_geo_set_position_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SET_POSITION, "Set Position", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_position_exec;
-  ntype.declare = blender::nodes::geo_node_set_position_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_position_exec;
+  ntype.declare = file_ns::geo_node_set_position_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
index 06e25c2ed55..441f60d077b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_shade_smooth.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_shade_smooth_cc {
 
 static void geo_node_set_shade_smooth_declare(NodeDeclarationBuilder &b)
 {
@@ -64,15 +64,17 @@ static void geo_node_set_shade_smooth_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_shade_smooth_cc
 
 void register_node_type_geo_set_shade_smooth()
 {
+  namespace file_ns = blender::nodes::node_geo_set_shade_smooth_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_SHADE_SMOOTH, "Set Shade Smooth", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_shade_smooth_exec;
-  ntype.declare = blender::nodes::geo_node_set_shade_smooth_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_shade_smooth_exec;
+  ntype.declare = file_ns::geo_node_set_shade_smooth_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
index ec751ae1d2b..1dee686bd4d 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_cyclic.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_spline_cyclic_cc {
 
 static void geo_node_set_spline_cyclic_declare(NodeDeclarationBuilder &b)
 {
@@ -65,15 +65,17 @@ static void geo_node_set_spline_cyclic_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_spline_cyclic_cc
 
 void register_node_type_geo_set_spline_cyclic()
 {
+  namespace file_ns = blender::nodes::node_geo_set_spline_cyclic_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_SPLINE_CYCLIC, "Set Spline Cyclic", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_spline_cyclic_exec;
-  ntype.declare = blender::nodes::geo_node_set_spline_cyclic_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_spline_cyclic_exec;
+  ntype.declare = file_ns::geo_node_set_spline_cyclic_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
index ccf419975ca..f7a3fc989be 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_spline_resolution.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_set_spline_resolution_cc {
 
 static void geo_node_set_spline_resolution_declare(NodeDeclarationBuilder &b)
 {
@@ -81,15 +81,17 @@ static void geo_node_set_spline_resolution_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_set_spline_resolution_cc
 
 void register_node_type_geo_set_spline_resolution()
 {
+  namespace file_ns = blender::nodes::node_geo_set_spline_resolution_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_SPLINE_RESOLUTION, "Set Spline Resolution", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_spline_resolution_exec;
-  ntype.declare = blender::nodes::geo_node_set_spline_resolution_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_set_spline_resolution_exec;
+  ntype.declare = file_ns::geo_node_set_spline_resolution_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_string_join.cc b/source/blender/nodes/geometry/nodes/node_geo_string_join.cc
index 98d0aca084a..e3715c72c6e 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_string_join.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_string_join.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_string_join_cc {
 
 static void geo_node_string_join_declare(NodeDeclarationBuilder &b)
 {
@@ -40,14 +40,16 @@ static void geo_node_string_join_exec(GeoNodeExecParams params)
   params.set_output("String", std::move(output));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_string_join_cc
 
 void register_node_type_geo_string_join()
 {
+  namespace file_ns = blender::nodes::node_geo_string_join_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_STRING_JOIN, "Join Strings", NODE_CLASS_CONVERTER, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_string_join_exec;
-  ntype.declare = blender::nodes::geo_node_string_join_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_string_join_exec;
+  ntype.declare = file_ns::geo_node_string_join_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc b/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc
index 9e3ff10a3c5..01b3ea7d521 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_string_to_curves.cc
@@ -30,7 +30,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_string_to_curves_cc {
 
 static void geo_node_string_to_curves_declare(NodeDeclarationBuilder &b)
 {
@@ -297,23 +297,25 @@ static void geo_node_string_to_curves_exec(GeoNodeExecParams params)
   params.set_output("Curves", std::move(geometry_set_out));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_string_to_curves_cc
 
 void register_node_type_geo_string_to_curves()
 {
+  namespace file_ns = blender::nodes::node_geo_string_to_curves_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_STRING_TO_CURVES, "String to Curves", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_string_to_curves_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_string_to_curves_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_string_to_curves_init);
-  node_type_update(&ntype, blender::nodes::geo_node_string_to_curves_update);
+  ntype.declare = file_ns::geo_node_string_to_curves_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_string_to_curves_exec;
+  node_type_init(&ntype, file_ns::geo_node_string_to_curves_init);
+  node_type_update(&ntype, file_ns::geo_node_string_to_curves_update);
   node_type_size(&ntype, 190, 120, 700);
   node_type_storage(&ntype,
                     "NodeGeometryStringToCurves",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_string_to_curves_layout;
+  ntype.draw_buttons = file_ns::geo_node_string_to_curves_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
index 2b3430a5ed0..13f5e8149fe 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
@@ -27,7 +27,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_subdivision_surface_cc {
 
 static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
 {
@@ -145,18 +145,20 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_subdivision_surface_cc
 
 void register_node_type_geo_subdivision_surface()
 {
+  namespace file_ns = blender::nodes::node_geo_subdivision_surface_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
+  ntype.declare = file_ns::geo_node_subdivision_surface_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_subdivision_surface_exec;
+  ntype.draw_buttons = file_ns::geo_node_subdivision_surface_layout;
+  node_type_init(&ntype, file_ns::geo_node_subdivision_surface_init);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
   node_type_storage(&ntype,
                     "NodeGeometrySubdivisionSurface",
diff --git a/source/blender/nodes/geometry/nodes/node_geo_switch.cc b/source/blender/nodes/geometry/nodes/node_geo_switch.cc
index 8d6f53ae375..e44730ec98b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_switch.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_switch.cc
@@ -26,7 +26,7 @@
 
 #include "FN_multi_function_signature.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_switch_cc {
 
 static void geo_node_switch_declare(NodeDeclarationBuilder &b)
 {
@@ -293,19 +293,21 @@ static void geo_node_switch_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_switch_cc
 
 void register_node_type_geo_switch()
 {
+  namespace file_ns = blender::nodes::node_geo_switch_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SWITCH, "Switch", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = blender::nodes::geo_node_switch_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_switch_init);
-  node_type_update(&ntype, blender::nodes::geo_node_switch_update);
+  ntype.declare = file_ns::geo_node_switch_declare;
+  node_type_init(&ntype, file_ns::geo_node_switch_init);
+  node_type_update(&ntype, file_ns::geo_node_switch_update);
   node_type_storage(&ntype, "NodeSwitch", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_switch_exec;
+  ntype.geometry_node_execute = file_ns::geo_node_switch_exec;
   ntype.geometry_node_execute_supports_laziness = true;
-  ntype.draw_buttons = blender::nodes::geo_node_switch_layout;
+  ntype.draw_buttons = file_ns::geo_node_switch_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
index 74b4c5d30c0..b0d6bcfa8cb 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
@@ -33,11 +33,11 @@
 
 #include "node_geometry_util.hh"
 
+namespace blender::nodes::node_geo_transfer_attribute_cc {
+
 using namespace blender::bke::mesh_surface_sample;
 using blender::fn::GArray;
 
-namespace blender::nodes {
-
 static void geo_node_transfer_attribute_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Target"))
@@ -793,22 +793,24 @@ static void geo_node_transfer_attribute_exec(GeoNodeExecParams params)
   output_attribute_field(params, std::move(output_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_transfer_attribute_cc
 
 void register_node_type_geo_transfer_attribute()
 {
+  namespace file_ns = blender::nodes::node_geo_transfer_attribute_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_TRANSFER_ATTRIBUTE, "Transfer Attribute", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_transfer_attribute_init);
-  node_type_update(&ntype, blender::nodes::geo_node_transfer_attribute_update);
+  node_type_init(&ntype, file_ns::geo_node_transfer_attribute_init);
+  node_type_update(&ntype, file_ns::geo_node_transfer_attribute_update);
   node_type_storage(&ntype,
                     "NodeGeometryTransferAttribute",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_transfer_attribute_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_transfer_attribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_transfer_attribute_layout;
+  ntype.declare = file_ns::geo_node_transfer_attribute_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_transfer_attribute_exec;
+  ntype.draw_buttons = file_ns::geo_node_transfer_attribute_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_transform.cc
index 2c55a255b5d..758183338c5 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_transform.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_transform.cc
@@ -35,15 +35,6 @@
 
 namespace blender::nodes {
 
-static void geo_node_transform_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Geometry>(N_("Geometry"));
-  b.add_input<decl::Vector>(N_("Translation")).subtype(PROP_TRANSLATION);
-  b.add_input<decl::Vector>(N_("Rotation")).subtype(PROP_EULER);
-  b.add_input<decl::Vector>(N_("Scale")).default_value({1, 1, 1}).subtype(PROP_XYZ);
-  b.add_output<decl::Geometry>(N_("Geometry"));
-}
-
 static bool use_translate(const float3 rotation, const float3 scale)
 {
   if (compare_ff(rotation.length_squared(), 0.0f, 1e-9f) != 1) {
@@ -69,15 +60,6 @@ static void transform_mesh(Mesh &mesh, const float4x4 &transform)
   BKE_mesh_normals_tag_dirty(&mesh);
 }
 
-void transform_mesh(Mesh &mesh,
-                    const float3 translation,
-                    const float3 rotation,
-                    const float3 scale)
-{
-  const float4x4 matrix = float4x4::from_loc_eul_scale(translation, rotation, scale);
-  transform_mesh(mesh, matrix);
-}
-
 static void translate_pointcloud(PointCloud &pointcloud, const float3 translation)
 {
   CustomData_duplicate_referenced_layer(&pointcloud.pdata, CD_PROP_FLOAT3, pointcloud.totpoint);
@@ -153,48 +135,70 @@ static void translate_volume(Volume &volume, const float3 translation, const Dep
   transform_volume(volume, float4x4::from_location(translation), depsgraph);
 }
 
-void transform_geometry_set(GeometrySet &geometry,
-                            const float4x4 &transform,
-                            const Depsgraph &depsgraph)
+static void translate_geometry_set(GeometrySet &geometry,
+                                   const float3 translation,
+                                   const Depsgraph &depsgraph)
 {
   if (CurveEval *curve = geometry.get_curve_for_write()) {
-    curve->transform(transform);
+    curve->translate(translation);
   }
   if (Mesh *mesh = geometry.get_mesh_for_write()) {
-    transform_mesh(*mesh, transform);
+    translate_mesh(*mesh, translation);
   }
   if (PointCloud *pointcloud = geometry.get_pointcloud_for_write()) {
-    transform_pointcloud(*pointcloud, transform);
+    translate_pointcloud(*pointcloud, translation);
   }
   if (Volume *volume = geometry.get_volume_for_write()) {
-    transform_volume(*volume, transform, depsgraph);
+    translate_volume(*volume, translation, depsgraph);
   }
   if (geometry.has_instances()) {
-    transform_instances(geometry.get_component_for_write<InstancesComponent>(), transform);
+    translate_instances(geometry.get_component_for_write<InstancesComponent>(), translation);
   }
 }
 
-static void translate_geometry_set(GeometrySet &geometry,
-                                   const float3 translation,
-                                   const Depsgraph &depsgraph)
+void transform_geometry_set(GeometrySet &geometry,
+                            const float4x4 &transform,
+                            const Depsgraph &depsgraph)
 {
   if (CurveEval *curve = geometry.get_curve_for_write()) {
-    curve->translate(translation);
+    curve->transform(transform);
   }
   if (Mesh *mesh = geometry.get_mesh_for_write()) {
-    translate_mesh(*mesh, translation);
+    transform_mesh(*mesh, transform);
   }
   if (PointCloud *pointcloud = geometry.get_pointcloud_for_write()) {
-    translate_pointcloud(*pointcloud, translation);
+    transform_pointcloud(*pointcloud, transform);
   }
   if (Volume *volume = geometry.get_volume_for_write()) {
-    translate_volume(*volume, translation, depsgraph);
+    transform_volume(*volume, transform, depsgraph);
   }
   if (geometry.has_instances()) {
-    translate_instances(geometry.get_component_for_write<InstancesComponent>(), translation);
+    transform_instances(geometry.get_component_for_write<InstancesComponent>(), transform);
   }
 }
 
+void transform_mesh(Mesh &mesh,
+                    const float3 translation,
+                    const float3 rotation,
+                    const float3 scale)
+{
+  const float4x4 matrix = float4x4::from_loc_eul_scale(translation, rotation, scale);
+  transform_mesh(mesh, matrix);
+}
+
+}  // namespace blender::nodes
+
+namespace blender::nodes::node_geo_transform_cc {
+
+static void geo_node_transform_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Geometry>(N_("Geometry"));
+  b.add_input<decl::Vector>(N_("Translation")).subtype(PROP_TRANSLATION);
+  b.add_input<decl::Vector>(N_("Rotation")).subtype(PROP_EULER);
+  b.add_input<decl::Vector>(N_("Scale")).default_value({1, 1, 1}).subtype(PROP_XYZ);
+  b.add_output<decl::Geometry>(N_("Geometry"));
+}
+
 static void geo_node_transform_exec(GeoNodeExecParams params)
 {
   GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
@@ -214,14 +218,16 @@ static void geo_node_transform_exec(GeoNodeExecParams params)
 
   params.set_output("Geometry", std::move(geometry_set));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_transform_cc
 
 void register_node_type_geo_transform()
 {
+  namespace file_ns = blender::nodes::node_geo_transform_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_TRANSFORM, "Transform", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_transform_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_transform_exec;
+  ntype.declare = file_ns::geo_node_transform_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_transform_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
index 1a5a60fb1b0..3450ce604a0 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_translate_instances.cc
@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_translate_instances_cc {
 
 static void geo_node_translate_instances_declare(NodeDeclarationBuilder &b)
 {
@@ -70,15 +70,17 @@ static void geo_node_translate_instances_exec(GeoNodeExecParams params)
   params.set_output("Instances", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_translate_instances_cc
 
 void register_node_type_geo_translate_instances()
 {
+  namespace file_ns = blender::nodes::node_geo_translate_instances_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(
       &ntype, GEO_NODE_TRANSLATE_INSTANCES, "Translate Instances", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_translate_instances_exec;
-  ntype.declare = blender::nodes::geo_node_translate_instances_declare;
+  ntype.geometry_node_execute = file_ns::geo_node_translate_instances_exec;
+  ntype.declare = file_ns::geo_node_translate_instances_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
index c869846e1f8..0a8a1f3c276 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_triangulate.cc
@@ -27,7 +27,7 @@ Mesh *triangulate_mesh(Mesh *mesh,
                        const int flag);
 }
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_triangulate_cc {
 
 static void geo_node_triangulate_declare(NodeDeclarationBuilder &b)
 {
@@ -69,16 +69,18 @@ static void geo_node_triangulate_exec(GeoNodeExecParams params)
 
   params.set_output("Mesh", std::move(geometry_set));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_triangulate_cc
 
 void register_node_type_geo_triangulate()
 {
+  namespace file_ns = blender::nodes::node_geo_triangulate_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_TRIANGULATE, "Triangulate", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_triangulate_declare;
-  node_type_init(&ntype, blender::nodes::geo_triangulate_init);
-  ntype.geometry_node_execute = blender::nodes::geo_node_triangulate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_triangulate_layout;
+  ntype.declare = file_ns::geo_node_triangulate_declare;
+  node_type_init(&ntype, file_ns::geo_triangulate_init);
+  ntype.geometry_node_execute = file_ns::geo_node_triangulate_exec;
+  ntype.draw_buttons = file_ns::geo_node_triangulate_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_viewer.cc b/source/blender/nodes/geometry/nodes/node_geo_viewer.cc
index a46d7529124..86ea7e5ed77 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_viewer.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_viewer.cc
@@ -19,7 +19,8 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_viewer_cc {
+
 static void geo_node_viewer_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Geometry"));
@@ -77,18 +78,20 @@ static void geo_node_viewer_update(bNodeTree *ntree, bNode *node)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_viewer_cc
 
 void register_node_type_geo_viewer()
 {
+  namespace file_ns = blender::nodes::node_geo_viewer_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, 0);
   node_type_storage(
       &ntype, "NodeGeometryViewer", node_free_standard_storage, node_copy_standard_storage);
-  node_type_update(&ntype, blender::nodes::geo_node_viewer_update);
-  node_type_init(&ntype, blender::nodes::geo_node_viewer_init);
-  ntype.declare = blender::nodes::geo_node_viewer_declare;
-  ntype.draw_buttons_ex = blender::nodes::geo_node_viewer_layout;
+  node_type_update(&ntype, file_ns::geo_node_viewer_update);
+  node_type_init(&ntype, file_ns::geo_node_viewer_init);
+  ntype.declare = file_ns::geo_node_viewer_declare;
+  ntype.draw_buttons_ex = file_ns::geo_node_viewer_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc
index 99eeae370fe..692bbba8a51 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc
@@ -35,7 +35,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::node_geo_volume_to_mesh_cc {
 
 static void geo_node_volume_to_mesh_declare(NodeDeclarationBuilder &b)
 {
@@ -194,20 +194,22 @@ static void geo_node_volume_to_mesh_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::node_geo_volume_to_mesh_cc
 
 void register_node_type_geo_volume_to_mesh()
 {
+  namespace file_ns = blender::nodes::node_geo_volume_to_mesh_cc;
+
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_VOLUME_TO_MESH, "Volume to Mesh", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_volume_to_mesh_declare;
+  ntype.declare = file_ns::geo_node_volume_to_mesh_declare;
   node_type_storage(
       &ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_volume_to_mesh_init);
-  node_type_update(&ntype, blender::nodes::geo_node_volume_to_mesh_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_volume_to_mesh_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_volume_to_mesh_layout;
+  node_type_init(&ntype, file_ns::geo_node_volume_to_mesh_init);
+  node_type_update(&ntype, file_ns::geo_node_volume_to_mesh_update);
+  ntype.geometry_node_execute = file_ns::geo_node_volume_to_mesh_exec;
+  ntype.draw_buttons = file_ns::geo_node_volume_to_mesh_layout;
   nodeRegisterType(&ntype);
 }