Cannot build with double precision using version godot-4.5-stable

[rewindturtle]

Godot version

4.5-stable

godot-cpp version

godot-4.5-stable

System information

Windows 10, Intel i5-11600K

Issue description

The file godot-cpp/gdextension/extension_api.json contains the line ""precision": "single"" in its header. Attempting to build the library with the scons "precision" option set to "double" results in the error:
Exception: Cannot do a precision=double build using 'godot-cpp/gdextension/extension_api.json' which was generated by Godot built with precision=single

Steps to reproduce

1. Clone the godot-cpp repo and checkout tag godot-4.5-stable.
2. Enter the godot-cpp repo and run the command "scons precision=double"

Minimal reproduction project

N/A

[enetheru]

I'm pretty sure this is how its supposed to work. And that you need to create an API dump from a double precision build of godot itself using the --dump-api command.
Here is a direct link to the documentation with the relevant information:

https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/gdextension_cpp_example.html#building-the-c-bindings

https://docs.godotengine.org/en/stable/tutorials/scripting/cpp/about_godot_cpp.html#version-compatibility

[Ivorforce]

Yes, the check was recently added because using the single precision bindings with a double build is incorrect and can lead to crashes. It's just that earlier versions didn't warn you about it.

[dsnopek]

The rule is: if you've built the engine yourself using different code or build options from the official builds, then you should generate your own extension_api.json from your custom Godot build. The official builds are done with precision=single, so that rule applies here!

[ernzo]

-I personally have no problem building double/single precision mono/non-mono editors, in Debian:
scons platform=linuxbsd target=editor dev_build=no module_mono_enabled=yes use_llvm=yes linker=mold precision=single -j$(nproc)

scons platform=linuxbsd target=editor dev_build=no module_mono_enabled=yes use_llvm=yes linker=mold precision=double -j$(nproc)

-But I'm having a strange related problem here with the GDExtension godot-cpp Template:
https://github.com/godotengine/godot-cpp-template

It doesnt matter if I set the command "float=single" or "precision=single"
scons platform=linux target=template_debug custom_api_file="extension_api.json" float=single

Scons always builds the double precision one:

scons: Reading SConscript files ...
WARNING: Unknown SCons variables were passed and will be ignored:
    float=single
Auto-detected 8 CPU cores available for build parallelism. Using 7 cores by default. You can override it with the -j argument.
Building for architecture x86_64 on platform linux
scons: done reading SConscript files.
scons: Building targets ...
Generating godot-cpp/gen/include/godot_cpp/core/ext_wrappers.gen.inc ...
Built-in type config: float_64

Built-in type config: float_64<

I have tried editing the SConstruct files in both Template, and godot-cpp itself -> No Luck.

