Moving to https://github.com/godotengine/godot-cpp.

Thanks for the report!

Just to make sure I'm understanding correctly: the issue is caused by the classes that were added to Godot in your custom module, not the classes added in your GDExtension? That does make sense, given that all the generated classes are dumped into the same directory, and so scons would put them in the same .a file

I'm not sure what tools (if any) scons gives us to deal with this. A potential solution is just making more directories for the generated .cpp files, such that we ensure that each directory only holds a maximum of 50 (?) files?

Just to make sure I'm understanding correctly: the issue is caused by the classes that were added to Godot in your custom module, not the classes added in your GDExtension?

Yes that's correct.

That does make sense, given that all the generated classes are dumped into the same directory, and so scons would put them in the same .a file
I'm not sure what tools (if any) scons gives us to deal with this. A potential solution is just making more directories for the generated .cpp files, such that we ensure that each directory only holds a maximum of 50 (?) files?

I don’t think this would work, because the issue is with the number of files passed to the command that creates the library, and we want to reduce that number. I am trying a different approach: create small intermediate static libraries and then link them together.

Edit:
Here is an attempt trying to implement this approach (to apply in godotcpp.py in the _godot_cpp method) but it doesn't work... The resulting library is empty:

-        library = env.StaticLibrary(target=env.File("bin/%s" % library_name), source=sources)
+        libraries = []
+        remaining = sources[:]
+        n = 0
+        while len(remaining) > 0:
+            libraries.append(env.StaticLibrary(target="bin/libgodot-cpp-part_%d%s" % (n, env["suffix"] + env["LIBSUFFIX"]), source=remaining[:100]))
+            remaining = remaining[100:]
+            n += 1
+
+        library = env.StaticLibrary(target=env.File("bin/%s" % library_name), source=[], LIBS=libraries)
+        for lib in libraries:
+            env.Depends(env.File("bin/%s" % library_name), lib)
+

I can't find a single out-of-the-box method that is portable:

• Linking smaller static libraries together doesn’t work as I thought because the object files they contain are not extracted and repackaged.
• Incrementally building a large static library seems possible using ar with the right options, but this is not portable.
• Extracting object files from smaller static libraries and then merging them should work, but this is also not portable.

As far as I can tell, we are left with two possible approaches, but one requirement must be dropped:

• Instead of building a single static library, build smaller static libraries and let the GDExtension shared library link against them.
• Create a custom builder, specific to Unix-like systems, to incrementally build the single large static library.

does using a file for the options work?
https://www.man7.org/linux/man-pages/man1/ar.1.html

@file
           Read command-line options from file.  The options read are
           inserted in place of the original @file option.  If file does
           not exist, or cannot be read, then the option will be treated
           literally, and not removed.

           Options in file are separated by whitespace.  A whitespace
           character may be included in an option by surrounding the
           entire option in either single or double quotes.  Any
           character (including a backslash) may be included by prefixing
           the character to be included with a backslash.  The file may
           itself contain additional @file options; any such options will
           be processed recursively.

Nice idea!

It works, I am making some more tests and will provide a PR in a few hours if everything is fine.