How to increase stack size more than 2047

b79 · May 14, 2025, 2:52pm

Godot Version

4.4

Question

I am implementing Wave Function Collapse on 2D square lattice. All is fine with the code, but here is the issue. I use recursion A LOT and I ended up finishing the stack of 1024 bites. So even a 40x40 map does not work.
The code is right. In fact, I managed to increase stack size from the properties menu up to 2047 and 40x40 now works.
But not 50x50.

Properties does not allow me more than 2047.

I tried adding the line:
ProjectSettings.set_setting(“debug/settings/gdscript/max_call_stack”,4096)

in the _ready function.

It does not give rise to an exception, but also it does not do anything.

Now please everybody don’t lecture me on computer science.
I know recursion has its drawbacks wrt iteration.
I know you can turn any recursion into iteration, and vice versa.

To be honest, I already turned one of the recursions into an iteration and now I run 100x100 maps fine, and maybe even more (still have to try). Now I do recursion only in the func used to update entropies and not on the main one.
Fine. Problem solved.

But… NO!!!

No way! Dammit guys, I WANT to be able to set the stack size the the value I want, anytime! I can’t believe to not be able to do it!!!

So how can I do it?!

mrcdk · May 14, 2025, 4:40pm

It’s not possible to go bigger than 2047. It’s a hardcoded value to avoid stack overflow:

github.com/godotengine/godot

modules/gdscript/gdscript.cpp

428a762e9


      
          	strings._script_source = StringName("script/source");
          	_debug_parse_err_line = -1;
          	_debug_parse_err_file = "";
          
          #ifdef DEBUG_ENABLED
          	profiling = false;
          	profile_native_calls = false;
          	script_frame_time = 0;
          #endif
          
          	_debug_max_call_stack = GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "debug/settings/gdscript/max_call_stack", PROPERTY_HINT_RANGE, "512," + itos(GDScriptFunction::MAX_CALL_DEPTH - 1) + ",1"), 1024);
          	track_call_stack = GLOBAL_DEF_RST("debug/settings/gdscript/always_track_call_stacks", false);
          	track_locals = GLOBAL_DEF_RST("debug/settings/gdscript/always_track_local_variables", false);
          
          #ifdef DEBUG_ENABLED
          	track_call_stack = true;
          	track_locals = track_locals || EngineDebugger::is_active();
          
          	GLOBAL_DEF("debug/gdscript/warnings/enable", true);
          	GLOBAL_DEF("debug/gdscript/warnings/exclude_addons", true);
          	GLOBAL_DEF("debug/gdscript/warnings/renamed_in_godot_4_hint", true);

github.com/godotengine/godot

modules/gdscript/gdscript_function.h

428a762e9


      
          		} NativeProfile;
          		HashMap<String, NativeProfile> native_calls;
          		HashMap<String, NativeProfile> last_native_calls;
          	} profile;
          #endif
          
          	_FORCE_INLINE_ String _get_call_error(const String &p_where, const Variant **p_argptrs, const Variant &p_ret, const Callable::CallError &p_err) const;
          	Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type);
          
          public:
          	static constexpr int MAX_CALL_DEPTH = 2048; // Limit to try to avoid crash because of a stack overflow.
          
          	struct CallState {
          		GDScript *script = nullptr;
          		GDScriptInstance *instance = nullptr;
          #ifdef DEBUG_ENABLED
          		StringName function_name;
          		String script_path;
          #endif
          		Vector<uint8_t> stack;
          		int stack_size = 0;

In the VM if the depth is bigger than that constant it will just return early the default value:

github.com/godotengine/godot

modules/gdscript/gdscript_vm.cpp

428a762e9


      
          	if (unlikely(++call_depth > MAX_CALL_DEPTH)) {
          		call_depth--;
          #ifdef DEBUG_ENABLED
          		String err_file;
          		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && !p_instance->script->path.is_empty()) {
          			err_file = p_instance->script->path;
          		} else if (_script) {
          			err_file = _script->path;
          		}
          		if (err_file.is_empty()) {
          			err_file = "<built-in>";
          		}
          		String err_func = name;
          		if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->local_name != StringName()) {
          			err_func = p_instance->script->local_name.operator String() + "." + err_func;
          		}
          		int err_line = _initial_line;
          		const char *err_text = "Stack overflow. Check for infinite recursion in your script.";
          		if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
          			// Debugger break did not happen.

This file has been truncated. show original

hexgrid · May 14, 2025, 6:45pm

If this is strongly important to you, my suggestion would be:

see if Godot supports tail recursion (assuming you can make your recursive functions tail calls…)
if not, consider proposing making gdscript properly tail recursive

b79 · May 14, 2025, 9:01pm

Thank you all for your replies!

I think that, instead of propising making gdscript properly tail recursive, one might simply propose to remove the hardcode maximum of 2047. I’m perfectly fine with the default value of 1024, I don’t get why imposing this further constraint. A constraint that is actually close to the default value, which means even less sense to me.

hexgrid · May 14, 2025, 9:22pm

Practically speaking, I suspect you’ll find the devs unwilling to contemplate removing the hard limit on the stack; something needs to prevent stack overflow, and there may well be other parts of the code that do not behave well (or indeed, may behave extremely badly) if the stack overruns. You might be able to convince them to up the hard limit, but I expect removing it entirely will be a difficult thing to sell.

On the other hand, you’ve got source for Godot, and @mrcdk has pointed you at the relevant bits of it; you could always set MAX_CALL_DEPTH yourself and build from source.