Even entirely removing the option from godot-cpp-template-main/godot-cpp/tools/godotcpp.py

    opts.Add(
        EnumVariable(
            key="precision",
            help="Set the floating-point precision level",
            default=env.get("precision", "single"),
            allowed_values=("single"),  <> line 297

# if env["precision"] == "double":
    #     env.Append(CPPDEFINES=["REAL_T_IS_DOUBLE"]) <> line 501

No luck!
It will always try to build the float_64 version.

-Of course I'm usin the extension_api.json extracted from a Single Precision editor,
but that doesnt seem to make a difference.

-I managed to build the Template as it comes, and got it running on a Double precision mono editor:

Godot Engine v4.5.stable.mono.double.custom_build.876b29033 (2025-09-15 01:30:02 UTC) - [https://godotengine.org](https://www.google.com/url?sa=E&q=https%3A%2F%2Fgodotengine.org)
Vulkan 1.4.305 - Forward+ - Using Device #0: AMD - AMD Radeon RX 6600 (RADV NAVI23)

Type: 24

-However I really dont need a Double precision editor nor library;
and it's possible double precision may rule out exporting to arm32.. right?

And that's the situation..
Template works;
my custom C++ code never works even if the library is built without errors/warnings..

I can build template and it works,
but it will make a Double precision library, no matter what..

-It will surely be positive if this proposal got implemented:
godotengine/godot#90979

And we could try to build our GDExtension libraries directly on Godot..
by simply adding the C++ code on a .cpp and .h file,
and having it auto updated on the register_types or SConstruct files by godot editor itself.

Right now doing it manually,
you risk getting entangled in the build environ itself..

Needs to be a bit more fool proof!

[Ivorforce]

Hi, the correct argument is precision=double/precision=single, not float=double. Your console output tells you this as well:

WARNING: Unknown SCons variables were passed and will be ignored:
float=single

[ernzo]

Good catch!

Yes I tried it both ways, also with precision=single:

ernzo@debian:~/Documents/Projects/4.5 Stable/GDExtension Conversion/godot-cpp-template-main➤ scons platform=linux target=template_debug custom_api_file="extension_api.json" precision=single            
scons: Reading SConscript files ...
Auto-detected 8 CPU cores available for build parallelism. Using 7 cores by default. You can override it with the -j argument.
Building for architecture x86_64 on platform linux
scons: done reading SConscript files.
scons: Building targets ...
Generating godot-cpp/gen/include/godot_cpp/core/ext_wrappers.gen.inc ...
Built-in type config: float_64
Compiling godot-cpp/src/core/memory.cpp ...
scons_generate_doc_source(["src/gen/doc_data.gen.cpp"], ["doc_classes/ExampleClass.xml"])
Compiling shared src/gen/doc_data.gen.cpp ...
scons: Build interrupted.
scons: building terminated because of errors.

I'm still getting:
"Built-in type config: float_64"

So I assumed something was bypassing it, and edited the files..
but even with the option apparently removed inside godot-cpp 4.5..

godotcpp.py:

    opts.Add(
        EnumVariable(
            key="precision",
            help="Set the floating-point precision level",
            default=env.get("precision", "single"),
            allowed_values=("single"), <> Line 297

Keeps doing it float 64..

It's possible I'm totally wrong and the culprit is somewhere else tho..!

[Ivorforce]

I'm not sure I understand.

precision=single is the default Godot build. You can use the normal extension_api.json for it (i.e. custom_api_file does not have to be set, it's already correct).

If you want a float64 build, you need to build Godot with precision=double, and use an extension_api.json file generated with it.

[ernzo]

I understand it even less.. lol
but thanks for the confirmation:

"precision=single is the default Godot build"

When building an Editor is indeed the default..

It's probably just a mix-up on my end with the GDExtension template (made for godot 4.1) and godot-cpp 4.5

I will keep on trying,
and see if I can translate at least one of the C# scripts on my app to GDExtension C++ ..

If I manage to get it working, I will have to sort it out tho,
otherwise, you cannot export to arm32 with a Double Precision Editor/library.. right?

[aaronfranke]

@ernzo float_64 means 32-bit float and 64-bit hardware architecture, while double_64 means 64-bit float and 64-bit hardware architecture, and float_32 means 32-bit float and 32-bit hardware architecture.

[ernzo]

Luckily all the problems I had with godot-cpp precision and GDExtesions got solved!

I managed to translate all the C# scripts to C++,
and the app went from 52,6MB to 14,8MB download in Google Store/Console!

Also the Performance increased pretty considerably,
and that makes the app better in all aspects, as it's a measuring tool..

-As for the Single/Double Precision matter..
The problem got fixed, and after deleting everything and starting fresh, the Precision type was respected on GDExt library build.

Something made Single Precision libs to be built with Double precision,
which required a DP Editor to run...

The problem disappeared after nuking all the files and caches and starting fresh, once again..

-For all the noobs like me.. it can be done!
C++ GDEXt is not the easiest or most documented thing, but the system is solid!

It's a bit steep, but as long as you take the Template and structure your code properly,
godot-cpp will compile it into a .so library no problem, which then you can integrate and call directly from Godot..

Once the library is built and recognised by Godot,
linking the library to your .gd script and calling the methods is just as direct as calling normal C# methods..

-So again No Problem in Debian/trixie,
Editors can be built with Single/Double Precision, Mono/Non-mono..

C++ GDExt libs can be built with Single/Double Precision, and exported to linux, arm32/64 x86_64.. it all works as intended!

The next thing for me will be, porting the entire app to iOS,
looks like the library I built will compatible no probs.. so it's about XCode and what it might require.

[dsnopek]

Great, I'm glad you got it working!