diff --git a/.gitignore b/.gitignore
index 539003ca6b97..861d15ea9f42 100644
--- a/.gitignore
+++ b/.gitignore
@@ -284,6 +284,7 @@ Generated\ Files/
 *.pidb
 *.svclog
 *.scc
+*.obj.enc
 
 # Visual C++ cache files
 ipch/
diff --git a/core/debugger/debugger_marshalls.cpp b/core/debugger/debugger_marshalls.cpp
index 4c69290c2e6b..1ad75c1ceef0 100644
--- a/core/debugger/debugger_marshalls.cpp
+++ b/core/debugger/debugger_marshalls.cpp
@@ -32,10 +32,10 @@
 
 #include "core/io/marshalls.h"
 
-#define CHECK_SIZE(arr, expected, what) ERR_FAIL_COND_V_MSG((uint32_t)arr.size() < (uint32_t)(expected), false, String("Malformed ") + what + " message from script debugger, message too short. Expected size: " + itos(expected) + ", actual size: " + itos(arr.size()))
-#define CHECK_END(arr, expected, what) ERR_FAIL_COND_V_MSG((uint32_t)arr.size() > (uint32_t)expected, false, String("Malformed ") + what + " message from script debugger, message too long. Expected size: " + itos(expected) + ", actual size: " + itos(arr.size()))
+#define CHECK_SIZE(arr, expected, what) ERR_FAIL_COND_V_MSG((uint32_t)(arr).size() < (uint32_t)(expected), false, String("Malformed ") + (what) + " message from script debugger, message too short. Expected size: " + itos(expected) + ", actual size: " + itos((arr).size()))
+#define CHECK_END(arr, expected, what) ERR_FAIL_COND_V_MSG((uint32_t)(arr).size() > (uint32_t)(expected), false, String("Malformed ") + (what) + " message from script debugger, message too long. Expected size: " + itos(expected) + ", actual size: " + itos((arr).size()))
 
-Array DebuggerMarshalls::ScriptStackDump::serialize() {
+Array DebuggerMarshalls::ScriptStackDump::serialize() const {
 	Array arr;
 	arr.push_back(frames.size() * 3);
 	for (int i = 0; i < frames.size(); i++) {
@@ -43,27 +43,54 @@ Array DebuggerMarshalls::ScriptStackDump::serialize() {
 		arr.push_back(frames[i].line);
 		arr.push_back(frames[i].func);
 	}
+	if (!tid.is_zero()) {
+		arr.push_back(tid);
+	}
 	return arr;
 }
 
 bool DebuggerMarshalls::ScriptStackDump::deserialize(const Array &p_arr) {
 	CHECK_SIZE(p_arr, 1, "ScriptStackDump");
-	uint32_t size = p_arr[0];
+	const uint32_t size = p_arr[0];
 	CHECK_SIZE(p_arr, size, "ScriptStackDump");
 	int idx = 1;
 	for (uint32_t i = 0; i < size / 3; i++) {
-		ScriptLanguage::StackInfo sf;
+		StackInfo sf;
 		sf.file = p_arr[idx];
 		sf.line = p_arr[idx + 1];
 		sf.func = p_arr[idx + 2];
 		frames.push_back(sf);
 		idx += 3;
 	}
+	if (idx == p_arr.size() - 1) {
+		// one extra data item is optional TID
+		tid = p_arr[idx];
+		++idx;
+	} else {
+		tid.zero();
+	}
 	CHECK_END(p_arr, idx, "ScriptStackDump");
 	return true;
 }
 
-Array DebuggerMarshalls::ScriptStackVariable::serialize(int max_size) {
+void DebuggerMarshalls::ScriptStackDump::populate(const ScriptLanguageThreadContext &p_context) {
+	tid = p_context.debug_get_thread_id();
+	const int slc = p_context.debug_get_stack_level_count();
+	for (int i = 0; i < slc; i++) {
+		StackInfo frame;
+		frame.file = p_context.debug_get_stack_level_source(i);
+		frame.line = p_context.debug_get_stack_level_line(i);
+		frame.func = p_context.debug_get_stack_level_function(i);
+		frames.push_back(frame);
+	}
+}
+
+void DebuggerMarshalls::ScriptStackDump::clear() {
+	tid = DebugThreadID();
+	frames.clear();
+}
+
+Array DebuggerMarshalls::ScriptStackVariable::serialize(int max_size) const {
 	Array arr;
 	arr.push_back(name);
 	arr.push_back(type);
@@ -74,7 +101,7 @@ Array DebuggerMarshalls::ScriptStackVariable::serialize(int max_size) {
 	}
 
 	int len = 0;
-	Error err = encode_variant(var, nullptr, len, true);
+	const Error err = encode_variant(var, nullptr, len, true);
 	if (err != OK) {
 		ERR_PRINT("Failed to encode variant.");
 	}
@@ -96,7 +123,7 @@ bool DebuggerMarshalls::ScriptStackVariable::deserialize(const Array &p_arr) {
 	return true;
 }
 
-Array DebuggerMarshalls::OutputError::serialize() {
+Array DebuggerMarshalls::OutputError::serialize() const {
 	Array arr;
 	arr.push_back(hr);
 	arr.push_back(min);
@@ -108,8 +135,8 @@ Array DebuggerMarshalls::OutputError::serialize() {
 	arr.push_back(error);
 	arr.push_back(error_descr);
 	arr.push_back(warning);
-	unsigned int size = callstack.size();
-	const ScriptLanguage::StackInfo *r = callstack.ptr();
+	const unsigned int size = callstack.size();
+	const StackInfo *r = callstack.ptr();
 	arr.push_back(size * 3);
 	for (int i = 0; i < callstack.size(); i++) {
 		arr.push_back(r[i].file);
@@ -131,11 +158,11 @@ bool DebuggerMarshalls::OutputError::deserialize(const Array &p_arr) {
 	error = p_arr[7];
 	error_descr = p_arr[8];
 	warning = p_arr[9];
-	unsigned int stack_size = p_arr[10];
+	const unsigned int stack_size = p_arr[10];
 	CHECK_SIZE(p_arr, stack_size, "OutputError");
 	int idx = 11;
-	callstack.resize(stack_size / 3);
-	ScriptLanguage::StackInfo *w = callstack.ptrw();
+	callstack.resize(static_cast<int>(stack_size) / 3);
+	StackInfo *w = callstack.ptrw();
 	for (unsigned int i = 0; i < stack_size / 3; i++) {
 		w[i].file = p_arr[idx];
 		w[i].func = p_arr[idx + 1];
diff --git a/core/debugger/debugger_marshalls.h b/core/debugger/debugger_marshalls.h
index 751e8a637114..30e0dbca24b4 100644
--- a/core/debugger/debugger_marshalls.h
+++ b/core/debugger/debugger_marshalls.h
@@ -34,21 +34,29 @@
 #include "core/object/script_language.h"
 
 struct DebuggerMarshalls {
+	using DebugThreadID = ScriptLanguageThreadContext::DebugThreadID;
+	using StackInfo = ScriptLanguageThreadContext::StackInfo;
+
 	struct ScriptStackVariable {
 		String name;
 		Variant value;
 		int type = -1;
 
-		Array serialize(int max_size = 1 << 20); // 1 MiB default.
+		Array serialize(int max_size = 1 << 20) const; // 1 MiB default.
 		bool deserialize(const Array &p_arr);
 	};
 
 	struct ScriptStackDump {
-		List<ScriptLanguage::StackInfo> frames;
-		ScriptStackDump() {}
+		DebugThreadID tid;
+		List<StackInfo> frames;
+
+		ScriptStackDump() = default;
 
-		Array serialize();
+		Array serialize() const;
 		bool deserialize(const Array &p_arr);
+
+		void populate(const ScriptLanguageThreadContext &p_context);
+		void clear();
 	};
 
 	struct OutputError {
@@ -62,9 +70,9 @@ struct DebuggerMarshalls {
 		String error;
 		String error_descr;
 		bool warning = false;
-		Vector<ScriptLanguage::StackInfo> callstack;
+		Vector<StackInfo> callstack;
 
-		Array serialize();
+		Array serialize() const;
 		bool deserialize(const Array &p_arr);
 	};
 };
diff --git a/core/debugger/engine_debugger.h b/core/debugger/engine_debugger.h
index 236d5e5f6318..b3375302577d 100644
--- a/core/debugger/engine_debugger.h
+++ b/core/debugger/engine_debugger.h
@@ -36,10 +36,10 @@
 #include "core/templates/hash_map.h"
 #include "core/templates/vector.h"
 #include "core/variant/array.h"
-#include "core/variant/variant.h"
 
 class RemoteDebuggerPeer;
 class ScriptDebugger;
+class ScriptLanguageThreadContext;
 
 class EngineDebugger {
 public:
@@ -61,7 +61,8 @@ class EngineDebugger {
 		bool active = false;
 
 	public:
-		Profiler() {}
+		Profiler() = default;
+
 		Profiler(void *p_data, ProfilingToggle p_toggle, ProfilingAdd p_add, ProfilingTick p_tick) {
 			data = p_data;
 			toggle = p_toggle;
@@ -77,7 +78,8 @@ class EngineDebugger {
 		void *data = nullptr;
 
 	public:
-		Capture() {}
+		Capture() = default;
+
 		Capture(void *p_data, CaptureFunc p_capture) {
 			data = p_data;
 			capture = p_capture;
@@ -110,7 +112,7 @@ class EngineDebugger {
 
 	static void initialize(const String &p_uri, bool p_skip_breakpoints, Vector<String> p_breakpoints, void (*p_allow_focus_steal_fn)());
 	static void deinitialize();
-	static void register_profiler(const StringName &p_name, const Profiler &p_profiler);
+	static void register_profiler(const StringName &p_name, const Profiler &p_func);
 	static void unregister_profiler(const StringName &p_name);
 	static bool is_profiling(const StringName &p_name);
 	static bool has_profiler(const StringName &p_name);
@@ -128,10 +130,19 @@ class EngineDebugger {
 
 	void line_poll();
 
-	virtual void poll_events(bool p_is_idle) {}
+	virtual void poll_events(bool) {}
 	virtual void send_message(const String &p_msg, const Array &p_data) = 0;
 	virtual void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type) = 0;
-	virtual void debug(bool p_can_continue = true, bool p_is_error_breakpoint = false) = 0;
+
+	// Initiate new debugging session on the caller thread and block the caller for the duration.
+	virtual void debug(ScriptLanguageThreadContext &p_focused_thread) = 0;
+
+	// Notify that the caller thread would like to be selected for debugging,
+	// but debugger is busy with another thread.
+	virtual void request_debug(const ScriptLanguageThreadContext &p_any_thread) = 0;
+
+	// Notify that the specified thread is held and can be inquired for stack info, but don't block.
+	virtual void thread_paused(const ScriptLanguageThreadContext &p_any_thread) = 0;
 
 	virtual ~EngineDebugger();
 };
diff --git a/core/debugger/local_debugger.cpp b/core/debugger/local_debugger.cpp
index 58d239ccb986..1b9751538d68 100644
--- a/core/debugger/local_debugger.cpp
+++ b/core/debugger/local_debugger.cpp
@@ -68,7 +68,7 @@ struct LocalDebugger::ScriptsProfiler {
 	void _print_frame_data(bool p_accumulated) {
 		uint64_t diff = OS::get_singleton()->get_ticks_usec() - idle_accum;
 
-		if (!p_accumulated && diff < 1000000) { //show every one second
+		if (!p_accumulated && diff < 1000000) { // show every one second
 			return;
 		}
 
@@ -113,24 +113,43 @@ struct LocalDebugger::ScriptsProfiler {
 	}
 };
 
-void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
-	ScriptLanguage *script_lang = script_debugger->get_break_language();
+void LocalDebugger::_print_stack_header(ScriptLanguageThreadContext &p_focused_thread) {
+	const PackedByteArray tid = p_focused_thread.debug_get_thread_id();
+	print_line(vformat("#Thread %s", String::hex_encode_buffer(tid.ptr(), tid.size())));
+}
+
+void LocalDebugger::_print_status(ScriptLanguageThreadContext &p_focused_thread, int current_frame) {
+	print_line("\nDebugger Break, Reason: '" + p_focused_thread.debug_get_error() + "'");
+	_print_stack_header(p_focused_thread);
+	_print_frame(p_focused_thread, 0, 0);
+}
 
+void LocalDebugger::_print_frame(ScriptLanguageThreadContext &p_focused_thread, int printed_frame, int current_frame) {
+	String cfi = (current_frame == printed_frame) ? "*" : " "; // current frame indicator
+	print_line(cfi + "Frame " + itos(printed_frame) + " - " + p_focused_thread.debug_get_stack_level_source(printed_frame) + ":" +
+			itos(p_focused_thread.debug_get_stack_level_line(printed_frame)) + " in function '" +
+			p_focused_thread.debug_get_stack_level_function(printed_frame) + "'");
+}
+
+void LocalDebugger::debug(ScriptLanguageThreadContext &p_focused_thread) {
+	if (!p_focused_thread.is_main_thread()) {
+		// REVISIT: Thread debugging is not (yet) supported for LocalDebugger, so just let the thread
+		// run and refuse to debug it.
+		return;
+	}
 	if (!target_function.is_empty()) {
-		String current_function = script_lang->debug_get_stack_level_function(0);
+		String current_function = p_focused_thread.debug_get_stack_level_function(0);
 		if (current_function != target_function) {
-			script_debugger->set_depth(0);
-			script_debugger->set_lines_left(1);
+			p_focused_thread.debug_step();
 			return;
 		}
 		target_function = "";
 	}
 
-	print_line("\nDebugger Break, Reason: '" + script_lang->debug_get_error() + "'");
-	print_line("*Frame " + itos(0) + " - " + script_lang->debug_get_stack_level_source(0) + ":" + itos(script_lang->debug_get_stack_level_line(0)) + " in function '" + script_lang->debug_get_stack_level_function(0) + "'");
+	_print_status(p_focused_thread, 0);
 	print_line("Enter \"help\" for assistance.");
 	int current_frame = 0;
-	int total_frames = script_lang->debug_get_stack_level_count();
+	int total_frames = p_focused_thread.debug_get_stack_level_count();
 	while (true) {
 		OS::get_singleton()->print("debug> ");
 		String line = OS::get_singleton()->get_stdin_string().strip_edges();
@@ -139,27 +158,28 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 		String variable_prefix = options["variable_prefix"];
 
 		if (line.is_empty()) {
-			print_line("\nDebugger Break, Reason: '" + script_lang->debug_get_error() + "'");
-			print_line("*Frame " + itos(current_frame) + " - " + script_lang->debug_get_stack_level_source(current_frame) + ":" + itos(script_lang->debug_get_stack_level_line(current_frame)) + " in function '" + script_lang->debug_get_stack_level_function(current_frame) + "'");
+			_print_status(p_focused_thread, current_frame);
 			print_line("Enter \"help\" for assistance.");
+
 		} else if (line == "c" || line == "continue") {
 			break;
-		} else if (line == "bt" || line == "breakpoint") {
+
+		} else if (line == "bt" || line == "backtrace") {
+			_print_stack_header(p_focused_thread);
 			for (int i = 0; i < total_frames; i++) {
-				String cfi = (current_frame == i) ? "*" : " "; //current frame indicator
-				print_line(cfi + "Frame " + itos(i) + " - " + script_lang->debug_get_stack_level_source(i) + ":" + itos(script_lang->debug_get_stack_level_line(i)) + " in function '" + script_lang->debug_get_stack_level_function(i) + "'");
+				_print_frame(p_focused_thread, i, current_frame);
 			}
 
 		} else if (line.begins_with("fr") || line.begins_with("frame")) {
 			if (line.get_slice_count(" ") == 1) {
-				print_line("*Frame " + itos(current_frame) + " - " + script_lang->debug_get_stack_level_source(current_frame) + ":" + itos(script_lang->debug_get_stack_level_line(current_frame)) + " in function '" + script_lang->debug_get_stack_level_function(current_frame) + "'");
+				_print_frame(p_focused_thread, current_frame, current_frame);
 			} else {
 				int frame = line.get_slicec(' ', 1).to_int();
 				if (frame < 0 || frame >= total_frames) {
 					print_line("Error: Invalid frame.");
 				} else {
 					current_frame = frame;
-					print_line("*Frame " + itos(frame) + " - " + script_lang->debug_get_stack_level_source(frame) + ":" + itos(script_lang->debug_get_stack_level_line(frame)) + " in function '" + script_lang->debug_get_stack_level_function(frame) + "'");
+					_print_frame(p_focused_thread, current_frame, current_frame);
 				}
 			}
 
@@ -192,19 +212,19 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 		} else if (line == "lv" || line == "locals") {
 			List<String> locals;
 			List<Variant> values;
-			script_lang->debug_get_stack_level_locals(current_frame, &locals, &values);
+			p_focused_thread.debug_get_stack_level_locals(current_frame, &locals, &values);
 			print_variables(locals, values, variable_prefix);
 
 		} else if (line == "gv" || line == "globals") {
 			List<String> globals;
 			List<Variant> values;
-			script_lang->debug_get_globals(&globals, &values);
+			p_focused_thread.get_language()->debug_get_globals(&globals, &values);
 			print_variables(globals, values, variable_prefix);
 
 		} else if (line == "mv" || line == "members") {
 			List<String> members;
 			List<Variant> values;
-			script_lang->debug_get_stack_level_members(current_frame, &members, &values);
+			p_focused_thread.debug_get_stack_level_members(current_frame, &members, &values);
 			print_variables(members, values, variable_prefix);
 
 		} else if (line.begins_with("p") || line.begins_with("print")) {
@@ -212,26 +232,23 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 				print_line("Usage: print <expre>");
 			} else {
 				String expr = line.get_slicec(' ', 2);
-				String res = script_lang->debug_parse_stack_level_expression(current_frame, expr);
+				String res = p_focused_thread.debug_parse_stack_level_expression(current_frame, expr);
 				print_line(res);
 			}
 
 		} else if (line == "s" || line == "step") {
-			script_debugger->set_depth(-1);
-			script_debugger->set_lines_left(1);
+			p_focused_thread.debug_step();
 			break;
 		} else if (line == "n" || line == "next") {
-			script_debugger->set_depth(0);
-			script_debugger->set_lines_left(1);
+			p_focused_thread.debug_next();
 			break;
 		} else if (line == "fin" || line == "finish") {
-			String current_function = script_lang->debug_get_stack_level_function(0);
+			String current_function = p_focused_thread.debug_get_stack_level_function(0);
 
 			for (int i = 0; i < total_frames; i++) {
-				target_function = script_lang->debug_get_stack_level_function(i);
+				target_function = p_focused_thread.debug_get_stack_level_function(i);
 				if (target_function != current_function) {
-					script_debugger->set_depth(0);
-					script_debugger->set_lines_left(1);
+					p_focused_thread.debug_step_out();
 					return;
 				}
 			}
@@ -270,8 +287,7 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 		} else if (line == "q" || line == "quit") {
 			// Do not stop again on quit
 			script_debugger->clear_breakpoints();
-			script_debugger->set_depth(-1);
-			script_debugger->set_lines_left(-1);
+			p_focused_thread.debug_continue();
 
 			MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 			if (main_loop->get_class() == "SceneTree") {
@@ -318,6 +334,16 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 	}
 }
 
+void LocalDebugger::request_debug(const ScriptLanguageThreadContext &p_context) {
+	// REVISIT: Thread debugging is not (yet) supported for LocalDebugger.
+	(void)p_context;
+}
+
+void LocalDebugger::thread_paused(const ScriptLanguageThreadContext &p_context) {
+	// REVISIT: Thread debugging is not (yet) supported for LocalDebugger.
+	(void)p_context;
+}
+
 void LocalDebugger::print_variables(const List<String> &names, const List<Variant> &values, const String &variable_prefix) {
 	String value;
 	Vector<String> value_lines;
diff --git a/core/debugger/local_debugger.h b/core/debugger/local_debugger.h
index c687214c653c..0c40cec4e689 100644
--- a/core/debugger/local_debugger.h
+++ b/core/debugger/local_debugger.h
@@ -36,7 +36,6 @@
 #include "core/templates/list.h"
 
 class LocalDebugger : public EngineDebugger {
-private:
 	struct ScriptsProfiler;
 
 	ScriptsProfiler *scripts_profiler = nullptr;
@@ -47,10 +46,16 @@ class LocalDebugger : public EngineDebugger {
 	Pair<String, int> to_breakpoint(const String &p_line);
 	void print_variables(const List<String> &names, const List<Variant> &values, const String &variable_prefix);
 
+	void _print_stack_header(ScriptLanguageThreadContext &p_focused_thread);
+	void _print_status(ScriptLanguageThreadContext &p_focused_thread, int current_frame);
+	void _print_frame(ScriptLanguageThreadContext &p_focused_thread, int printed_frame, int current_frame);
+
 public:
-	void debug(bool p_can_continue, bool p_is_error_breakpoint);
-	void send_message(const String &p_message, const Array &p_args);
-	void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type);
+	void debug(ScriptLanguageThreadContext &p_focused_thread) override;
+	void request_debug(const ScriptLanguageThreadContext &p_context) override;
+	void thread_paused(const ScriptLanguageThreadContext &p_context) override;
+	void send_message(const String &p_message, const Array &p_args) override;
+	void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type) override;
 
 	LocalDebugger();
 	~LocalDebugger();
diff --git a/core/debugger/remote_debugger.cpp b/core/debugger/remote_debugger.cpp
index 23ee977df463..d8cb9ebd0efd 100644
--- a/core/debugger/remote_debugger.cpp
+++ b/core/debugger/remote_debugger.cpp
@@ -39,6 +39,8 @@
 #include "core/object/script_language.h"
 #include "core/os/os.h"
 
+using Severity = ScriptLanguageThreadContext;
+
 class RemoteDebugger::MultiplayerProfiler : public EngineProfiler {
 	struct BandwidthFrame {
 		uint32_t timestamp;
@@ -178,7 +180,8 @@ Error RemoteDebugger::_put_msg(String p_message, Array p_data) {
 	Array msg;
 	msg.push_back(p_message);
 	msg.push_back(p_data);
-	Error err = peer->put_message(msg);
+	const int channel = Thread::get_caller_id() == Thread::get_main_id() ? Peer::CHANNEL_MAIN_THREAD : Peer::CHANNEL_OTHER;
+	const Error err = peer->put_message(channel, msg);
 	if (err != OK) {
 		n_messages_dropped++;
 	}
@@ -187,7 +190,7 @@ Error RemoteDebugger::_put_msg(String p_message, Array p_data) {
 
 void RemoteDebugger::_err_handler(void *p_this, const char *p_func, const char *p_file, int p_line, const char *p_err, const char *p_descr, bool p_editor_notify, ErrorHandlerType p_type) {
 	if (p_type == ERR_HANDLER_SCRIPT) {
-		return; //ignore script errors, those go through debugger
+		return; // ignore script errors, those go through debugger
 	}
 
 	RemoteDebugger *rd = static_cast<RemoteDebugger *>(p_this);
@@ -195,17 +198,8 @@ void RemoteDebugger::_err_handler(void *p_this, const char *p_func, const char *
 		return;
 	}
 
-	Vector<ScriptLanguage::StackInfo> si;
-
-	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
-		si = ScriptServer::get_language(i)->debug_get_current_stack_info();
-		if (si.size()) {
-			break;
-		}
-	}
-
 	// send_error will lock internally.
-	rd->script_debugger->send_error(String::utf8(p_func), String::utf8(p_file), p_line, String::utf8(p_err), String::utf8(p_descr), p_editor_notify, p_type, si);
+	rd->send_error(String::utf8(p_func), String::utf8(p_file), p_line, String::utf8(p_err), String::utf8(p_descr), p_editor_notify, p_type);
 }
 
 void RemoteDebugger::_print_handler(void *p_this, const String &p_string, bool p_error, bool p_rich) {
@@ -287,8 +281,7 @@ void RemoteDebugger::flush_output() {
 		Vector<String> joined_log_strings;
 		Vector<String> strings;
 		Vector<int> types;
-		for (int i = 0; i < output_strings.size(); i++) {
-			const OutputString &output_string = output_strings[i];
+		for (const OutputString &output_string : output_strings) {
 			if (output_string.type == MESSAGE_TYPE_ERROR) {
 				if (!joined_log_strings.is_empty()) {
 					strings.push_back(String("\n").join(joined_log_strings));
@@ -350,6 +343,11 @@ void RemoteDebugger::send_message(const String &p_message, const Array &p_args)
 }
 
 void RemoteDebugger::send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type) {
+	if (flushing && Thread::get_caller_id() == flush_thread) {
+		// Can't handle recursive errors during flush.
+		return;
+	}
+
 	ErrorMessage oe;
 	oe.error = p_err;
 	oe.error_descr = p_descr;
@@ -357,16 +355,27 @@ void RemoteDebugger::send_error(const String &p_func, const String &p_file, int
 	oe.source_line = p_line;
 	oe.source_func = p_func;
 	oe.warning = p_type == ERR_HANDLER_WARNING;
-	uint64_t time = OS::get_singleton()->get_ticks_msec();
-	oe.hr = time / 3600000;
-	oe.min = (time / 60000) % 60;
-	oe.sec = (time / 1000) % 60;
-	oe.msec = time % 1000;
-	oe.callstack.append_array(script_debugger->get_error_stack_info());
-
-	if (flushing && Thread::get_caller_id() == flush_thread) { // Can't handle recursive errors during flush.
-		return;
+	const uint64_t time = OS::get_singleton()->get_ticks_msec();
+	oe.hr = static_cast<int>(time / 3600000ULL);
+	oe.min = static_cast<int>(time / 60000ULL) % 60;
+	oe.sec = static_cast<int>(time / 1000ULL) % 60;
+	oe.msec = static_cast<int>(time % 1000ULL);
+
+	Vector<StackInfo> si;
+	// Right now this is always true, but if we were ever in a "switched off" state, we don't want to create thread contexts.
+	// In all other places, is_active() is checked before any debugging is done.
+	if (is_active()) {
+		// No mutex required since we are only accessing stable collection of languages and thread-local storage.
+		for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+			si = ScriptServer::get_language(i)->current_thread().debug_get_current_stack_info();
+			// FIXME This isn't technically correct if we have languages calling into each other,
+			// there could be multiple, so we should have a flag in the context to see if we are on the stack.
+			if (si.size()) {
+				break;
+			}
+		}
 	}
+	oe.callstack.append_array(si);
 
 	MutexLock lock(mutex);
 
@@ -381,8 +390,8 @@ void RemoteDebugger::send_error(const String &p_func, const String &p_file, int
 			if (warn_count > max_warnings_per_second) {
 				n_warnings_dropped++;
 				if (n_warnings_dropped == 1) {
-					// Only print one message about dropping per second
-					ErrorMessage overflow = _create_overflow_error("TOO_MANY_WARNINGS", "Too many warnings! Ignoring warnings for up to 1 second.");
+					// Only print one message about dropping per second.
+					const ErrorMessage overflow = _create_overflow_error("TOO_MANY_WARNINGS", "Too many warnings! Ignoring warnings for up to 1 second.");
 					errors.push_back(overflow);
 				}
 			} else {
@@ -393,7 +402,7 @@ void RemoteDebugger::send_error(const String &p_func, const String &p_file, int
 				n_errors_dropped++;
 				if (n_errors_dropped == 1) {
 					// Only print one message about dropping per second
-					ErrorMessage overflow = _create_overflow_error("TOO_MANY_ERRORS", "Too many errors! Ignoring errors for up to 1 second.");
+					const ErrorMessage overflow = _create_overflow_error("TOO_MANY_ERRORS", "Too many errors! Ignoring errors for up to 1 second.");
 					errors.push_back(overflow);
 				}
 			} else {
@@ -403,6 +412,44 @@ void RemoteDebugger::send_error(const String &p_func, const String &p_file, int
 	}
 }
 
+// May be called back under lock by the script debugger.
+void RemoteDebugger::send_stack_frame_variables(const ScriptLanguageThreadContext &p_any_thread, int p_level) {
+	List<String> members;
+	List<Variant> member_vals;
+	if (ScriptInstance *inst = p_any_thread.debug_get_stack_level_instance(p_level)) {
+		members.push_back("self");
+		member_vals.push_back(inst->get_owner());
+	}
+	p_any_thread.debug_get_stack_level_members(p_level, &members, &member_vals);
+	ERR_FAIL_COND(members.size() != member_vals.size());
+
+	List<String> locals;
+	List<Variant> local_vals;
+	p_any_thread.debug_get_stack_level_locals(p_level, &locals, &local_vals);
+	ERR_FAIL_COND(locals.size() != local_vals.size());
+
+	List<String> globals;
+	List<Variant> globals_vals;
+	p_any_thread.get_language()->debug_get_globals(&globals, &globals_vals);
+	ERR_FAIL_COND(globals.size() != globals_vals.size());
+
+	Array data;
+	data.push_back(local_vals.size() + member_vals.size() + globals_vals.size());
+	data.push_back(p_any_thread.debug_get_thread_id());
+	send_message("stack_frame_vars", data);
+	_send_stack_vars(locals, local_vals, 0);
+	_send_stack_vars(members, member_vals, 1);
+	_send_stack_vars(globals, globals_vals, 2);
+}
+
+// May be called back under lock by the script debugger.
+void RemoteDebugger::send_empty_stack_frame(const DebugThreadID &p_tid) {
+	Array data;
+	data.push_back(0);
+	data.push_back(p_tid);
+	send_message("stack_frame_vars", data);
+}
+
 void RemoteDebugger::_send_stack_vars(List<String> &p_names, List<Variant> &p_vals, int p_type) {
 	DebuggerMarshalls::ScriptStackVariable stvar;
 	List<String>::Element *E = p_names.front();
@@ -431,125 +478,154 @@ Error RemoteDebugger::_try_capture(const String &p_msg, const Array &p_data, boo
 	return capture_parse(cap, msg, p_data, r_captured);
 }
 
-void RemoteDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
-	//this function is called when there is a debugger break (bug on script)
-	//or when execution is paused from editor
+inline ScriptLanguageThreadContext::DebugThreadID _get_optional_thread_id(ScriptLanguageThreadContext &p_focused_thread, const Array &p_data, const int p_index) {
+	if (p_data.size() > p_index) {
+		return static_cast<ScriptLanguageThreadContext::DebugThreadID>(p_data[p_index]);
+	}
+	return p_focused_thread.debug_get_thread_id();
+}
+
+void RemoteDebugger::_send_debug_enter_thread(ScriptLanguageThreadContext &p_focused_thread) {
+	Array msg;
+	msg.push_back(p_focused_thread.debug_get_error_severity() < Severity::SEVERITY_FATAL);
+	msg.push_back(p_focused_thread.debug_get_error());
+	msg.push_back(p_focused_thread.debug_get_stack_level_count() > 0);
+	msg.push_back(p_focused_thread.debug_get_thread_id());
+	msg.push_back(p_focused_thread.is_main_thread());
+	msg.push_back(p_focused_thread.debug_get_error_severity());
+	send_message("debug_enter_thread", msg);
+}
+
+void RemoteDebugger::_send_debug_exit_thread(ScriptLanguageThreadContext &p_focused_thread) {
+	Array msg;
+	msg.push_back(p_focused_thread.debug_get_thread_id());
+	send_message("debug_exit_thread", msg);
+}
+
+bool RemoteDebugger::_get_next_message(ScriptLanguageThreadContext &p_focused_thread, Array &r_cmd) {
+	bool has_message = false;
+	if (p_focused_thread.is_main_thread()) {
+		// Also service captures while we sit here.  In NO_THREADS compilations this will block, but OTHER won't.
+		peer->poll(Peer::CHANNEL_MAIN_THREAD);
+		has_message = peer->has_message(Peer::CHANNEL_MAIN_THREAD);
+		if (has_message) {
+			r_cmd = peer->get_message(Peer::CHANNEL_MAIN_THREAD);
+		} else {
+			// Also service discardable messages only on Main thread.
+			peer->poll(Peer::CHANNEL_DISCARDABLE);
+			has_message = peer->has_message(Peer::CHANNEL_DISCARDABLE);
+			if (has_message) {
+				r_cmd = peer->get_message(Peer::CHANNEL_DISCARDABLE);
+			}
+		}
+	}
+	if (!has_message) {
+		peer->poll(Peer::CHANNEL_OTHER);
+		has_message = peer->has_message(Peer::CHANNEL_OTHER);
+		if (has_message) {
+			r_cmd = peer->get_message(Peer::CHANNEL_OTHER);
+		}
+	}
+	return has_message;
+}
+
+void RemoteDebugger::debug(ScriptLanguageThreadContext &p_focused_thread) {
+	// This function is called when there is a debugger break (error on script)
+	// or when execution is paused from editor.  The caller is the thread being debugged
+	// and we block them here while data is being interrogated.
 
-	if (script_debugger->is_skipping_breakpoints() && !p_is_error_breakpoint) {
+	if (script_debugger->is_skipping_breakpoints() && p_focused_thread.debug_get_error_severity() <= Severity::SEVERITY_BREAKPOINT) {
 		return;
 	}
 
 	ERR_FAIL_COND_MSG(!is_peer_connected(), "Script Debugger failed to connect, but being used anyway.");
 
-	if (!peer->can_block()) {
-		return; // Peer does not support blocking IO. We could at least send the error though.
+	if (!peer->can_block(Peer::CHANNEL_OTHER)) {
+		// Peer does not support blocking IO.
+		// REVISIT We could at least send the error though.
+		return;
 	}
 
-	ScriptLanguage *script_lang = script_debugger->get_break_language();
-	const String error_str = script_lang ? script_lang->debug_get_error() : "";
-	Array msg;
-	msg.push_back(p_can_continue);
-	msg.push_back(error_str);
-	ERR_FAIL_COND(!script_lang);
-	msg.push_back(script_lang->debug_get_stack_level_count() > 0);
-	if (allow_focus_steal_fn) {
+	if (allow_focus_steal_fn && p_focused_thread.is_main_thread()) {
 		allow_focus_steal_fn();
 	}
-	send_message("debug_enter", msg);
 
-	Input::MouseMode mouse_mode = Input::get_singleton()->get_mouse_mode();
+	_send_debug_enter_thread(p_focused_thread);
+
+	const Input::MouseMode mouse_mode = Input::get_singleton()->get_mouse_mode();
 	if (mouse_mode != Input::MOUSE_MODE_VISIBLE) {
 		Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE);
 	}
 
 	while (is_peer_connected()) {
 		flush_output();
-		peer->poll();
-
-		if (peer->has_message()) {
-			Array cmd = peer->get_message();
-
+		Array cmd;
+		if (_get_next_message(p_focused_thread, cmd)) {
 			ERR_CONTINUE(cmd.size() != 2);
 			ERR_CONTINUE(cmd[0].get_type() != Variant::STRING);
 			ERR_CONTINUE(cmd[1].get_type() != Variant::ARRAY);
 
-			String command = cmd[0];
-			Array data = cmd[1];
+			const String command = cmd[0];
+			const Array data = cmd[1];
 
+			// REVISIT implement commands to free other threads or step execute all?
+			if (command == "thread") {
+				// TODO thread safe tell script debugger to switch to that thread (if suspended or when it does suspend)
+				// then end debugging this thread
+			}
 			if (command == "step") {
-				script_debugger->set_depth(-1);
-				script_debugger->set_lines_left(1);
+				p_focused_thread.debug_step();
 				break;
-
-			} else if (command == "next") {
-				script_debugger->set_depth(0);
-				script_debugger->set_lines_left(1);
+			}
+			if (command == "next") {
+				p_focused_thread.debug_next();
 				break;
-
-			} else if (command == "continue") {
-				script_debugger->set_depth(-1);
-				script_debugger->set_lines_left(-1);
+			}
+			if (command == "continue") {
+				p_focused_thread.debug_continue();
 				break;
-
-			} else if (command == "break") {
-				ERR_PRINT("Got break when already broke!");
+			}
+			if (command == "break") {
+				ERR_PRINT("Received break request when already debugging.");
 				break;
-
-			} else if (command == "get_stack_dump") {
+			}
+			if (command == "get_stack_dump") {
 				DebuggerMarshalls::ScriptStackDump dump;
-				int slc = script_lang->debug_get_stack_level_count();
-				for (int i = 0; i < slc; i++) {
-					ScriptLanguage::StackInfo frame;
-					frame.file = script_lang->debug_get_stack_level_source(i);
-					frame.line = script_lang->debug_get_stack_level_line(i);
-					frame.func = script_lang->debug_get_stack_level_function(i);
-					dump.frames.push_back(frame);
+				const DebugThreadID tid = _get_optional_thread_id(p_focused_thread, data, 0);
+				if (p_focused_thread.is_main_thread() && p_focused_thread.debug_get_thread_id() == tid) {
+					dump.populate(p_focused_thread);
+				} else {
+					// Get data or send empty if not paused.
+					// The UI would know if thread has paused from notifications.
+					script_debugger->try_get_stack_dump(tid, dump);
 				}
-				send_message("stack_dump", dump.serialize());
-
+				Array send_data = dump.serialize();
+				send_message("stack_dump", send_data);
 			} else if (command == "get_stack_frame_vars") {
-				ERR_FAIL_COND(data.size() != 1);
-				ERR_FAIL_COND(!script_lang);
-				int lv = data[0];
-
-				List<String> members;
-				List<Variant> member_vals;
-				if (ScriptInstance *inst = script_lang->debug_get_stack_level_instance(lv)) {
-					members.push_back("self");
-					member_vals.push_back(inst->get_owner());
+				ERR_FAIL_COND(data.size() < 1);
+				const int lv = data[0];
+				const DebugThreadID tid = _get_optional_thread_id(p_focused_thread, data, 1);
+				if (p_focused_thread.is_main_thread() && p_focused_thread.debug_get_thread_id() == tid) {
+					send_stack_frame_variables(p_focused_thread, lv);
+				} else {
+					// Get data or send empty if not paused.
+					// The UI would know if thread has paused from notifications.
+					script_debugger->try_send_stack_frame_variables(tid, lv, *this);
 				}
-				script_lang->debug_get_stack_level_members(lv, &members, &member_vals);
-				ERR_FAIL_COND(members.size() != member_vals.size());
-
-				List<String> locals;
-				List<Variant> local_vals;
-				script_lang->debug_get_stack_level_locals(lv, &locals, &local_vals);
-				ERR_FAIL_COND(locals.size() != local_vals.size());
-
-				List<String> globals;
-				List<Variant> globals_vals;
-				script_lang->debug_get_globals(&globals, &globals_vals);
-				ERR_FAIL_COND(globals.size() != globals_vals.size());
-
-				Array var_size;
-				var_size.push_back(local_vals.size() + member_vals.size() + globals_vals.size());
-				send_message("stack_frame_vars", var_size);
-				_send_stack_vars(locals, local_vals, 0);
-				_send_stack_vars(members, member_vals, 1);
-				_send_stack_vars(globals, globals_vals, 2);
-
+			} else if (!p_focused_thread.is_main_thread()) {
+				// The remaining messages should have been sent on the main thread channel and can't
+				// be dispatched if we are debugging another thread.
+				WARN_PRINT(vformat("Disallowed message received on debugged thread channel: %s", command));
 			} else if (command == "reload_scripts") {
 				reload_all_scripts = true;
-
 			} else if (command == "breakpoint") {
 				ERR_FAIL_COND(data.size() < 3);
-				bool set = data[2];
+				const bool set = data[2];
 				if (set) {
 					script_debugger->insert_breakpoint(data[1], data[0]);
 				} else {
 					script_debugger->remove_breakpoint(data[1], data[0]);
 				}
-
 			} else if (command == "set_skip_breakpoints") {
 				ERR_FAIL_COND(data.size() < 1);
 				script_debugger->set_skip_breakpoints(data[0]);
@@ -566,22 +642,40 @@ void RemoteDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 		}
 	}
 
-	send_message("debug_exit", Array());
+	_send_debug_exit_thread(p_focused_thread);
 
 	if (mouse_mode != Input::MOUSE_MODE_VISIBLE) {
 		Input::get_singleton()->set_mouse_mode(mouse_mode);
 	}
 }
 
-void RemoteDebugger::poll_events(bool p_is_idle) {
-	if (peer.is_null()) {
-		return;
-	}
+void RemoteDebugger::request_debug(const ScriptLanguageThreadContext &p_any_thread) {
+	Array msg;
+	msg.push_back(p_any_thread.debug_get_thread_id());
+	msg.push_back(p_any_thread.is_main_thread());
+	msg.push_back(p_any_thread.debug_get_error());
+	msg.push_back(p_any_thread.debug_get_error_severity());
+	msg.push_back(p_any_thread.debug_get_error_severity() < Severity::SEVERITY_FATAL);
+	msg.push_back(p_any_thread.debug_get_stack_level_count() > 0);
+	send_message("thread_alert", msg);
+}
 
-	flush_output();
-	peer->poll();
-	while (peer->has_message()) {
-		Array arr = peer->get_message();
+void RemoteDebugger::thread_paused(const ScriptLanguageThreadContext &p_any_thread) {
+	Array msg;
+	msg.append(p_any_thread.debug_get_thread_id());
+	msg.append(p_any_thread.is_main_thread());
+	send_message("thread_paused", msg);
+}
+
+void RemoteDebugger::_service_channel(int p_channel) {
+	// Special handling: only fire a single servers:draw even if we just read many of them
+	// REVISIT: We should handle the entire DISCARDABLE channel this way and only fire the latest of
+	// each unique capture:msg.
+	bool servers_draw = false;
+	Variant servers_draw_args;
+	peer->poll(p_channel);
+	while (peer->has_message(p_channel)) {
+		Array arr = peer->get_message(p_channel);
 
 		ERR_CONTINUE(arr.size() != 2);
 		ERR_CONTINUE(arr[0].get_type() != Variant::STRING);
@@ -600,9 +694,30 @@ void RemoteDebugger::poll_events(bool p_is_idle) {
 			continue; // Unknown message...
 		}
 
+		if (cmd == "servers:draw") {
+			servers_draw = true;
+			// Will always be an empty array for now, but save it anyway.
+			servers_draw_args = arr[1];
+		}
 		const String msg = cmd.substr(idx + 1);
 		capture_parse(cap, msg, arr[1], parsed);
 	}
+	if (servers_draw) {
+		bool captured = false;
+		capture_parse(SNAME("servers"), "draw", servers_draw_args, captured);
+		(void)captured;
+	}
+}
+
+void RemoteDebugger::poll_events(bool p_is_idle) {
+	ERR_FAIL_COND_MSG(Thread::get_caller_id() != Thread::get_main_id(), "Dispatching of debugger captures can only run on Main thread. Please report broken implementation.");
+	if (peer.is_null()) {
+		return;
+	}
+
+	flush_output();
+	_service_channel(Peer::CHANNEL_MAIN_THREAD);
+	_service_channel(Peer::CHANNEL_DISCARDABLE);
 
 	// Reload scripts during idle poll only.
 	if (p_is_idle && reload_all_scripts) {
@@ -631,7 +746,7 @@ Error RemoteDebugger::_core_capture(const String &p_cmd, const Array &p_data, bo
 		ERR_FAIL_COND_V(p_data.size() < 1, ERR_INVALID_DATA);
 		script_debugger->set_skip_breakpoints(p_data[0]);
 	} else if (p_cmd == "break") {
-		script_debugger->debug(script_debugger->get_break_language());
+		script_debugger->debug_request_break();
 	} else {
 		r_captured = false;
 	}
@@ -653,7 +768,7 @@ Error RemoteDebugger::_profiler_capture(const String &p_cmd, const Array &p_data
 	return OK;
 }
 
-RemoteDebugger::RemoteDebugger(Ref<RemoteDebuggerPeer> p_peer) {
+RemoteDebugger::RemoteDebugger(Ref<Peer> p_peer) {
 	peer = p_peer;
 	max_chars_per_second = GLOBAL_GET("network/limits/debugger/max_chars_per_second");
 	max_errors_per_second = GLOBAL_GET("network/limits/debugger/max_errors_per_second");
diff --git a/core/debugger/remote_debugger.h b/core/debugger/remote_debugger.h
index fe4bbe86ea8e..b70f8474c712 100644
--- a/core/debugger/remote_debugger.h
+++ b/core/debugger/remote_debugger.h
@@ -48,7 +48,10 @@ class RemoteDebugger : public EngineDebugger {
 	};
 
 private:
-	typedef DebuggerMarshalls::OutputError ErrorMessage;
+	using Peer = RemoteDebuggerPeer;
+	using DebugThreadID = ScriptLanguageThreadContext::DebugThreadID;
+	using StackInfo = ScriptLanguageThreadContext::StackInfo;
+	using ErrorMessage = DebuggerMarshalls::OutputError;
 
 	class MultiplayerProfiler;
 	class PerformanceProfiler;
@@ -98,18 +101,27 @@ class RemoteDebugger : public EngineDebugger {
 	Error _profiler_capture(const String &p_cmd, const Array &p_data, bool &r_captured);
 	Error _core_capture(const String &p_cmd, const Array &p_data, bool &r_captured);
 
-	template <typename T>
-	void _bind_profiler(const String &p_name, T *p_prof);
-	Error _try_capture(const String &p_name, const Array &p_data, bool &r_captured);
+	Error _try_capture(const String &p_msg, const Array &p_data, bool &r_captured);
+
+	void _send_debug_enter_thread(ScriptLanguageThreadContext &p_focused_thread);
+	void _service_channel(int p_channel);
+	bool _get_next_message(ScriptLanguageThreadContext &p_focused_thread, Array &r_cmd);
+	void _send_debug_exit_thread(ScriptLanguageThreadContext &p_focused_thread);
 
 public:
 	// Overrides
-	void poll_events(bool p_is_idle);
-	void send_message(const String &p_message, const Array &p_args);
-	void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type);
-	void debug(bool p_can_continue = true, bool p_is_error_breakpoint = false);
-
-	explicit RemoteDebugger(Ref<RemoteDebuggerPeer> p_peer);
+	void poll_events(bool p_is_idle) override;
+	void send_message(const String &p_message, const Array &p_args) override;
+	void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type) override;
+	void debug(ScriptLanguageThreadContext &p_focused_thread) override;
+	void request_debug(const ScriptLanguageThreadContext &p_any_thread) override;
+	void thread_paused(const ScriptLanguageThreadContext &p_any_thread) override;
+
+	// Callbacks
+	void send_stack_frame_variables(const ScriptLanguageThreadContext &p_any_thread, int p_level);
+	void send_empty_stack_frame(const DebugThreadID &p_tid);
+
+	explicit RemoteDebugger(Ref<Peer> p_peer);
 	~RemoteDebugger();
 };
 
diff --git a/core/debugger/remote_debugger_peer.cpp b/core/debugger/remote_debugger_peer.cpp
index e9362b4ea4c6..6f37308ac2c8 100644
--- a/core/debugger/remote_debugger_peer.cpp
+++ b/core/debugger/remote_debugger_peer.cpp
@@ -38,44 +38,52 @@ bool RemoteDebuggerPeerTCP::is_peer_connected() {
 	return connected;
 }
 
-bool RemoteDebuggerPeerTCP::has_message() {
-	return in_queue.size() > 0;
+bool RemoteDebuggerPeerTCP::has_message(int p_channel) {
+	MutexLock<Mutex> lock(channels[p_channel].shared.mutex);
+	return channels[p_channel].shared.in_queue.size() > 0;
 }
 
-Array RemoteDebuggerPeerTCP::get_message() {
-	MutexLock lock(mutex);
-	ERR_FAIL_COND_V(!has_message(), Array());
-	Array out = in_queue[0];
-	in_queue.pop_front();
+Array RemoteDebuggerPeerTCP::get_message(int p_channel) {
+	MutexLock<Mutex> lock(channels[p_channel].shared.mutex);
+	ERR_FAIL_COND_V(!has_message(p_channel), Array());
+	Array out = channels[p_channel].shared.in_queue[0];
+	channels[p_channel].shared.in_queue.pop_front();
 	return out;
 }
 
-Error RemoteDebuggerPeerTCP::put_message(const Array &p_arr) {
-	MutexLock lock(mutex);
-	if (out_queue.size() >= max_queued_messages) {
+Error RemoteDebuggerPeerTCP::put_message(int p_channel, const Array &p_arr) {
+	MutexLock lock(channels[p_channel].shared.mutex);
+	if (channels[p_channel].shared.out_queue.size() >= max_queued_messages) {
 		return ERR_OUT_OF_MEMORY;
 	}
-
-	out_queue.push_back(p_arr);
+	channels[p_channel].shared.out_queue.push_back(p_arr);
 	return OK;
 }
 
 int RemoteDebuggerPeerTCP::get_max_message_size() const {
-	return 8 << 20; // 8 MiB
+	return MAX_MESSAGE_SIZE; // 8 MiB
 }
 
-void RemoteDebuggerPeerTCP::close() {
+void RemoteDebuggerPeerTCP::_close() {
+	// FIXME non volatile bool may never be delivered
 	running = false;
 	thread.wait_to_finish();
 	tcp_client->disconnect_from_host();
-	out_buf.clear();
-	in_buf.clear();
+	for (Channel &channel : channels) {
+		channel.out_buf.clear();
+		channel.in_buf.clear();
+	}
+}
+
+void RemoteDebuggerPeerTCP::close() {
+	_close();
 }
 
 RemoteDebuggerPeerTCP::RemoteDebuggerPeerTCP(Ref<StreamPeerTCP> p_tcp) {
-	// This means remote debugger takes 16 MiB just because it exists...
-	in_buf.resize((8 << 20) + 4); // 8 MiB should be way more than enough (need 4 extra bytes for encoding packet size).
-	out_buf.resize(8 << 20); // 8 MiB should be way more than enough
+	for (Channel &channel : channels) {
+		channel.in_buf.resize(MAX_MESSAGE_SIZE + 4); // Plus packet size | channel ID combo.
+		channel.out_buf.resize(MAX_MESSAGE_SIZE + 4); // Plus packet size | channel ID combo.
+	}
 	tcp_client = p_tcp;
 	if (tcp_client.is_valid()) { // Attaching to an already connected stream.
 		connected = true;
@@ -89,64 +97,121 @@ RemoteDebuggerPeerTCP::RemoteDebuggerPeerTCP(Ref<StreamPeerTCP> p_tcp) {
 }
 
 RemoteDebuggerPeerTCP::~RemoteDebuggerPeerTCP() {
-	close();
+	_close();
 }
 
 void RemoteDebuggerPeerTCP::_write_out() {
 	while (tcp_client->get_status() == StreamPeerTCP::STATUS_CONNECTED && tcp_client->wait(NetSocket::POLL_TYPE_OUT) == OK) {
-		uint8_t *buf = out_buf.ptrw();
-		if (out_left <= 0) {
-			if (out_queue.size() == 0) {
-				break; // Nothing left to send
+		if (current_write_channel < 0) {
+			// check in priority order
+			for (int channel_index : { CHANNEL_OTHER, CHANNEL_MAIN_THREAD, CHANNEL_DISCARDABLE }) {
+				MutexLock<Mutex> lock(channels[channel_index].shared.mutex);
+				if (channels[channel_index].shared.out_queue.size() == 0) {
+					continue;
+				}
+				current_write_channel = channel_index;
+				break;
 			}
-			mutex.lock();
-			Variant var = out_queue[0];
-			out_queue.pop_front();
-			mutex.unlock();
+		}
+		if (current_write_channel < 0) {
+			// Nothing to do.
+			return;
+		}
+
+		uint8_t *buf = channels[current_write_channel].out_buf.ptrw();
+
+		if (channels[current_write_channel].out_left <= 0) {
+			// Need to start next buffer
+			channels[current_write_channel].shared.mutex.lock();
+			Variant var = channels[current_write_channel].shared.out_queue[0];
+			channels[current_write_channel].shared.out_queue.pop_front();
+			channels[current_write_channel].shared.mutex.unlock();
 			int size = 0;
+			const int OVERHEAD = 4;
 			Error err = encode_variant(var, nullptr, size);
-			ERR_CONTINUE(err != OK || size > out_buf.size() - 4); // 4 bytes separator.
-			encode_uint32(size, buf);
-			encode_variant(var, buf + 4, size);
-			out_left = size + 4;
-			out_pos = 0;
+			if (err != OK || size > channels[current_write_channel].out_buf.size() - OVERHEAD) {
+				// Can't send, but we did service this item.
+				WARN_PRINT(vformat("Failed to send debugger message to channel %d; error %d.", current_write_channel, err));
+				current_write_channel = -1;
+				continue;
+			}
+			static_assert(NUM_CHANNELS < 256);
+			static_assert(MAX_MESSAGE_SIZE < (1 << 24));
+			encode_uint32(size | (current_write_channel << 24), buf);
+			encode_variant(var, buf + OVERHEAD, size);
+			channels[current_write_channel].out_left = size + OVERHEAD;
+			channels[current_write_channel].out_pos = 0;
 		}
+
 		int sent = 0;
-		tcp_client->put_partial_data(buf + out_pos, out_left, sent);
-		out_left -= sent;
-		out_pos += sent;
+		tcp_client->put_partial_data(buf + channels[current_write_channel].out_pos, channels[current_write_channel].out_left, sent);
+		channels[current_write_channel].out_left -= sent;
+		channels[current_write_channel].out_pos += sent;
+
+		if (channels[current_write_channel].out_left <= 0) {
+			// Done with the current transmission.
+			current_write_channel = -1;
+		}
 	}
 }
 
 void RemoteDebuggerPeerTCP::_read_in() {
 	while (tcp_client->get_status() == StreamPeerTCP::STATUS_CONNECTED && tcp_client->wait(NetSocket::POLL_TYPE_IN) == OK) {
-		uint8_t *buf = in_buf.ptrw();
-		if (in_left <= 0) {
-			if (in_queue.size() > max_queued_messages) {
-				break; // Too many messages already in queue.
-			}
-			if (tcp_client->get_available_bytes() < 4) {
-				break; // Need 4 more bytes.
+		if (current_read_channel < 0) {
+			// Could be reading any channel, so don't do it if any of them are blocked.
+			// REVISIT: this isn't completely correct.  If Main is blocked on thread.join, it will never respond to any
+			// requests and we need to give up, so we do need per-channel flow control, i.e. multiple sockets or our
+			// own flow control (e.g. enet) or just conceptually tear down the Main connection and discard all Main
+			// messages.
+			int index = 0;
+			for (Channel &channel : channels) {
+				MutexLock<Mutex> lock(channel.shared.mutex);
+				if (channel.in_left <= 0) {
+					if (channel.shared.in_queue.size() > max_queued_messages) {
+						if (index == CHANNEL_DISCARDABLE) {
+							// Drop oldest message, since it is the most stale.
+							channel.shared.in_queue.pop_front();
+						} else {
+							return; // Too many messages already in queue.
+						}
+					}
+					if (tcp_client->get_available_bytes() < 4) {
+						return; // Need 4 more bytes.
+					}
+				}
+				++index;
 			}
 			uint32_t size = 0;
 			int read = 0;
-			Error err = tcp_client->get_partial_data((uint8_t *)&size, 4, read);
-			ERR_CONTINUE(read != 4 || err != OK || size > (uint32_t)in_buf.size());
-			in_left = size;
-			in_pos = 0;
+			const Error err = tcp_client->get_partial_data(reinterpret_cast<uint8_t *>(&size), 4, read);
+			ERR_CONTINUE(read != 4 || err != OK);
+			current_read_channel = static_cast<int>(size >> 24U & 0xffU);
+			size = size & 0xffffffU;
+			if (current_read_channel < 0 || current_read_channel >= NUM_CHANNELS) {
+				WARN_PRINT(vformat("Ignored message with invalid channel ID: %d out of 0..%d", current_read_channel, NUM_CHANNELS - 1));
+				current_read_channel = -1;
+				continue;
+			}
+			ERR_CONTINUE(size > static_cast<uint32_t>(channels[current_read_channel].in_buf.size()));
+			channels[current_read_channel].in_left = size;
+			channels[current_read_channel].in_pos = 0;
 		}
+		uint8_t *buf = channels[current_read_channel].in_buf.ptrw();
 		int read = 0;
-		tcp_client->get_partial_data(buf + in_pos, in_left, read);
-		in_left -= read;
-		in_pos += read;
-		if (in_left == 0) {
+		tcp_client->get_partial_data(buf + channels[current_read_channel].in_pos, channels[current_read_channel].in_left, read);
+		channels[current_read_channel].in_left -= read;
+		channels[current_read_channel].in_pos += read;
+		if (channels[current_read_channel].in_left == 0) {
+			// Restart with size marker, even if we error out below.
+			const int was_reading_channel = current_read_channel;
+			current_read_channel = -1;
+
 			Variant var;
-			Error err = decode_variant(var, buf, in_pos, &read);
-			ERR_CONTINUE(read != in_pos || err != OK);
+			const Error err = decode_variant(var, buf, channels[was_reading_channel].in_pos, &read);
+			ERR_CONTINUE(read != channels[was_reading_channel].in_pos || err != OK);
 			ERR_CONTINUE_MSG(var.get_type() != Variant::ARRAY, "Malformed packet received, not an Array.");
-			mutex.lock();
-			in_queue.push_back(var);
-			mutex.unlock();
+			MutexLock<Mutex> lock(channels[was_reading_channel].shared.mutex);
+			channels[was_reading_channel].shared.in_queue.push_back(var);
 		}
 	}
 }
@@ -159,7 +224,7 @@ Error RemoteDebuggerPeerTCP::connect_to_host(const String &p_host, uint16_t p_po
 		ip = IP::get_singleton()->resolve_hostname(p_host);
 	}
 
-	int port = p_port;
+	const int port = p_port;
 
 	const int tries = 6;
 	const int waits[tries] = { 1, 10, 100, 1000, 1000, 1000 };
@@ -192,11 +257,14 @@ Error RemoteDebuggerPeerTCP::connect_to_host(const String &p_host, uint16_t p_po
 
 void RemoteDebuggerPeerTCP::_thread_func(void *p_ud) {
 	// Update in time for 144hz monitors
+	// FIXME that precision is nonsense, we don't have that kind of resolution from sleeping (ms on Windows, scheduling intervals, etc.)
 	const uint64_t min_tick = 6900;
 	RemoteDebuggerPeerTCP *peer = static_cast<RemoteDebuggerPeerTCP *>(p_ud);
 	while (peer->running && peer->is_peer_connected()) {
 		uint64_t ticks_usec = OS::get_singleton()->get_ticks_usec();
-		peer->_poll();
+		for (int channel_index = 0; channel_index < NUM_CHANNELS; ++channel_index) {
+			peer->_poll(channel_index);
+		}
 		if (!peer->is_peer_connected()) {
 			break;
 		}
@@ -207,17 +275,27 @@ void RemoteDebuggerPeerTCP::_thread_func(void *p_ud) {
 	}
 }
 
-void RemoteDebuggerPeerTCP::poll() {
+void RemoteDebuggerPeerTCP::poll(int p_channel) {
 #ifdef NO_THREADS
-	_poll();
+	if (p_channel == CHANNEL_MAIN_THREAD) {
+		// Block only for the first channel, because they are actually all the same socket.
+		_poll(p_channel);
+	}
+#else
+	(void)p_channel;
 #endif
 }
 
-void RemoteDebuggerPeerTCP::_poll() {
+void RemoteDebuggerPeerTCP::_poll(const int p_channel) {
 	tcp_client->poll();
 	if (connected) {
-		_write_out();
-		_read_in();
+		// In this implementation, we only have one connection on the wire, so
+		// we can't send from multiple channels fragmented.  So we have to
+		// actually process all channels together.
+		if (p_channel == CHANNEL_MAIN_THREAD) {
+			_read_in();
+			_write_out();
+		}
 		connected = tcp_client->get_status() == StreamPeerTCP::STATUS_CONNECTED;
 	}
 }
@@ -229,13 +307,13 @@ RemoteDebuggerPeer *RemoteDebuggerPeerTCP::create(const String &p_uri) {
 	uint16_t debug_port = 6007;
 
 	if (debug_host.contains(":")) {
-		int sep_pos = debug_host.rfind(":");
+		const int sep_pos = debug_host.rfind(":");
 		debug_port = debug_host.substr(sep_pos + 1).to_int();
 		debug_host = debug_host.substr(0, sep_pos);
 	}
 
 	RemoteDebuggerPeerTCP *peer = memnew(RemoteDebuggerPeerTCP);
-	Error err = peer->connect_to_host(debug_host, debug_port);
+	const Error err = peer->connect_to_host(debug_host, debug_port);
 	if (err != OK) {
 		memdelete(peer);
 		return nullptr;
diff --git a/core/debugger/remote_debugger_peer.h b/core/debugger/remote_debugger_peer.h
index 473fd8d712d4..7a6fba8373ac 100644
--- a/core/debugger/remote_debugger_peer.h
+++ b/core/debugger/remote_debugger_peer.h
@@ -34,7 +34,6 @@
 #include "core/io/stream_peer_tcp.h"
 #include "core/object/ref_counted.h"
 #include "core/os/mutex.h"
-#include "core/os/thread.h"
 #include "core/string/ustring.h"
 
 class RemoteDebuggerPeer : public RefCounted {
@@ -42,54 +41,94 @@ class RemoteDebuggerPeer : public RefCounted {
 	int max_queued_messages = 4096;
 
 public:
+	enum {
+		CHANNEL_MAIN_THREAD = 0,
+		CHANNEL_OTHER,
+		CHANNEL_DISCARDABLE,
+		NUM_CHANNELS
+	};
+
 	virtual bool is_peer_connected() = 0;
-	virtual bool has_message() = 0;
-	virtual Error put_message(const Array &p_arr) = 0;
-	virtual Array get_message() = 0;
+	virtual bool has_message(int p_channel) = 0;
+	virtual Error put_message(int p_channel, const Array &p_arr) = 0;
+	virtual Array get_message(int p_channel) = 0;
 	virtual void close() = 0;
-	virtual void poll() = 0;
+	virtual void poll(int p_channel) = 0;
 	virtual int get_max_message_size() const = 0;
-	virtual bool can_block() const { return true; } // If blocking io is allowed on main thread (debug).
+
+	// If blocking io is allowed on main thread (debug).
+	virtual bool can_block(int p_channel) const {
+		(void)p_channel;
+		return true;
+	}
 
 	RemoteDebuggerPeer();
 };
 
 class RemoteDebuggerPeerTCP : public RemoteDebuggerPeer {
-private:
 	Ref<StreamPeerTCP> tcp_client;
-	Mutex mutex;
 	Thread thread;
-	List<Array> in_queue;
-	List<Array> out_queue;
-	int out_left = 0;
-	int out_pos = 0;
-	Vector<uint8_t> out_buf;
-	int in_left = 0;
-	int in_pos = 0;
-	Vector<uint8_t> in_buf;
 	bool connected = false;
 	bool running = false;
 
+	// Each of these is a separately locked in and out queue, which are conceptually
+	// like SCTP streams that don't block each other.
+	struct Channel {
+		// Accessed only by TCP thread.
+		int out_left = 0;
+		int out_pos = 0;
+		Vector<uint8_t> out_buf;
+		int in_left = 0;
+		int in_pos = 0;
+		Vector<uint8_t> in_buf;
+
+		// Shared with clients under lock.
+		struct Shared {
+			Mutex mutex;
+			List<Array> in_queue;
+			List<Array> out_queue;
+		};
+		Shared shared;
+	};
+
+	Channel channels[NUM_CHANNELS];
+
+	// If >= 0, this channel has a partial read in progress.
+	int current_read_channel = -1;
+
+	// If >= 0, this channel has a partial write in progress.
+	int current_write_channel = -1;
+
 	static void _thread_func(void *p_ud);
 
-	void _poll();
+	void _poll(int p_channel);
 	void _write_out();
 	void _read_in();
 
+	// REVISIT This means remote debugger takes 16 MiB just because it exists (in/out buffers).
+	enum {
+		MAX_MESSAGE_SIZE = 8 << 20
+	};
+
+protected:
+	// Descendants must call this manually from _close, because the virtual
+	// close() is used in the destructor and won't actually call up.
+	void _close();
+
 public:
 	static RemoteDebuggerPeer *create(const String &p_uri);
 
 	Error connect_to_host(const String &p_host, uint16_t p_port);
 
-	void poll() override;
+	void poll(int p_channel) override;
 	bool is_peer_connected() override;
-	bool has_message() override;
-	Array get_message() override;
-	Error put_message(const Array &p_arr) override;
+	bool has_message(int p_channel) override;
+	Array get_message(int p_channel) override;
+	Error put_message(int p_channel, const Array &p_arr) override;
 	int get_max_message_size() const override;
 	void close() override;
 
-	RemoteDebuggerPeerTCP(Ref<StreamPeerTCP> p_stream = Ref<StreamPeerTCP>());
+	explicit RemoteDebuggerPeerTCP(Ref<StreamPeerTCP> p_tcp = Ref<StreamPeerTCP>());
 	~RemoteDebuggerPeerTCP();
 };
 
diff --git a/core/debugger/script_debugger.cpp b/core/debugger/script_debugger.cpp
index e30f3e7886e6..318495a6cd1c 100644
--- a/core/debugger/script_debugger.cpp
+++ b/core/debugger/script_debugger.cpp
@@ -32,22 +32,6 @@
 
 #include "core/debugger/engine_debugger.h"
 
-void ScriptDebugger::set_lines_left(int p_left) {
-	lines_left = p_left;
-}
-
-int ScriptDebugger::get_lines_left() const {
-	return lines_left;
-}
-
-void ScriptDebugger::set_depth(int p_depth) {
-	depth = p_depth;
-}
-
-int ScriptDebugger::get_depth() const {
-	return depth;
-}
-
 void ScriptDebugger::insert_breakpoint(int p_line, const StringName &p_source) {
 	if (!breakpoints.has(p_line)) {
 		breakpoints[p_line] = HashSet<StringName>();
@@ -93,24 +77,131 @@ bool ScriptDebugger::is_skipping_breakpoints() {
 	return skip_breakpoints;
 }
 
-void ScriptDebugger::debug(ScriptLanguage *p_lang, bool p_can_continue, bool p_is_error_breakpoint) {
-	ScriptLanguage *prev = break_lang;
-	break_lang = p_lang;
-	EngineDebugger::get_singleton()->debug(p_can_continue, p_is_error_breakpoint);
-	break_lang = prev;
+bool ScriptDebugger::_try_claim_debugger(const ScriptLanguageThreadContext &p_any_thread) {
+	MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+	if (_focused_thread.is_valid() && !_focused_thread->is_dead()) {
+		return false;
+	}
+	_focused_thread = Ref<ScriptLanguageThreadContext>(&p_any_thread);
+	return true;
 }
 
-void ScriptDebugger::send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type, const Vector<StackInfo> &p_stack_info) {
-	// Store stack info, this is ugly, but allows us to separate EngineDebugger and ScriptDebugger. There might be a better way.
-	error_stack_info.append_array(p_stack_info);
-	EngineDebugger::get_singleton()->send_error(p_func, p_file, p_line, p_err, p_descr, p_editor_notify, p_type);
-	error_stack_info.clear();
+void ScriptDebugger::step(ScriptLanguageThreadContext &p_any_thread) {
+	if (p_any_thread.is_main_thread()) {
+		EngineDebugger::get_singleton()->poll_events(false);
+	}
+
+	if (_break_requested.is_set()) {
+		// Warning: there is a race condition here: Multiple threads
+		// may get this far, but that can be safely ignored. Those threads
+		// will simply compete for debug(...) normally, just like multiple threads
+		// hitting breakpoints.
+		_break_requested.clear();
+		debug(p_any_thread);
+		// We may have failed to debug, continue below like a secondary thread.
+	}
+
+	if (!_hold_threads.is_set()) {
+		// Only pause if requested.  This is also where we return after successful debugging.
+		return;
+	}
+
+	// Check in this context (now conceptually owned by debugger.)
+	const DebugThreadID tid = p_any_thread.debug_get_thread_id();
+	{
+		MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+		// Check again because we could have just been resumed and we
+		// were blocked while the previous batch was cleaning out.
+		if (!_hold_threads.is_set()) {
+			return;
+		}
+		_held_threads[tid] = Ref<ScriptLanguageThreadContext>(&p_any_thread);
+	}
+
+	EngineDebugger::get_singleton()->thread_paused(p_any_thread);
+	if (p_any_thread.is_main_thread()) {
+		// Keep servicing non-core debug messages while waiting to resume.
+		while (!p_any_thread.wait_resume_ms(1)) {
+			EngineDebugger::get_singleton()->poll_events(false);
+		}
+	} else {
+		p_any_thread.wait_resume();
+	}
+
+	// Reclaim our context to resume running.
+	MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+	_held_threads.erase(tid);
 }
 
-Vector<ScriptLanguage::StackInfo> ScriptDebugger::get_error_stack_info() const {
-	return error_stack_info;
+void ScriptDebugger::debug_request_break() {
+	_break_requested.set();
 }
 
-ScriptLanguage *ScriptDebugger::get_break_language() const {
-	return break_lang;
+void ScriptDebugger::debug(ScriptLanguageThreadContext &p_any_thread) {
+	const bool is_first = _try_claim_debugger(p_any_thread);
+
+	if (!is_first) {
+		// A thread is already being debugged, just indicate that this thread has also hit a breakpoint or error.
+		EngineDebugger::get_singleton()->request_debug(p_any_thread);
+
+		// Suspend on step() like all the other extra threads.
+		return;
+	}
+
+	if (_hold_other_threads_on_debug_start) {
+		_hold_threads.set();
+	} else {
+		_hold_threads.clear();
+	}
+
+	// This thread is also available for interrogation, so check it in,
+	// now conceptually owned by debugger.
+	// Not using smart lock here because of smart lock on same mutex
+	// below (in case of very poor optimizing compiler.)
+	const DebugThreadID tid = p_any_thread.debug_get_thread_id();
+	_mutex_thread_transfer.lock();
+	_held_threads[tid] = Ref<ScriptLanguageThreadContext>(&p_any_thread);
+	_mutex_thread_transfer.unlock();
+
+	// Run the "OTHER" channel of debugging protocol on this thread, since it is the only thread that is
+	// guaranteed not to block.  If Main gets blocked, then secondary debug captures won't get replies.
+	EngineDebugger::get_singleton()->debug(p_any_thread);
+
+	{
+		MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+
+		// We don't need to be resumed.
+		_held_threads.erase(tid);
+
+		// Release the debugger, so others can claim it.
+		const bool wrong_thread_released = _focused_thread.ptr() != &p_any_thread;
+		_focused_thread.unref();
+
+		// Resume everyone.
+		_hold_threads.clear();
+		for (const KeyValue<DebugThreadID, Ref<ScriptLanguageThreadContext>> &thread : _held_threads) {
+			// Thread will remove itself.
+			thread.value->resume();
+		}
+
+		ERR_FAIL_COND_MSG(wrong_thread_released, "Debugged thread reference was corrupted during debugging; please report broken implementation.");
+	}
+}
+
+void ScriptDebugger::try_get_stack_dump(const DebugThreadID &p_tid, DebuggerMarshalls::ScriptStackDump &p_dump) {
+	MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+	const ConstHeldThreadsIterator it = _held_threads.find(p_tid);
+	if (it != _held_threads.end()) {
+		p_dump.populate(**(it->value));
+	}
+}
+
+void ScriptDebugger::try_send_stack_frame_variables(const DebugThreadID &p_tid, int p_level, RemoteDebugger &p_remote_debugger) {
+	MutexLock<BinaryMutex> lock(_mutex_thread_transfer);
+	const ConstHeldThreadsIterator it = _held_threads.find(p_tid);
+	if (it != _held_threads.end()) {
+		p_remote_debugger.send_stack_frame_variables(**(it->value), p_level);
+	} else {
+		p_remote_debugger.send_empty_stack_frame(p_tid);
+	}
 }
diff --git a/core/debugger/script_debugger.h b/core/debugger/script_debugger.h
index 5124b357a5c7..25e8a7b4a829 100644
--- a/core/debugger/script_debugger.h
+++ b/core/debugger/script_debugger.h
@@ -34,31 +34,41 @@
 #include "core/object/script_language.h"
 #include "core/string/string_name.h"
 #include "core/templates/hash_set.h"
-#include "core/templates/rb_map.h"
 #include "core/templates/vector.h"
+#include "debugger_marshalls.h"
+#include "remote_debugger.h"
 
 class ScriptDebugger {
-	typedef ScriptLanguage::StackInfo StackInfo;
+	using DebugThreadID = ScriptLanguageThreadContext::DebugThreadID;
+	using StackInfo = ScriptLanguageThreadContext::StackInfo;
 
-	int lines_left = -1;
-	int depth = -1;
 	bool skip_breakpoints = false;
 
 	HashMap<int, HashSet<StringName>> breakpoints;
 
-	ScriptLanguage *break_lang = nullptr;
-	Vector<StackInfo> error_stack_info;
+	// TODO remote configuration?
+	bool _hold_other_threads_on_debug_start = true;
 
-public:
-	void set_lines_left(int p_left);
-	int get_lines_left() const;
+	// If true, all non-focused threads hold on step execute also.
+	SafeFlag _hold_threads;
+
+	// If true, there is a pending async request for break on any thread (usually from ctrl-c or similar.)
+	SafeFlag _break_requested;
+
+	// Ownership of the thread context of a paused thread is temporarily granted to
+	// the debugger by storing it into _focused_thread or _held_threads under lock
+	// of _mutex_thread_transfer.
+	BinaryMutex _mutex_thread_transfer;
+	Ref<ScriptLanguageThreadContext> _focused_thread;
+	HashMap<DebugThreadID, Ref<ScriptLanguageThreadContext>, VariantHasher, VariantComparator> _held_threads;
+	typedef HashMap<DebugThreadID, Ref<ScriptLanguageThreadContext>, VariantHasher, VariantComparator>::ConstIterator ConstHeldThreadsIterator;
 
-	void set_depth(int p_depth);
-	int get_depth() const;
+	bool _try_claim_debugger(const ScriptLanguageThreadContext &p_any_thread);
+
+public:
+	/* BREAKPOINTS */
 
 	String breakpoint_find_source(const String &p_source) const;
-	void set_break_language(ScriptLanguage *p_lang) { break_lang = p_lang; }
-	ScriptLanguage *get_break_language() { return break_lang; }
 	void set_skip_breakpoints(bool p_skip_breakpoints);
 	bool is_skipping_breakpoints();
 	void insert_breakpoint(int p_line, const StringName &p_source);
@@ -68,12 +78,25 @@ class ScriptDebugger {
 	void clear_breakpoints();
 	const HashMap<int, HashSet<StringName>> &get_breakpoints() const { return breakpoints; }
 
-	void debug(ScriptLanguage *p_lang, bool p_can_continue = true, bool p_is_error_breakpoint = false);
-	ScriptLanguage *get_break_language() const;
+	/* DEBUGGING */
+
+	// Start new debugging session, from breakpoint or error, expected to block the caller being debugged.
+	void debug(ScriptLanguageThreadContext &p_any_thread);
+
+	// Called from all threads that are not the thread currently being debugged ("focused thread")
+	// for every opcode while debugger is active, may block the caller.
+	void step(ScriptLanguageThreadContext &p_any_thread);
+
+	// Asynchronously request break by the next script language to execute something.
+	void debug_request_break();
+
+	// TODO can LocalDebugger use this or does this need a callback as below?
+	void try_get_stack_dump(const DebugThreadID &p_tid, DebuggerMarshalls::ScriptStackDump &p_dump);
+
+	// FIXME make this not depend on RemoteDebugger
+	void try_send_stack_frame_variables(const DebugThreadID &p_tid, int p_level, RemoteDebugger &p_remote_debugger);
 
-	void send_error(const String &p_func, const String &p_file, int p_line, const String &p_err, const String &p_descr, bool p_editor_notify, ErrorHandlerType p_type, const Vector<StackInfo> &p_stack_info);
-	Vector<StackInfo> get_error_stack_info() const;
-	ScriptDebugger() {}
+	ScriptDebugger() = default;
 };
 
 #endif // SCRIPT_DEBUGGER_H
diff --git a/core/object/script_language.cpp b/core/object/script_language.cpp
index e56d2e80b902..481828d4de9b 100644
--- a/core/object/script_language.cpp
+++ b/core/object/script_language.cpp
@@ -46,16 +46,6 @@ bool ScriptServer::reload_scripts_on_save = false;
 bool ScriptServer::languages_finished = false;
 ScriptEditRequestFunction ScriptServer::edit_request_func = nullptr;
 
-void Script::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_POSTINITIALIZE: {
-			if (EngineDebugger::is_active()) {
-				EngineDebugger::get_script_debugger()->set_break_language(get_language());
-			}
-		} break;
-	}
-}
-
 Variant Script::_get_property_default_value(const StringName &p_property) {
 	Variant ret;
 	get_property_default_value(p_property, ret);
@@ -129,7 +119,7 @@ PropertyInfo Script::get_class_category() const {
 
 void Script::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("can_instantiate"), &Script::can_instantiate);
-	//ClassDB::bind_method(D_METHOD("instance_create","base_object"),&Script::instance_create);
+	// ClassDB::bind_method(D_METHOD("instance_create","base_object"),&Script::instance_create);
 	ClassDB::bind_method(D_METHOD("instance_has", "base_object"), &Script::instance_has);
 	ClassDB::bind_method(D_METHOD("has_source_code"), &Script::has_source_code);
 	ClassDB::bind_method(D_METHOD("get_source_code"), &Script::get_source_code);
@@ -183,7 +173,7 @@ void ScriptServer::unregister_language(const ScriptLanguage *p_language) {
 }
 
 void ScriptServer::init_languages() {
-	{ //load global classes
+	{ // load global classes
 		global_classes_clear();
 		if (ProjectSettings::get_singleton()->has_setting("_global_script_classes")) {
 			Array script_classes = ProjectSettings::get_singleton()->get("_global_script_classes");
@@ -199,7 +189,7 @@ void ScriptServer::init_languages() {
 	}
 
 	for (int i = 0; i < _language_count; i++) {
-		_languages[i]->init();
+		_languages[i]->init(i);
 	}
 }
 
@@ -353,14 +343,94 @@ Variant ScriptInstance::property_get_fallback(const StringName &, bool *r_valid)
 	return Variant();
 }
 
-ScriptInstance::~ScriptInstance() {
-}
+ScriptInstance::~ScriptInstance() = default;
 
 ScriptCodeCompletionCache *ScriptCodeCompletionCache::singleton = nullptr;
 ScriptCodeCompletionCache::ScriptCodeCompletionCache() {
 	singleton = this;
 }
 
+bool ScriptLanguageThreadContext::debug_record_step_taken() {
+	if (steps_left > 0) {
+		if (frames_left <= 0) {
+			--steps_left;
+		}
+		if (steps_left <= 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void ScriptLanguageThreadContext::debug_record_enter_frame() {
+	if (steps_left > 0 && frames_left >= 0) {
+		// Need to exit from this frame before steps count again.
+		++frames_left;
+	}
+}
+
+void ScriptLanguageThreadContext::debug_record_exit_frame() {
+	if (steps_left > 0 && frames_left >= 0) {
+		// Pop out until we start consuming steps again.
+		--frames_left;
+	}
+}
+
+void ScriptLanguageThreadContext::wait_resume() const {
+	resumption.wait();
+}
+
+bool ScriptLanguageThreadContext::wait_resume_ms(int p_milliseconds) const {
+	// REVISIT: Godot Semaphore does not expose std::condition_variable::wait_for,
+	// so we just fake it by sleeping.  The downside is that we will wait up to
+	// max(p_milliseconds, minimum OS timer interval) too long after the
+	// semaphore is set.
+	if (resumption.try_wait()) {
+		return true;
+	}
+	OS::get_singleton()->delay_usec(p_milliseconds * 1000);
+	return false;
+}
+
+void ScriptLanguageThreadContext::resume() const {
+	resumption.post();
+}
+
+bool ScriptLanguageThreadContext::is_dead() const {
+	// TODO implement: associated thread may have died without removing this from all collections
+	return false;
+}
+
+void ScriptLanguageThreadContext::debug_step() {
+	frames_left = -1;
+	steps_left = 1;
+}
+
+void ScriptLanguageThreadContext::debug_next() {
+	// REVISIT: how does this work?
+	frames_left = 0;
+	steps_left = 1;
+}
+
+void ScriptLanguageThreadContext::debug_step_out() {
+	// REVISIT: how does this work? why is it used for stepping out of frames and not 1,0?
+	frames_left = 0;
+	steps_left = 1;
+}
+
+void ScriptLanguageThreadContext::debug_continue() {
+	frames_left = -1;
+	steps_left = -1;
+}
+
+void ScriptLanguage::init(int p_language_index) {
+	language_index = p_language_index;
+}
+
+int ScriptLanguage::get_language_index() const {
+	return language_index;
+}
+
 void ScriptLanguage::get_core_type_words(List<String> *p_core_type_words) const {
 	p_core_type_words->push_back("String");
 	p_core_type_words->push_back("Vector2");
@@ -531,7 +601,7 @@ void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, c
 
 		Variant defval;
 		if (script->get_property_default_value(E.key, defval)) {
-			//remove because it's the same as the default value
+			// remove because it's the same as the default value
 			if (defval == E.value) {
 				to_remove.push_back(E.key);
 			}
@@ -546,7 +616,7 @@ void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, c
 	if (owner && owner->get_script_instance() == this) {
 		owner->notify_property_list_changed();
 	}
-	//change notify
+	// change notify
 
 	constants.clear();
 	script->get_constants(&constants);
diff --git a/core/object/script_language.h b/core/object/script_language.h
index 12a21150bc64..e50644b4ccaa 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -33,8 +33,9 @@
 
 #include "core/doc_data.h"
 #include "core/io/resource.h"
+#include "core/os/semaphore.h"
+#include "core/os/thread.h"
 #include "core/templates/pair.h"
-#include "core/templates/rb_map.h"
 
 class ScriptLanguage;
 template <typename T>
@@ -43,10 +44,12 @@ class TypedArray;
 typedef void (*ScriptEditRequestFunction)(const String &p_path);
 
 class ScriptServer {
+public:
 	enum {
 		MAX_LANGUAGES = 16
 	};
 
+private:
 	static ScriptLanguage *_languages[MAX_LANGUAGES];
 	static int _language_count;
 	static bool scripting_enabled;
@@ -103,7 +106,6 @@ class Script : public Resource {
 
 protected:
 	virtual bool editor_can_reload_from_file() override { return false; } // this is handled by editor better
-	void _notification(int p_what);
 	static void _bind_methods();
 
 	friend class PlaceHolderScriptInstance;
@@ -118,7 +120,7 @@ class Script : public Resource {
 public:
 	virtual bool can_instantiate() const = 0;
 
-	virtual Ref<Script> get_base_script() const = 0; //for script inheritance
+	virtual Ref<Script> get_base_script() const = 0; // for script inheritance
 
 	virtual bool inherits_script(const Ref<Script> &p_script) const = 0;
 
@@ -150,7 +152,7 @@ class Script : public Resource {
 
 	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const = 0;
 
-	virtual void update_exports() {} //editor tool
+	virtual void update_exports() {} // editor tool
 	virtual void get_script_method_list(List<MethodInfo> *p_list) const = 0;
 	virtual void get_script_property_list(List<PropertyInfo> *p_list) const = 0;
 
@@ -163,7 +165,7 @@ class Script : public Resource {
 
 	virtual const Variant get_rpc_config() const = 0;
 
-	Script() {}
+	Script() = default;
 };
 
 class ScriptInstance {
@@ -204,12 +206,12 @@ class ScriptInstance {
 		return String();
 	}
 
-	//this is used by script languages that keep a reference counter of their own
-	//you can make make Ref<> not die when it reaches zero, so deleting the reference
-	//depends entirely from the script
+	// this is used by script languages that keep a reference counter of their own
+	// you can make make Ref<> not die when it reaches zero, so deleting the reference
+	// depends entirely from the script
 
 	virtual void refcount_incremented() {}
-	virtual bool refcount_decremented() { return true; } //return true if it can die
+	virtual bool refcount_decremented() { return true; } // return true if it can die
 
 	virtual Ref<Script> get_script() const = 0;
 
@@ -232,22 +234,119 @@ class ScriptCodeCompletionCache {
 
 	ScriptCodeCompletionCache();
 
-	virtual ~ScriptCodeCompletionCache() {}
+	virtual ~ScriptCodeCompletionCache() = default;
+};
+
+// A language-specific debugging context kept in thread-local storage for each thread.  Specialized for each built-in script language
+// and for extension languages in general.  Manufactured by the owning ScriptLanguage specialization.
+// REVISIT: really this could be generalized to not just applying to script languages.  Why shouldn't the EngineDebugger understand
+// stacks not from ScriptLanguage?  This was probably just a choice to stick this into ScriptLanguage because there were no other customers.
+// REVISIT maybe does not need to be ref counted, since it can only be used by either the owner thread or the debugger while the thread is suspended?
+class ScriptLanguageThreadContext : public RefCounted {
+	GDCLASS(ScriptLanguageThreadContext, RefCounted)
+
+protected:
+	// Holds thread when suspended in the debugger.
+	Semaphore resumption;
+
+	// Number of "next / step over" steps to execute before pausing, or -1 for unrestricted run.
+	int steps_left = -1;
+
+	// Number of stack frames to pop out of before pausing, or -1 for unrestricted run.
+	int frames_left = -1;
+
+	// Hash of system Thread ID for which this context was created; used as opaque tag in debugger, to correlate
+	// contexts from different languages that refer to the same thread.
+	Thread::ID tid = Thread::get_caller_id();
+
+public:
+	struct StackInfo {
+		String file;
+		String func;
+		int line;
+	};
+
+	enum Severity {
+		SEVERITY_NONE = 0,
+
+		// This severity and lower numbered severities are skipped when breakpoint skipping is requested.
+		SEVERITY_BREAKPOINT,
+
+		// Breakpoint requested from code, rather than debugger.
+		SEVERITY_BREAKPOINT_STATEMENT,
+
+		// Warning: name collision with a macro on Windows platform if this is renamed to SEVERITY_ERROR.
+		SEVERITY_NON_FATAL_ERROR,
+
+		// Severities less than this (not inclusive) can be continued in the debugger.
+		SEVERITY_FATAL,
+
+		SEVERITY_NUM_VALUES
+	};
+
+	virtual ScriptLanguage *get_language() const = 0;
+
+	// This API is used in extensions, so this is not necessarily a real Thread::ID
+	// but rather an opaque Variant (packed byte array) that is unique across all
+	// threads and all languages This value is useful only for debugging or as an
+	// index and can't decoded to an OS thread ID.
+	typedef Variant DebugThreadID;
+
+	/* DEBUG INFO FUNCTIONS */
+
+	virtual DebugThreadID debug_get_thread_id() const = 0;
+	virtual String debug_get_error() const = 0;
+	virtual Severity debug_get_error_severity() const = 0;
+	virtual int debug_get_stack_level_count() const = 0;
+	virtual int debug_get_stack_level_line(int p_level) const = 0;
+	virtual String debug_get_stack_level_function(int p_level) const = 0;
+	virtual String debug_get_stack_level_source(int p_level) const = 0;
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const = 0;
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const = 0;
+	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) const { return nullptr; }
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1) const = 0;
+	virtual Vector<StackInfo> debug_get_current_stack_info() const { return Vector<StackInfo>(); }
+
+	/* STEP EXECUTION FUNCTIONS */
+
+	virtual void debug_step();
+	virtual void debug_next();
+	virtual void debug_step_out();
+	virtual void debug_continue();
+
+	bool debug_record_step_taken();
+	void debug_record_enter_frame();
+	void debug_record_exit_frame();
+
+	/* FUNCTIONS RELATING TO ACTUAL UNDERLYING THREAD */
+
+	virtual void wait_resume() const;
+	virtual bool wait_resume_ms(int p_milliseconds) const;
+	virtual void resume() const;
+	virtual bool is_dead() const;
+	virtual bool is_main_thread() const = 0;
 };
 
 class ScriptLanguage : public Object {
 	GDCLASS(ScriptLanguage, Object)
+
+protected:
+	int language_index;
+
 public:
 	virtual String get_name() const = 0;
 
 	/* LANGUAGE FUNCTIONS */
-	virtual void init() = 0;
+
+	virtual void init(int p_language_index);
+	virtual int get_language_index() const;
 	virtual String get_type() const = 0;
 	virtual String get_extension() const = 0;
 	virtual Error execute_file(const String &p_path) = 0;
 	virtual void finish() = 0;
 
 	/* EDITOR FUNCTIONS */
+
 	struct Warning {
 		int start_line = -1, end_line = -1;
 		int leftmost_column = -1, rightmost_column = -1;
@@ -334,7 +433,7 @@ class ScriptLanguage : public Object {
 		Vector<Pair<int, int>> matches;
 		int location = LOCATION_OTHER;
 
-		CodeCompletionOption() {}
+		CodeCompletionOption() = default;
 
 		CodeCompletionOption(const String &p_text, CodeCompletionKind p_kind, int p_location = LOCATION_OTHER) {
 			display = p_text;
@@ -377,32 +476,13 @@ class ScriptLanguage : public Object {
 
 	/* MULTITHREAD FUNCTIONS */
 
-	//some VMs need to be notified of thread creation/exiting to allocate a stack
+	// some VMs need to be notified of thread creation/exiting to allocate a stack
 	virtual void thread_enter() {}
 	virtual void thread_exit() {}
 
-	/* DEBUGGER FUNCTIONS */
-	struct StackInfo {
-		String file;
-		String func;
-		int line;
-	};
-
-	virtual String debug_get_error() const = 0;
-	virtual int debug_get_stack_level_count() const = 0;
-	virtual int debug_get_stack_level_line(int p_level) const = 0;
-	virtual String debug_get_stack_level_function(int p_level) const = 0;
-	virtual String debug_get_stack_level_source(int p_level) const = 0;
-	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) = 0;
-	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) = 0;
-	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) { return nullptr; }
-	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) = 0;
-	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1) = 0;
-
-	virtual Vector<StackInfo> debug_get_current_stack_info() { return Vector<StackInfo>(); }
-
 	virtual void reload_all_scripts() = 0;
 	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) = 0;
+
 	/* LOADER FUNCTIONS */
 
 	virtual void get_recognized_extensions(List<String> *p_extensions) const = 0;
@@ -410,6 +490,11 @@ class ScriptLanguage : public Object {
 	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const = 0;
 	virtual void get_public_annotations(List<MethodInfo> *p_annotations) const = 0;
 
+	/* DEBUG FUNCTIONS */
+
+	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const = 0;
+	virtual ScriptLanguageThreadContext &current_thread() = 0;
+
 	struct ProfilingInfo {
 		StringName signature;
 		uint64_t call_count;
@@ -423,17 +508,17 @@ class ScriptLanguage : public Object {
 	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) = 0;
 	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) = 0;
 
-	virtual void *alloc_instance_binding_data(Object *p_object) { return nullptr; } //optional, not used by all languages
-	virtual void free_instance_binding_data(void *p_data) {} //optional, not used by all languages
-	virtual void refcount_incremented_instance_binding(Object *p_object) {} //optional, not used by all languages
-	virtual bool refcount_decremented_instance_binding(Object *p_object) { return true; } //return true if it can die //optional, not used by all languages
+	virtual void *alloc_instance_binding_data(Object *p_object) { return nullptr; } // optional, not used by all languages
+	virtual void free_instance_binding_data(void *p_data) {} // optional, not used by all languages
+	virtual void refcount_incremented_instance_binding(Object *p_object) {} // optional, not used by all languages
+	virtual bool refcount_decremented_instance_binding(Object *p_object) { return true; } // return true if it can die //optional, not used by all languages
 
 	virtual void frame();
 
 	virtual bool handles_global_class_type(const String &p_type) const { return false; }
 	virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const { return String(); }
 
-	virtual ~ScriptLanguage() {}
+	virtual ~ScriptLanguage() = default;
 };
 
 extern uint8_t script_encryption_key[32];
@@ -470,7 +555,7 @@ class PlaceHolderScriptInstance : public ScriptInstance {
 
 	Object *get_owner() override { return owner; }
 
-	void update(const List<PropertyInfo> &p_properties, const HashMap<StringName, Variant> &p_values); //likely changed in editor
+	void update(const List<PropertyInfo> &p_properties, const HashMap<StringName, Variant> &p_values); // likely changed in editor
 
 	virtual bool is_placeholder() const override { return true; }
 
diff --git a/core/object/script_language_extension.cpp b/core/object/script_language_extension.cpp
index 78e9038b6606..3decd6f39bdd 100644
--- a/core/object/script_language_extension.cpp
+++ b/core/object/script_language_extension.cpp
@@ -30,6 +30,113 @@
 
 #include "script_language_extension.h"
 
+#include "core/debugger/engine_debugger.h"
+#include "core/debugger/script_debugger.h"
+#include "core/object/script_language_internals.h"
+
+class ThreadContextExtensionRef : public ThreadContextRefBase {
+	Ref<ScriptLanguageThreadContext> _context;
+
+public:
+	bool is_valid() const {
+		return _context.is_valid();
+	}
+
+	ScriptLanguageThreadContext &context() {
+		return *_context.ptr();
+	}
+
+	// To be called by main thread on language exit; because thread local storage for the
+	// main thread is not cleared until after Godot checks for memory leaks.
+	void free_context() {
+		_context.unref();
+	}
+
+	void set_context(ScriptLanguageThreadContext *p_context) {
+		if (_detect_infinite_loop()) {
+			// We cannot continue, so just leave _context uninitialized to force a crash.
+			_context.unref();
+			return;
+		}
+		_context = Ref<ScriptLanguageThreadContext>(p_context);
+		_end_detect_infinite_loop();
+	}
+};
+
+// These get initialized for each thread.  If debugging is enabled, the entry for
+// the current script language extension (by language_index from ScriptServer) will
+// hold a thread local storage context for that thread.
+thread_local ThreadContextExtensionRef t_script_extension_current_thread[ScriptServer::MAX_LANGUAGES];
+
+// Dummy context to use if the extension declined to create a context for some or all threads.
+class EmptyThreadContext : public ScriptLanguageThreadContext {
+	ScriptLanguage *language;
+	DebugThreadID debug_thread_id;
+
+public:
+	ScriptLanguage *get_language() const override {
+		return language;
+	}
+
+	DebugThreadID debug_get_thread_id() const override {
+		return debug_thread_id;
+	}
+
+	String debug_get_error() const override {
+		return "";
+	}
+
+	Severity debug_get_error_severity() const override {
+		return SEVERITY_NONE;
+	}
+
+	int debug_get_stack_level_count() const override {
+		return 0;
+	}
+
+	int debug_get_stack_level_line(int) const override {
+		return 0;
+	}
+
+	String debug_get_stack_level_function(int) const override {
+		return "";
+	}
+
+	String debug_get_stack_level_source(int) const override {
+		return "";
+	}
+
+	void debug_get_stack_level_locals(int, List<String> *, List<Variant> *, int, int) const override {
+		// No code.
+	}
+
+	void debug_get_stack_level_members(int, List<String> *, List<Variant> *, int, int) const override {
+		// No code.
+	}
+
+	String debug_parse_stack_level_expression(int, const String &, int, int) const override {
+		return "";
+	}
+
+	bool is_main_thread() const override {
+		return false;
+	}
+
+	EmptyThreadContext(ScriptLanguage *p_language, const DebugThreadID &p_debug_thread_id) :
+			language(p_language),
+			debug_thread_id(p_debug_thread_id) {
+		// No code.
+	}
+};
+
+ScriptLanguageThreadContext &ScriptLanguageExtension::current_thread() {
+	ThreadContextExtensionRef &ref = t_script_extension_current_thread[language_index];
+	if (unlikely(!ref.is_valid())) {
+		ref.set_context(create_thread_context());
+	}
+	return ref.context();
+}
+
 void ScriptExtension::_bind_methods() {
 	GDVIRTUAL_BIND(_editor_can_reload_from_file);
 	GDVIRTUAL_BIND(_placeholder_erased, "placeholder");
@@ -78,7 +185,117 @@ void ScriptExtension::_bind_methods() {
 	GDVIRTUAL_BIND(_get_rpc_config);
 }
 
+void ScriptLanguageThreadContextExtension::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_parent"), &ScriptLanguageThreadContextExtension::get_parent);
+
+	GDVIRTUAL_BIND(_debug_get_error);
+	GDVIRTUAL_BIND(_debug_get_stack_level_count);
+
+	GDVIRTUAL_BIND(_debug_get_stack_level_line, "level");
+	GDVIRTUAL_BIND(_debug_get_stack_level_function, "level");
+	GDVIRTUAL_BIND(_debug_get_stack_level_locals, "level", "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_get_stack_level_members, "level", "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_get_stack_level_instance, "level");
+	GDVIRTUAL_BIND(_debug_parse_stack_level_expression, "level", "expression", "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_get_current_stack_info);
+}
+
+// virtual
+ScriptLanguage *ScriptLanguageThreadContextExtension::get_language() const {
+	return parent;
+}
+
+void ScriptLanguageThreadContextExtension::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const {
+	Dictionary ret;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_locals, p_level, p_max_subitems, p_max_depth, ret);
+	if (ret.size() == 0) {
+		return;
+	}
+	if (p_locals != nullptr && ret.has("locals")) {
+		PackedStringArray strings = ret["locals"];
+		for (int i = 0; i < strings.size(); i++) {
+			p_locals->push_back(strings[i]);
+		}
+	}
+	if (p_values != nullptr && ret.has("values")) {
+		Array values = ret["values"];
+		for (int i = 0; i < values.size(); i++) {
+			p_values->push_back(values[i]);
+		}
+	}
+}
+
+void ScriptLanguageThreadContextExtension::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const {
+	Dictionary ret;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_members, p_level, p_max_subitems, p_max_depth, ret);
+	if (ret.size() == 0) {
+		return;
+	}
+	if (p_members != nullptr && ret.has("members")) {
+		PackedStringArray strings = ret["members"];
+		for (int i = 0; i < strings.size(); i++) {
+			p_members->push_back(strings[i]);
+		}
+	}
+	if (p_values != nullptr && ret.has("values")) {
+		Array values = ret["values"];
+		for (int i = 0; i < values.size(); i++) {
+			p_values->push_back(values[i]);
+		}
+	}
+}
+
+ScriptInstance *ScriptLanguageThreadContextExtension::debug_get_stack_level_instance(int p_level) const {
+	GDNativePtr<void> ret = nullptr;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_instance, p_level, ret);
+	return reinterpret_cast<ScriptInstance *>(ret.operator void *());
+}
+
+Vector<ScriptLanguageThreadContext::StackInfo> ScriptLanguageThreadContextExtension::debug_get_current_stack_info() const {
+	TypedArray<Dictionary> ret;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_current_stack_info, ret);
+	Vector<StackInfo> sret;
+	for (int i = 0; i < ret.size(); i++) {
+		StackInfo si;
+		Dictionary d = ret[i];
+		ERR_CONTINUE(!d.has("file"));
+		ERR_CONTINUE(!d.has("func"));
+		ERR_CONTINUE(!d.has("line"));
+		si.file = d["file"];
+		si.func = d["func"];
+		si.line = d["line"];
+		sret.push_back(si);
+	}
+	return sret;
+}
+
+ScriptLanguageThreadContext::DebugThreadID ScriptLanguageThreadContextExtension::debug_get_thread_id() const {
+	PackedByteArray ret;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_thread_id, ret);
+	return ret;
+}
+
+ScriptLanguageThreadContext::Severity ScriptLanguageThreadContextExtension::debug_get_error_severity() const {
+	int ret = 0;
+	GDVIRTUAL_REQUIRED_CALL(_debug_get_error_severity, ret);
+	ERR_FAIL_COND_V_MSG(ret < SEVERITY_NONE, SEVERITY_NONE, vformat("severity code must be at least %d", SEVERITY_NONE));
+	ERR_FAIL_COND_V_MSG(ret >= SEVERITY_NUM_VALUES, static_cast<Severity>(SEVERITY_NUM_VALUES - 1), vformat("severity code must be at most %d", SEVERITY_NUM_VALUES - 1));
+	return static_cast<Severity>(ret);
+}
+
+bool ScriptLanguageThreadContextExtension::is_main_thread() const {
+	bool ret = false;
+	GDVIRTUAL_REQUIRED_CALL(_is_main_thread, ret);
+	return ret;
+}
+
 void ScriptLanguageExtension::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("debug_break"), &ScriptLanguageExtension::debug_break);
+	ClassDB::bind_method(D_METHOD("debug_step"), &ScriptLanguageExtension::debug_step);
+	ClassDB::bind_method(D_METHOD("debug_request_break"), &ScriptLanguageExtension::debug_request_break);
+	ClassDB::bind_method(D_METHOD("create_unique_debug_thread_id"), &ScriptLanguageExtension::create_unique_debug_thread_id);
+
+	GDVIRTUAL_BIND(_create_thread_context);
 	GDVIRTUAL_BIND(_get_name);
 	GDVIRTUAL_BIND(_init);
 	GDVIRTUAL_BIND(_get_type);
@@ -116,18 +333,8 @@ void ScriptLanguageExtension::_bind_methods() {
 
 	GDVIRTUAL_BIND(_thread_enter);
 	GDVIRTUAL_BIND(_thread_exit);
-	GDVIRTUAL_BIND(_debug_get_error);
-	GDVIRTUAL_BIND(_debug_get_stack_level_count);
 
-	GDVIRTUAL_BIND(_debug_get_stack_level_line, "level");
-	GDVIRTUAL_BIND(_debug_get_stack_level_function, "level");
-	GDVIRTUAL_BIND(_debug_get_stack_level_locals, "level", "max_subitems", "max_depth");
-	GDVIRTUAL_BIND(_debug_get_stack_level_members, "level", "max_subitems", "max_depth");
-	GDVIRTUAL_BIND(_debug_get_stack_level_instance, "level");
 	GDVIRTUAL_BIND(_debug_get_globals, "max_subitems", "max_depth");
-	GDVIRTUAL_BIND(_debug_parse_stack_level_expression, "level", "expression", "max_subitems", "max_depth");
-
-	GDVIRTUAL_BIND(_debug_get_current_stack_info);
 
 	GDVIRTUAL_BIND(_reload_all_scripts);
 	GDVIRTUAL_BIND(_reload_tool_script, "script", "soft_reload");
@@ -182,3 +389,51 @@ void ScriptLanguageExtension::_bind_methods() {
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_PLAIN_TEXT);
 	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MAX);
 }
+
+// virtual
+void ScriptLanguageExtension::init(int p_language_index) {
+	ScriptLanguage::init(p_language_index);
+	GDVIRTUAL_REQUIRED_CALL(_init);
+}
+
+// virtual
+void ScriptLanguageExtension::finish() {
+	GDVIRTUAL_REQUIRED_CALL(_finish);
+
+	// Free main thread context so that it does not trigger ObjectDB leak detection.
+	t_script_extension_current_thread[language_index].free_context();
+}
+
+PackedByteArray ScriptLanguageExtension::create_unique_debug_thread_id() const {
+	return ScriptLanguageInternals::create_thread_id(*this, Thread::get_caller_id());
+}
+
+void ScriptLanguageExtension::debug_break() {
+	if (EngineDebugger::is_active()) {
+		EngineDebugger::get_script_debugger()->debug(current_thread());
+	}
+}
+
+void ScriptLanguageExtension::debug_step() {
+	if (EngineDebugger::is_active()) {
+		EngineDebugger::get_script_debugger()->step(current_thread());
+	}
+}
+
+void ScriptLanguageExtension::debug_request_break() {
+	if (EngineDebugger::is_active()) {
+		EngineDebugger::get_script_debugger()->debug_request_break();
+	}
+}
+
+ScriptLanguageThreadContext *ScriptLanguageExtension::create_thread_context() {
+	if (GDVIRTUAL_IS_OVERRIDDEN(_create_thread_context)) {
+		ScriptLanguageThreadContextExtension *ret = nullptr;
+		GDVIRTUAL_CALL(_create_thread_context, ret);
+		if (ret != nullptr) {
+			ret->parent = this;
+			return ret;
+		}
+	}
+	return memnew(EmptyThreadContext(this, create_unique_debug_thread_id()));
+}
diff --git a/core/object/script_language_extension.h b/core/object/script_language_extension.h
index 7e74f6a2be8c..f707a3a77122 100644
--- a/core/object/script_language_extension.h
+++ b/core/object/script_language_extension.h
@@ -83,7 +83,7 @@ class ScriptExtension : public Script {
 
 		Vector<DocData::ClassDoc> class_doc;
 #ifndef _MSC_VER
-#warning missing conversion from documentation to ClassDoc
+#warning unimplemented conversion from documentation to ClassDoc
 #endif
 		return class_doc;
 	}
@@ -119,6 +119,7 @@ class ScriptExtension : public Script {
 
 	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const override {
 		bool has_dv = false;
+
 		if (!GDVIRTUAL_REQUIRED_CALL(_has_property_default_value, p_property, has_dv) || !has_dv) {
 			return false;
 		}
@@ -188,6 +189,60 @@ typedef ScriptLanguage::ProfilingInfo ScriptLanguageExtensionProfilingInfo;
 
 GDVIRTUAL_NATIVE_PTR(ScriptLanguageExtensionProfilingInfo)
 
+class ScriptLanguageExtension;
+
+class ScriptLanguageThreadContextExtension : public ScriptLanguageThreadContext {
+	GDCLASS(ScriptLanguageThreadContextExtension, ScriptLanguageThreadContext)
+	friend class ScriptLanguageExtension;
+
+protected:
+	static void _bind_methods();
+	ScriptLanguageExtension *parent = nullptr;
+
+public:
+	ScriptLanguage *get_language() const override;
+
+	ScriptLanguageExtension *get_parent() const {
+		// valid as least the lifetime of this object
+		return parent;
+	}
+
+	EXBIND0RC(String, debug_get_error)
+	EXBIND0RC(int, debug_get_stack_level_count)
+	EXBIND1RC(int, debug_get_stack_level_line, int)
+	EXBIND1RC(String, debug_get_stack_level_function, int)
+	EXBIND1RC(String, debug_get_stack_level_source, int)
+	EXBIND4RC(String, debug_parse_stack_level_expression, int, const String &, int, int)
+
+	GDVIRTUAL3RC(Dictionary, _debug_get_stack_level_locals, int, int, int)
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override;
+
+	GDVIRTUAL3RC(Dictionary, _debug_get_stack_level_members, int, int, int)
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override;
+
+	GDVIRTUAL1RC(GDNativePtr<void>, _debug_get_stack_level_instance, int)
+	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) const override;
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _debug_get_current_stack_info)
+	virtual Vector<StackInfo> debug_get_current_stack_info() const override;
+
+	GDVIRTUAL0RC(PackedByteArray, _debug_get_thread_id)
+	DebugThreadID debug_get_thread_id() const override;
+
+	GDVIRTUAL0RC(int, _debug_get_error_severity)
+	Severity debug_get_error_severity() const override;
+
+	GDVIRTUAL0RC(bool, _is_main_thread)
+	bool is_main_thread() const override;
+
+	ScriptLanguageThreadContextExtension() = default;
+	~ScriptLanguageThreadContextExtension() = default;
+
+	ScriptLanguageThreadContextExtension(const ScriptLanguageThreadContextExtension &) = delete;
+	ScriptLanguageThreadContextExtension(const ScriptLanguageThreadContextExtension &&) = delete;
+	ScriptLanguageThreadContextExtension &operator=(const ScriptLanguageThreadContextExtension &&) = delete;
+};
+
 class ScriptLanguageExtension : public ScriptLanguage {
 	GDCLASS(ScriptLanguageExtension, ScriptLanguage)
 protected:
@@ -196,11 +251,14 @@ class ScriptLanguageExtension : public ScriptLanguage {
 public:
 	EXBIND0RC(String, get_name)
 
-	EXBIND0(init)
+	GDVIRTUAL0(_init)
+	void init(int p_language_index) override;
 	EXBIND0RC(String, get_type)
 	EXBIND0RC(String, get_extension)
 	EXBIND1R(Error, execute_file, const String &)
-	EXBIND0(finish)
+	GDVIRTUAL0(_finish)
+
+	virtual void finish() override;
 
 	/* EDITOR FUNCTIONS */
 
@@ -431,65 +489,14 @@ class ScriptLanguageExtension : public ScriptLanguage {
 
 	/* MULTITHREAD FUNCTIONS */
 
-	//some VMs need to be notified of thread creation/exiting to allocate a stack
+	// some VMs need to be notified of thread creation/exiting to allocate a stack
 	EXBIND0(thread_enter)
 	EXBIND0(thread_exit)
 
-	EXBIND0RC(String, debug_get_error)
-	EXBIND0RC(int, debug_get_stack_level_count)
-	EXBIND1RC(int, debug_get_stack_level_line, int)
-	EXBIND1RC(String, debug_get_stack_level_function, int)
-	EXBIND1RC(String, debug_get_stack_level_source, int)
-
-	GDVIRTUAL3R(Dictionary, _debug_get_stack_level_locals, int, int, int)
-	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override {
-		Dictionary ret;
-		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_locals, p_level, p_max_subitems, p_max_depth, ret);
-		if (ret.size() == 0) {
-			return;
-		}
-		if (p_locals != nullptr && ret.has("locals")) {
-			PackedStringArray strings = ret["locals"];
-			for (int i = 0; i < strings.size(); i++) {
-				p_locals->push_back(strings[i]);
-			}
-		}
-		if (p_values != nullptr && ret.has("values")) {
-			Array values = ret["values"];
-			for (int i = 0; i < values.size(); i++) {
-				p_values->push_back(values[i]);
-			}
-		}
-	}
-	GDVIRTUAL3R(Dictionary, _debug_get_stack_level_members, int, int, int)
-	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override {
-		Dictionary ret;
-		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_members, p_level, p_max_subitems, p_max_depth, ret);
-		if (ret.size() == 0) {
-			return;
-		}
-		if (p_members != nullptr && ret.has("members")) {
-			PackedStringArray strings = ret["members"];
-			for (int i = 0; i < strings.size(); i++) {
-				p_members->push_back(strings[i]);
-			}
-		}
-		if (p_values != nullptr && ret.has("values")) {
-			Array values = ret["values"];
-			for (int i = 0; i < values.size(); i++) {
-				p_values->push_back(values[i]);
-			}
-		}
-	}
-	GDVIRTUAL1R(GDNativePtr<void>, _debug_get_stack_level_instance, int)
+	/* DEBUG FUNCTIONS */
 
-	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) override {
-		GDNativePtr<void> ret = nullptr;
-		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_instance, p_level, ret);
-		return reinterpret_cast<ScriptInstance *>(ret.operator void *());
-	}
-	GDVIRTUAL2R(Dictionary, _debug_get_globals, int, int)
-	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override {
+	GDVIRTUAL2RC(Dictionary, _debug_get_globals, int, int)
+	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override {
 		Dictionary ret;
 		GDVIRTUAL_REQUIRED_CALL(_debug_get_globals, p_max_subitems, p_max_depth, ret);
 		if (ret.size() == 0) {
@@ -509,29 +516,31 @@ class ScriptLanguageExtension : public ScriptLanguage {
 		}
 	}
 
-	EXBIND4R(String, debug_parse_stack_level_expression, int, const String &, int, int)
+	// Create a Debug Thread ID for the current thread.  This ID is unique across all thread/language combinations.
+	PackedByteArray create_unique_debug_thread_id() const;
 
-	GDVIRTUAL0R(TypedArray<Dictionary>, _debug_get_current_stack_info)
-	virtual Vector<StackInfo> debug_get_current_stack_info() override {
-		TypedArray<Dictionary> ret;
-		GDVIRTUAL_REQUIRED_CALL(_debug_get_current_stack_info, ret);
-		Vector<StackInfo> sret;
-		for (int i = 0; i < ret.size(); i++) {
-			StackInfo si;
-			Dictionary d = ret[i];
-			ERR_CONTINUE(!d.has("file"));
-			ERR_CONTINUE(!d.has("func"));
-			ERR_CONTINUE(!d.has("line"));
-			si.file = d["file"];
-			si.func = d["func"];
-			si.line = d["line"];
-			sret.push_back(si);
-		}
-		return sret;
-	}
+	// Start new debugging session for the caller thread, from breakpoint or error, expected to
+	// block the caller while it is being debugged.
+	void debug_break();
+
+	// Called from all threads that are not the thread currently being debugged ("focused thread")
+	// for every opcode while debugger is active, may block the caller.
+	void debug_step();
+
+	// Asynchronously request break by the next script language to execute something.
+	void debug_request_break();
+
+	GDVIRTUAL0RC(ScriptLanguageThreadContextExtension *, _create_thread_context)
+
+	ScriptLanguageThreadContext *create_thread_context();
+
+	ScriptLanguageThreadContext &current_thread() override;
+
+	/* SCRIPTS */
 
 	EXBIND0(reload_all_scripts)
 	EXBIND2(reload_tool_script, const Ref<Script> &, bool)
+
 	/* LOADER FUNCTIONS */
 
 	GDVIRTUAL0RC(PackedStringArray, _get_recognized_extensions)
@@ -574,6 +583,8 @@ class ScriptLanguageExtension : public ScriptLanguage {
 		}
 	}
 
+	/* PROFILING FUNCTIONS */
+
 	EXBIND0(profiling_start)
 	EXBIND0(profiling_stop)
 
@@ -593,6 +604,8 @@ class ScriptLanguageExtension : public ScriptLanguage {
 		return ret;
 	}
 
+	/* OTHER FUNCTIONS */
+
 	GDVIRTUAL1R(GDNativePtr<void>, _alloc_instance_binding_data, Object *)
 
 	virtual void *alloc_instance_binding_data(Object *p_object) override {
diff --git a/core/object/script_language_internals.h b/core/object/script_language_internals.h
new file mode 100644
index 000000000000..00d3294b5e33
--- /dev/null
+++ b/core/object/script_language_internals.h
@@ -0,0 +1,111 @@
+/*************************************************************************/
+/*  script_language_internals.h                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef SCRIPT_LANGUAGE_INTERNALS_H
+#define SCRIPT_LANGUAGE_INTERNALS_H
+
+#include "core/object/script_language.h"
+
+class ScriptLanguageInternals {
+public:
+	static ScriptLanguageThreadContext::DebugThreadID create_thread_id(const ScriptLanguage &p_language, uint64_t p_thread_id) {
+		PackedByteArray thread_id;
+		const uint8_t *raw = reinterpret_cast<const uint8_t *>(&p_thread_id);
+		thread_id.resize(sizeof(Thread::ID) + 1);
+		memcpy(thread_id.ptrw(), raw, sizeof(Thread::ID));
+		static_assert(ScriptServer::MAX_LANGUAGES <= 256);
+		thread_id.set(sizeof(Thread::ID), static_cast<uint8_t>(p_language.get_language_index()));
+		// return Variant(thread_id);
+		Variant value;
+		value = thread_id;
+		return value;
+	}
+};
+
+// Initialization behavior shared by language-specific contexts and extension contexts
+class ThreadContextRefBase {
+	bool _guard_context_creation = false;
+
+protected:
+	bool _detect_infinite_loop() {
+		if (_guard_context_creation) {
+			// Infinite loop during context creation, happens when creation errors
+			// are printed while debugging, which calls this function again.  Must
+			// exit without printing.
+			GENERATE_TRAP();
+			return true;
+		}
+		_guard_context_creation = true;
+		return false;
+	}
+
+	void _end_detect_infinite_loop() {
+		_guard_context_creation = false;
+	}
+
+public:
+	// called from thread local storage initializer
+	ThreadContextRefBase() = default;
+	~ThreadContextRefBase() = default;
+
+	ThreadContextRefBase(const ThreadContextRefBase &) = delete;
+	ThreadContextRefBase(const ThreadContextRefBase &&) = delete;
+	ThreadContextRefBase &operator=(const ThreadContextRefBase &) = delete;
+	ThreadContextRefBase &operator=(const ThreadContextRefBase &&) = delete;
+};
+
+template <class FACTORY, class CONTEXT>
+class ThreadContextRef : public ThreadContextRefBase {
+	Ref<CONTEXT> _context;
+
+public:
+	CONTEXT &context() {
+		if (_detect_infinite_loop()) {
+			// Intentionally crash below, as we cannot continue.
+			_context.unref();
+		} else {
+			if (!_context.is_valid()) {
+				_context = Ref<CONTEXT>(FACTORY::create_thread_context());
+			}
+		}
+
+		_end_detect_infinite_loop();
+
+		return *_context.ptr();
+	}
+
+	// To be called by main thread on language exit; because thread local storage for the
+	// main thread is not cleared until after Godot checks for memory leaks.
+	void free_context() {
+		_context.unref();
+	}
+};
+
+#endif // SCRIPT_LANGUAGE_INTERNALS_H
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index 7f734201e742..10ef78aa97dc 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -115,7 +115,7 @@ static ResourceUID *resource_uid = nullptr;
 static bool _is_core_extensions_registered = false;
 
 void register_core_types() {
-	//consistency check
+	// consistency check
 	static_assert(sizeof(Callable) <= 16);
 
 	ObjectDB::setup();
@@ -147,9 +147,11 @@ void register_core_types() {
 
 	GDREGISTER_ABSTRACT_CLASS(Script);
 	GDREGISTER_ABSTRACT_CLASS(ScriptLanguage);
+	GDREGISTER_ABSTRACT_CLASS(ScriptLanguageThreadContext);
 
 	GDREGISTER_VIRTUAL_CLASS(ScriptExtension);
 	GDREGISTER_VIRTUAL_CLASS(ScriptLanguageExtension);
+	GDREGISTER_VIRTUAL_CLASS(ScriptLanguageThreadContextExtension);
 
 	GDREGISTER_CLASS(RefCounted);
 	GDREGISTER_CLASS(WeakRef);
diff --git a/doc/classes/ScriptLanguageExtension.xml b/doc/classes/ScriptLanguageExtension.xml
index 2d41f8e8806f..611fdb9fbc09 100644
--- a/doc/classes/ScriptLanguageExtension.xml
+++ b/doc/classes/ScriptLanguageExtension.xml
@@ -53,71 +53,18 @@
 			<description>
 			</description>
 		</method>
-		<method name="_debug_get_current_stack_info" qualifiers="virtual">
-			<return type="Dictionary[]" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_error" qualifiers="virtual const">
-			<return type="String" />
+		<method name="_create_thread_context" qualifiers="virtual const">
+			<return type="ScriptLanguageThreadContextExtension" />
 			<description>
 			</description>
 		</method>
-		<method name="_debug_get_globals" qualifiers="virtual">
+		<method name="_debug_get_globals" qualifiers="virtual const">
 			<return type="Dictionary" />
 			<param index="0" name="max_subitems" type="int" />
 			<param index="1" name="max_depth" type="int" />
 			<description>
 			</description>
 		</method>
-		<method name="_debug_get_stack_level_count" qualifiers="virtual const">
-			<return type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_stack_level_function" qualifiers="virtual const">
-			<return type="String" />
-			<param index="0" name="level" type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_stack_level_instance" qualifiers="virtual">
-			<return type="void*" />
-			<param index="0" name="level" type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_stack_level_line" qualifiers="virtual const">
-			<return type="int" />
-			<param index="0" name="level" type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_stack_level_locals" qualifiers="virtual">
-			<return type="Dictionary" />
-			<param index="0" name="level" type="int" />
-			<param index="1" name="max_subitems" type="int" />
-			<param index="2" name="max_depth" type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_get_stack_level_members" qualifiers="virtual">
-			<return type="Dictionary" />
-			<param index="0" name="level" type="int" />
-			<param index="1" name="max_subitems" type="int" />
-			<param index="2" name="max_depth" type="int" />
-			<description>
-			</description>
-		</method>
-		<method name="_debug_parse_stack_level_expression" qualifiers="virtual">
-			<return type="String" />
-			<param index="0" name="level" type="int" />
-			<param index="1" name="expression" type="String" />
-			<param index="2" name="max_subitems" type="int" />
-			<param index="3" name="max_depth" type="int" />
-			<description>
-			</description>
-		</method>
 		<method name="_execute_file" qualifiers="virtual">
 			<return type="int" enum="Error" />
 			<param index="0" name="path" type="String" />
@@ -365,6 +312,26 @@
 			<description>
 			</description>
 		</method>
+		<method name="create_unique_debug_thread_id" qualifiers="const">
+			<return type="PackedByteArray" />
+			<description>
+			</description>
+		</method>
+		<method name="debug_break">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="debug_request_break">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="debug_step">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
 	</methods>
 	<constants>
 		<constant name="LOOKUP_RESULT_SCRIPT_LOCATION" value="0" enum="LookupResultType">
diff --git a/doc/classes/ScriptLanguageThreadContext.xml b/doc/classes/ScriptLanguageThreadContext.xml
new file mode 100644
index 000000000000..41524df97575
--- /dev/null
+++ b/doc/classes/ScriptLanguageThreadContext.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="ScriptLanguageThreadContext" inherits="RefCounted" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+	</brief_description>
+	<description>
+	</description>
+	<tutorials>
+	</tutorials>
+</class>
diff --git a/doc/classes/ScriptLanguageThreadContextExtension.xml b/doc/classes/ScriptLanguageThreadContextExtension.xml
new file mode 100644
index 000000000000..69249d47a912
--- /dev/null
+++ b/doc/classes/ScriptLanguageThreadContextExtension.xml
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="ScriptLanguageThreadContextExtension" inherits="ScriptLanguageThreadContext" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+	</brief_description>
+	<description>
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="_debug_get_current_stack_info" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_error" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_count" qualifiers="virtual const">
+			<return type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_function" qualifiers="virtual const">
+			<return type="String" />
+			<param index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_instance" qualifiers="virtual const">
+			<return type="void*" />
+			<param index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_line" qualifiers="virtual const">
+			<return type="int" />
+			<param index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_locals" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<param index="0" name="level" type="int" />
+			<param index="1" name="max_subitems" type="int" />
+			<param index="2" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_members" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<param index="0" name="level" type="int" />
+			<param index="1" name="max_subitems" type="int" />
+			<param index="2" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_parse_stack_level_expression" qualifiers="virtual const">
+			<return type="String" />
+			<param index="0" name="level" type="int" />
+			<param index="1" name="expression" type="String" />
+			<param index="2" name="max_subitems" type="int" />
+			<param index="3" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="get_parent" qualifiers="const">
+			<return type="ScriptLanguageExtension" />
+			<description>
+			</description>
+		</method>
+	</methods>
+</class>
diff --git a/drivers/unix/os_unix.cpp b/drivers/unix/os_unix.cpp
index 384f46c8df27..d2e1c7519c1e 100644
--- a/drivers/unix/os_unix.cpp
+++ b/drivers/unix/os_unix.cpp
@@ -113,8 +113,7 @@ static void handle_interrupt(int sig) {
 		return;
 	}
 
-	EngineDebugger::get_script_debugger()->set_depth(-1);
-	EngineDebugger::get_script_debugger()->set_lines_left(1);
+	EngineDebugger::get_script_debugger()->debug_request_break();
 }
 
 void OS_Unix::initialize_debugging() {
diff --git a/editor/debugger/SCsub b/editor/debugger/SCsub
index 99f1c888f087..0868a63f3057 100644
--- a/editor/debugger/SCsub
+++ b/editor/debugger/SCsub
@@ -5,3 +5,4 @@ Import("env")
 env.add_source_files(env.editor_sources, "*.cpp")
 
 SConscript("debug_adapter/SCsub")
+SConscript("stack_dump/SCsub")
diff --git a/editor/debugger/debug_adapter/debug_adapter_parser.cpp b/editor/debugger/debug_adapter/debug_adapter_parser.cpp
index ac41306cde63..d8b9372be034 100644
--- a/editor/debugger/debug_adapter/debug_adapter_parser.cpp
+++ b/editor/debugger/debug_adapter/debug_adapter_parser.cpp
@@ -406,7 +406,8 @@ Dictionary DebugAdapterParser::req_scopes(const Dictionary &p_params) const {
 		}
 	}
 
-	EditorDebuggerNode::get_singleton()->get_default_debugger()->request_stack_dump(frame_id);
+	// FIXME need thread ID to call the thread-aware version. Implement threaded DAP.
+	EditorDebuggerNode::get_singleton()->get_default_debugger()->request_stack_frame_variables(frame_id);
 	DebugAdapterProtocol::get_singleton()->_current_frame = frame_id;
 
 	body["scopes"] = scope_list;
@@ -473,7 +474,7 @@ Dictionary DebugAdapterParser::req_godot_put_msg(const Dictionary &p_params) con
 	String msg = args["message"];
 	Array data = args["data"];
 
-	EditorDebuggerNode::get_singleton()->get_default_debugger()->_put_msg(msg, data);
+	EditorDebuggerNode::get_singleton()->get_default_debugger()->send_message_auto(msg, data);
 
 	return prepare_success_response(p_params);
 }
diff --git a/editor/debugger/debug_adapter/debug_adapter_protocol.cpp b/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
index 4c445eb766cf..f795d85152bd 100644
--- a/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
+++ b/editor/debugger/debug_adapter/debug_adapter_protocol.cpp
@@ -950,16 +950,34 @@ void DebugAdapterProtocol::on_debug_stack_frame_var(const Array &p_data) {
 	variable.type = Variant::get_type_name(stack_var.value.get_type());
 	variable.variablesReference = parse_variant(stack_var.value);
 
-	variable_list.find(variable_id)->value.push_back(variable.to_json());
+	HashMap<int, Array>::Iterator it = variable_list.find(variable_id);
+	ERR_FAIL_COND(it == variable_list.end());
+	it->value.push_back(variable.to_json());
 	_remaining_vars--;
 }
 
+static const HashSet<String> s_handled_messages = [] {
+	HashSet<String> temp;
+	for (const String &value : {
+				 "debug_enter",
+				 "debug_exit",
+				 "debug_enter_thread",
+				 "debug_exit_thread",
+				 "stack_dump",
+				 "stack_frame_vars",
+				 "stack_frame_var",
+				 "output",
+				 "request_quit" }) {
+		temp.insert(value);
+	}
+	return temp;
+}();
+
 void DebugAdapterProtocol::on_debug_data(const String &p_msg, const Array &p_data) {
 	// Ignore data that is already handled by DAP
-	if (p_msg == "debug_enter" || p_msg == "debug_exit" || p_msg == "stack_dump" || p_msg == "stack_frame_vars" || p_msg == "stack_frame_var" || p_msg == "output" || p_msg == "request_quit") {
+	if (s_handled_messages.has(p_msg)) {
 		return;
 	}
-
 	notify_custom_data(p_msg, p_data);
 }
 
diff --git a/editor/debugger/editor_debugger_node.cpp b/editor/debugger/editor_debugger_node.cpp
index 9fd7fa578fd1..30ddee7840ae 100644
--- a/editor/debugger/editor_debugger_node.cpp
+++ b/editor/debugger/editor_debugger_node.cpp
@@ -160,7 +160,9 @@ void EditorDebuggerNode::_text_editor_stack_goto(const ScriptEditorDebugger *p_d
 	const int line = p_debugger->get_stack_script_line() - 1;
 	emit_signal(SNAME("goto_script_line"), stack_script, line);
 	emit_signal(SNAME("set_execution"), stack_script, line);
-	stack_script.unref(); // Why?!?
+
+	// Release our reference so the resource can unload/reload.
+	stack_script.unref();
 }
 
 void EditorDebuggerNode::_bind_methods() {
@@ -175,7 +177,7 @@ void EditorDebuggerNode::_bind_methods() {
 
 	ADD_SIGNAL(MethodInfo("goto_script_line"));
 	ADD_SIGNAL(MethodInfo("set_execution", PropertyInfo("script"), PropertyInfo(Variant::INT, "line")));
-	ADD_SIGNAL(MethodInfo("clear_execution", PropertyInfo("script")));
+	ADD_SIGNAL(MethodInfo("clear_execution", PropertyInfo(Variant::OBJECT, "script", PROPERTY_HINT_RESOURCE_TYPE, "Script")));
 	ADD_SIGNAL(MethodInfo("breaked", PropertyInfo(Variant::BOOL, "reallydid"), PropertyInfo(Variant::BOOL, "can_debug")));
 	ADD_SIGNAL(MethodInfo("breakpoint_toggled", PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::BOOL, "enabled")));
 }
diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
index 5baa9970af39..7e52c5da21af 100644
--- a/editor/debugger/script_editor_debugger.cpp
+++ b/editor/debugger/script_editor_debugger.cpp
@@ -41,6 +41,7 @@
 #include "editor/debugger/editor_performance_profiler.h"
 #include "editor/debugger/editor_profiler.h"
 #include "editor/debugger/editor_visual_profiler.h"
+#include "editor/debugger/stack_dump/stack_dump.h"
 #include "editor/editor_file_dialog.h"
 #include "editor/editor_log.h"
 #include "editor/editor_node.h"
@@ -68,13 +69,14 @@
 #include "servers/display_server.h"
 
 using CameraOverride = EditorDebuggerNode::CameraOverride;
+using Channels = RemoteDebuggerPeer;
 
-void ScriptEditorDebugger::_put_msg(String p_message, Array p_data) {
+void ScriptEditorDebugger::_put_msg(int p_channel, String p_message, Array p_data) {
 	if (is_session_active()) {
 		Array msg;
 		msg.push_back(p_message);
 		msg.push_back(p_data);
-		peer->put_message(msg);
+		peer->put_message(p_channel, msg);
 	}
 }
 
@@ -96,27 +98,27 @@ void ScriptEditorDebugger::debug_skip_breakpoints() {
 
 	Array msg;
 	msg.push_back(skip_breakpoints_value);
-	_put_msg("set_skip_breakpoints", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "set_skip_breakpoints", msg);
 }
 
 void ScriptEditorDebugger::debug_next() {
 	ERR_FAIL_COND(!breaked);
 
-	_put_msg("next", Array());
+	_put_msg(Channels::CHANNEL_OTHER, "next", Array());
 	_clear_execution();
 }
 
 void ScriptEditorDebugger::debug_step() {
 	ERR_FAIL_COND(!breaked);
 
-	_put_msg("step", Array());
+	_put_msg(Channels::CHANNEL_OTHER, "step", Array());
 	_clear_execution();
 }
 
 void ScriptEditorDebugger::debug_break() {
 	ERR_FAIL_COND(breaked);
 
-	_put_msg("break", Array());
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "break", Array());
 }
 
 void ScriptEditorDebugger::debug_continue() {
@@ -128,8 +130,8 @@ void ScriptEditorDebugger::debug_continue() {
 	}
 
 	_clear_execution();
-	_put_msg("continue", Array());
-	_put_msg("servers:foreground", Array());
+	_put_msg(Channels::CHANNEL_OTHER, "continue", Array());
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "servers:foreground", Array());
 }
 
 void ScriptEditorDebugger::update_tabs() {
@@ -156,7 +158,7 @@ void ScriptEditorDebugger::save_node(ObjectID p_id, const String &p_file) {
 	Array msg;
 	msg.push_back(p_id);
 	msg.push_back(p_file);
-	_put_msg("scene:save_node", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:save_node", msg);
 }
 
 void ScriptEditorDebugger::_file_selected(const String &p_file) {
@@ -239,8 +241,44 @@ void ScriptEditorDebugger::_file_selected(const String &p_file) {
 	}
 }
 
+bool ScriptEditorDebugger::_validate_message(
+		const String &p_name,
+		Array p_data,
+		std::initializer_list<Variant::Type> p_types,
+		Vector<const Variant *> *p_out_validated,
+		bool p_allow_extra_data) {
+	if (p_out_validated) {
+		p_out_validated->clear();
+	}
+	if (p_data.size() < static_cast<int>(p_types.size())) {
+		ERR_PRINT(vformat("Message '%s' too short.", p_name));
+		return false;
+	}
+	if (p_data.size() != static_cast<int>(p_types.size()) && !p_allow_extra_data) {
+		ERR_PRINT(vformat("Message '%s' has too many arguments and does not permit extension.", p_name));
+		return false;
+	}
+	int scan = 0;
+	for (Variant::Type expected : p_types) {
+		// REVISIT: we could allow Variant::can_convert_strict, but is that a good idea?
+		if (p_data[scan].get_type() != expected) {
+			ERR_PRINT(vformat("Message '%s' argument %d should be type %d but %d received.",
+					p_name,
+					scan,
+					expected,
+					p_data[scan].get_type()));
+			return false;
+		}
+		if (p_out_validated) {
+			p_out_validated->append(&p_data[scan]);
+		}
+		++scan;
+	}
+	return true;
+}
+
 void ScriptEditorDebugger::request_remote_tree() {
-	_put_msg("scene:request_scene_tree", Array());
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:request_scene_tree", Array());
 }
 
 const SceneDebuggerTree *ScriptEditorDebugger::get_remote_tree() {
@@ -252,35 +290,35 @@ void ScriptEditorDebugger::update_remote_object(ObjectID p_obj_id, const String
 	msg.push_back(p_obj_id);
 	msg.push_back(p_prop);
 	msg.push_back(p_value);
-	_put_msg("scene:set_object_property", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:set_object_property", msg);
 }
 
 void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) {
 	ERR_FAIL_COND(p_obj_id.is_null());
 	Array msg;
 	msg.push_back(p_obj_id);
-	_put_msg("scene:inspect_object", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:inspect_object", msg);
 }
 
-Object *ScriptEditorDebugger::get_remote_object(ObjectID p_id) {
-	return inspector->get_object(p_id);
+Object *ScriptEditorDebugger::get_remote_object(ObjectID p_obj_id) {
+	return inspector->get_object(p_obj_id);
 }
 
-void ScriptEditorDebugger::_remote_object_selected(ObjectID p_id) {
-	emit_signal(SNAME("remote_object_requested"), p_id);
+void ScriptEditorDebugger::_remote_object_selected(ObjectID p_obj_id) {
+	emit_signal(SNAME("remote_object_requested"), p_obj_id);
 }
 
-void ScriptEditorDebugger::_remote_object_edited(ObjectID p_id, const String &p_prop, const Variant &p_value) {
-	update_remote_object(p_id, p_prop, p_value);
-	request_remote_object(p_id);
+void ScriptEditorDebugger::_remote_object_edited(ObjectID p_obj_id, const String &p_prop, const Variant &p_value) {
+	update_remote_object(p_obj_id, p_prop, p_value);
+	request_remote_object(p_obj_id);
 }
 
-void ScriptEditorDebugger::_remote_object_property_updated(ObjectID p_id, const String &p_property) {
-	emit_signal(SNAME("remote_object_property_updated"), p_id, p_property);
+void ScriptEditorDebugger::_remote_object_property_updated(ObjectID p_obj_id, const String &p_property) {
+	emit_signal(SNAME("remote_object_property_updated"), p_obj_id, p_property);
 }
 
 void ScriptEditorDebugger::_video_mem_request() {
-	_put_msg("servers:memory", Array());
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "servers:memory", Array());
 }
 
 void ScriptEditorDebugger::_video_mem_export() {
@@ -297,417 +335,513 @@ Size2 ScriptEditorDebugger::get_minimum_size() const {
 	return ms;
 }
 
-void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_data) {
-	emit_signal(SNAME("debug_data"), p_msg, p_data);
-	if (p_msg == "debug_enter") {
-		_put_msg("get_stack_dump", Array());
-
-		ERR_FAIL_COND(p_data.size() != 3);
-		bool can_continue = p_data[0];
-		String error = p_data[1];
-		bool has_stackdump = p_data[2];
-		breaked = true;
-		can_debug = can_continue;
-		_update_buttons_state();
-		_set_reason_text(error, MESSAGE_ERROR);
-		emit_signal(SNAME("breaked"), true, can_continue, error, has_stackdump);
-		if (is_move_to_foreground()) {
-			DisplayServer::get_singleton()->window_move_to_foreground();
-		}
-		if (!error.is_empty()) {
-			tabs->set_current_tab(0);
-		}
-		profiler->set_enabled(false);
-		inspector->clear_cache(); // Take a chance to force remote objects update.
+void ScriptEditorDebugger::_handle_debug_enter(const Array &p_data, DebugThreadID *p_tid, bool p_is_main_thread, int p_severity_code) {
+	breaked = true;
+	can_debug = p_data[0];
+	const String error = p_data[1];
+	const bool has_stackdump = p_data[2];
+	_update_buttons_state();
+	_set_reason_text(error, MESSAGE_ERROR);
 
-	} else if (p_msg == "debug_exit") {
-		breaked = false;
-		can_debug = false;
-		_clear_execution();
-		_update_buttons_state();
-		_set_reason_text(TTR("Execution resumed."), MESSAGE_SUCCESS);
-		emit_signal(SNAME("breaked"), false, false, "", false);
-		profiler->set_enabled(true);
-		profiler->disable_seeking();
-	} else if (p_msg == "set_pid") {
-		ERR_FAIL_COND(p_data.size() < 1);
-		remote_pid = p_data[0];
-	} else if (p_msg == "scene:click_ctrl") {
-		ERR_FAIL_COND(p_data.size() < 2);
-		clicked_ctrl->set_text(p_data[0]);
-		clicked_ctrl_type->set_text(p_data[1]);
-	} else if (p_msg == "scene:scene_tree") {
-		scene_tree->nodes.clear();
-		scene_tree->deserialize(p_data);
-		emit_signal(SNAME("remote_tree_updated"));
-		_update_buttons_state();
-	} else if (p_msg == "scene:inspect_object") {
-		ObjectID id = inspector->add_object(p_data);
-		if (id.is_valid()) {
-			emit_signal(SNAME("remote_object_updated"), id);
-		}
-	} else if (p_msg == "servers:memory_usage") {
-		vmem_tree->clear();
-		TreeItem *root = vmem_tree->create_item();
-		ServersDebugger::ResourceUsage usage;
-		usage.deserialize(p_data);
-
-		uint64_t total = 0;
-
-		for (const ServersDebugger::ResourceInfo &E : usage.infos) {
-			TreeItem *it = vmem_tree->create_item(root);
-			String type = E.type;
-			int bytes = E.vram;
-			it->set_text(0, E.path);
-			it->set_text(1, type);
-			it->set_text(2, E.format);
-			it->set_text(3, String::humanize_size(bytes));
-			total += bytes;
-
-			if (has_theme_icon(type, SNAME("EditorIcons"))) {
-				it->set_icon(0, get_theme_icon(type, SNAME("EditorIcons")));
-			}
+	if (p_tid) {
+		focused_thread = *p_tid;
+		emit_signal(SNAME("thread_breaked"), *p_tid, p_is_main_thread, error, p_severity_code, can_debug);
+	}
+	emit_signal(SNAME("breaked"), true, can_debug, error, has_stackdump);
+	if (is_move_to_foreground()) {
+		DisplayServer::get_singleton()->window_move_to_foreground();
+	}
+	if (!error.is_empty()) {
+		tabs->set_current_tab(0);
+	}
+	profiler->set_enabled(false);
+	inspector->clear_cache(); // Take a chance to force remote objects update.
+}
+
+void ScriptEditorDebugger::_handle_debug_exit(DebugThreadID *p_tid) {
+	if (p_tid != nullptr && *p_tid != focused_thread) {
+		// Ignore out of order message that can happen when we switch between main and non-main threads.
+		return;
+	}
+	breaked = false;
+	can_debug = false;
+	_clear_execution();
+	_update_buttons_state();
+	_set_reason_text(TTR("Execution resumed."), MESSAGE_SUCCESS);
+	emit_signal(SNAME("breaked"), false, false, "", false);
+	if (p_tid) {
+		emit_signal(SNAME("thread_continued"), *p_tid);
+	}
+	profiler->set_enabled(true);
+	profiler->disable_seeking();
+}
+
+void ScriptEditorDebugger::_handle_servers_memory_usage(const Array &p_data) const {
+	vmem_tree->clear();
+	TreeItem *root = vmem_tree->create_item();
+	ServersDebugger::ResourceUsage usage;
+	usage.deserialize(p_data);
+
+	uint64_t total = 0;
+
+	for (const ServersDebugger::ResourceInfo &E : usage.infos) {
+		TreeItem *it = vmem_tree->create_item(root);
+		String type = E.type;
+		int bytes = E.vram;
+		it->set_text(0, E.path);
+		it->set_text(1, type);
+		it->set_text(2, E.format);
+		it->set_text(3, String::humanize_size(bytes));
+		total += bytes;
+
+		if (has_theme_icon(type, SNAME("EditorIcons"))) {
+			it->set_icon(0, get_theme_icon(type, SNAME("EditorIcons")));
 		}
+	}
 
-		vmem_total->set_tooltip_text(TTR("Bytes:") + " " + itos(total));
-		vmem_total->set_text(String::humanize_size(total));
+	vmem_total->set_tooltip_text(TTR("Bytes:") + " " + itos(total));
+	vmem_total->set_text(String::humanize_size(total));
+}
 
-	} else if (p_msg == "stack_dump") {
-		DebuggerMarshalls::ScriptStackDump stack;
-		stack.deserialize(p_data);
-
-		stack_dump->clear();
-		inspector->clear_stack_variables();
-		TreeItem *r = stack_dump->create_item();
-
-		Array stack_dump_info;
-
-		for (int i = 0; i < stack.frames.size(); i++) {
-			TreeItem *s = stack_dump->create_item(r);
-			Dictionary d;
-			d["frame"] = i;
-			d["file"] = stack.frames[i].file;
-			d["function"] = stack.frames[i].func;
-			d["line"] = stack.frames[i].line;
-			stack_dump_info.push_back(d);
-			s->set_metadata(0, d);
-
-			String line = itos(i) + " - " + String(d["file"]) + ":" + itos(d["line"]) + " - at function: " + String(d["function"]);
-			s->set_text(0, line);
-
-			if (i == 0) {
-				s->select(0);
-			}
+void ScriptEditorDebugger::_handle_stack_dump(const Array &p_data) {
+	DebuggerMarshalls::ScriptStackDump stack;
+	stack.deserialize(p_data);
+
+	if (stack.tid.is_zero()) {
+		// Requested stack dump was not available.  Our signal clients don't expect to
+		// see these.
+		return;
+	}
+
+	Array stack_dump_info;
+	for (int i = 0; i < stack.frames.size(); i++) {
+		Dictionary frame_info;
+		frame_info["frame"] = i;
+		frame_info["file"] = stack.frames[i].file;
+		frame_info["function"] = stack.frames[i].func;
+		frame_info["line"] = stack.frames[i].line;
+		stack_dump_info.push_back(frame_info);
+
+		String line = itos(i) + " - " + String(frame_info["file"]) + ":" + itos(frame_info["line"]) + " - at function: " + String(frame_info["function"]);
+	}
+	emit_signal(SNAME("stack_dump"), stack_dump_info);
+	emit_signal(SNAME("thread_stack_dump"), stack.tid, stack_dump_info);
+}
+
+void ScriptEditorDebugger::_handle_stack_frame_vars(const Array &p_data) {
+	inspector->clear_stack_variables();
+	ERR_FAIL_COND(p_data.size() < 1);
+	emit_signal(SNAME("stack_frame_vars"), p_data[0]);
+	if (p_data.size() > 1) {
+		emit_signal(SNAME("thread_stack_frame_vars"), p_data[0], p_data[1]);
+	}
+}
+
+void ScriptEditorDebugger::_handle_output(const Array &p_data) {
+	ERR_FAIL_COND(p_data.size() != 2);
+
+	ERR_FAIL_COND(p_data[0].get_type() != Variant::PACKED_STRING_ARRAY);
+	Vector<String> output_strings = p_data[0];
+
+	ERR_FAIL_COND(p_data[1].get_type() != Variant::PACKED_INT32_ARRAY);
+	Vector<int> output_types = p_data[1];
+
+	ERR_FAIL_COND(output_strings.size() != output_types.size());
+
+	for (int i = 0; i < output_strings.size(); i++) {
+		RemoteDebugger::MessageType type = (RemoteDebugger::MessageType)(int)(output_types[i]);
+		EditorLog::MessageType msg_type;
+		switch (type) {
+			case RemoteDebugger::MESSAGE_TYPE_LOG: {
+				msg_type = EditorLog::MSG_TYPE_STD;
+			} break;
+			case RemoteDebugger::MESSAGE_TYPE_LOG_RICH: {
+				msg_type = EditorLog::MSG_TYPE_STD_RICH;
+			} break;
+			case RemoteDebugger::MESSAGE_TYPE_ERROR: {
+				msg_type = EditorLog::MSG_TYPE_ERROR;
+			} break;
+			default: {
+				WARN_PRINT("Unhandled script debugger message type: " + itos(type));
+				msg_type = EditorLog::MSG_TYPE_STD;
+			} break;
 		}
-		emit_signal(SNAME("stack_dump"), stack_dump_info);
-	} else if (p_msg == "stack_frame_vars") {
-		inspector->clear_stack_variables();
-		ERR_FAIL_COND(p_data.size() != 1);
-		emit_signal(SNAME("stack_frame_vars"), p_data[0]);
+		EditorNode::get_log()->add_message(output_strings[i], msg_type);
+		emit_signal(SNAME("output"), output_strings[i]);
+	}
+}
 
-	} else if (p_msg == "stack_frame_var") {
-		inspector->add_stack_variable(p_data);
-		emit_signal(SNAME("stack_frame_var"), p_data);
+void ScriptEditorDebugger::_handle_peformance_profile_frame(const Array &p_data) const {
+	Vector<float> frame_data;
+	frame_data.resize(p_data.size());
+	for (int i = 0; i < p_data.size(); i++) {
+		frame_data.write[i] = p_data[i];
+	}
+	performance_profiler->add_profile_frame(frame_data);
+}
 
-	} else if (p_msg == "output") {
-		ERR_FAIL_COND(p_data.size() != 2);
-
-		ERR_FAIL_COND(p_data[0].get_type() != Variant::PACKED_STRING_ARRAY);
-		Vector<String> output_strings = p_data[0];
-
-		ERR_FAIL_COND(p_data[1].get_type() != Variant::PACKED_INT32_ARRAY);
-		Vector<int> output_types = p_data[1];
-
-		ERR_FAIL_COND(output_strings.size() != output_types.size());
-
-		for (int i = 0; i < output_strings.size(); i++) {
-			RemoteDebugger::MessageType type = (RemoteDebugger::MessageType)(int)(output_types[i]);
-			EditorLog::MessageType msg_type;
-			switch (type) {
-				case RemoteDebugger::MESSAGE_TYPE_LOG: {
-					msg_type = EditorLog::MSG_TYPE_STD;
-				} break;
-				case RemoteDebugger::MESSAGE_TYPE_LOG_RICH: {
-					msg_type = EditorLog::MSG_TYPE_STD_RICH;
-				} break;
-				case RemoteDebugger::MESSAGE_TYPE_ERROR: {
-					msg_type = EditorLog::MSG_TYPE_ERROR;
-				} break;
-				default: {
-					WARN_PRINT("Unhandled script debugger message type: " + itos(type));
-					msg_type = EditorLog::MSG_TYPE_STD;
-				} break;
-			}
-			EditorNode::get_log()->add_message(output_strings[i], msg_type);
-			emit_signal(SNAME("output"), output_strings[i]);
+void ScriptEditorDebugger::_handle_visual_profile_frame(const Array &p_data) const {
+	ServersDebugger::VisualProfilerFrame frame;
+	frame.deserialize(p_data);
+
+	EditorVisualProfiler::Metric metric;
+	metric.areas.resize(frame.areas.size());
+	metric.frame_number = frame.frame_number;
+	metric.valid = true;
+
+	{
+		EditorVisualProfiler::Metric::Area *areas_ptr = metric.areas.ptrw();
+		for (int i = 0; i < frame.areas.size(); i++) {
+			areas_ptr[i].name = frame.areas[i].name;
+			areas_ptr[i].cpu_time = frame.areas[i].cpu_msec;
+			areas_ptr[i].gpu_time = frame.areas[i].gpu_msec;
 		}
-	} else if (p_msg == "performance:profile_frame") {
-		Vector<float> frame_data;
-		frame_data.resize(p_data.size());
-		for (int i = 0; i < p_data.size(); i++) {
-			frame_data.write[i] = p_data[i];
+	}
+	visual_profiler->add_frame_metric(metric);
+}
+
+void ScriptEditorDebugger::_handle_error(const Array &p_data) {
+	DebuggerMarshalls::OutputError oe;
+	ERR_FAIL_COND_MSG(oe.deserialize(p_data) == false, "Failed to deserialize error message");
+
+	// Format time.
+	Array time_vals;
+	time_vals.push_back(oe.hr);
+	time_vals.push_back(oe.min);
+	time_vals.push_back(oe.sec);
+	time_vals.push_back(oe.msec);
+	bool e;
+	String time = String("%d:%02d:%02d:%04d").sprintf(time_vals, &e);
+
+	// Rest of the error data.
+	bool source_is_project_file = oe.source_file.begins_with("res://");
+
+	// Metadata to highlight error line in scripts.
+	Array source_meta;
+	source_meta.push_back(oe.source_file);
+	source_meta.push_back(oe.source_line);
+
+	// Create error tree to display above error or warning details.
+	TreeItem *r = error_tree->get_root();
+	if (!r) {
+		r = error_tree->create_item();
+	}
+
+	// Also provide the relevant details as tooltip to quickly check without
+	// uncollapsing the tree.
+	String tooltip = oe.warning ? TTR("Warning:") : TTR("Error:");
+
+	TreeItem *error = error_tree->create_item(r);
+	error->set_collapsed(true);
+
+	error->set_icon(0, get_theme_icon(oe.warning ? SNAME("Warning") : SNAME("Error"), SNAME("EditorIcons")));
+	error->set_text(0, time);
+	error->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
+
+	const Color color = get_theme_color(oe.warning ? SNAME("warning_color") : SNAME("error_color"), SNAME("Editor"));
+	error->set_custom_color(0, color);
+	error->set_custom_color(1, color);
+
+	String error_title;
+	if (oe.callstack.size() > 0) {
+		// If available, use the script's stack in the error title.
+		error_title = oe.callstack[oe.callstack.size() - 1].func + ": ";
+	} else if (!oe.source_func.is_empty()) {
+		// Otherwise try to use the C++ source function.
+		error_title += oe.source_func + ": ";
+	}
+	// If we have a (custom) error message, use it as title, and add a C++ Error
+	// item with the original error condition.
+	error_title += oe.error_descr.is_empty() ? oe.error : oe.error_descr;
+	error->set_text(1, error_title);
+	tooltip += " " + error_title + "\n";
+
+	if (!oe.error_descr.is_empty()) {
+		// Add item for C++ error condition.
+		TreeItem *cpp_cond = error_tree->create_item(error);
+		cpp_cond->set_text(0, "<" + TTR("C++ Error") + ">");
+		cpp_cond->set_text(1, oe.error);
+		cpp_cond->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
+		tooltip += TTR("C++ Error:") + " " + oe.error + "\n";
+		if (source_is_project_file) {
+			cpp_cond->set_metadata(0, source_meta);
 		}
-		performance_profiler->add_profile_frame(frame_data);
+	}
+	Vector<uint8_t> v;
+	v.resize(100);
 
-	} else if (p_msg == "visual:profile_frame") {
-		ServersDebugger::VisualProfilerFrame frame;
-		frame.deserialize(p_data);
+	// Source of the error.
+	String source_txt = (source_is_project_file ? oe.source_file.get_file() : oe.source_file) + ":" + itos(oe.source_line);
+	if (!oe.source_func.is_empty()) {
+		source_txt += " @ " + oe.source_func + "()";
+	}
 
-		EditorVisualProfiler::Metric metric;
-		metric.areas.resize(frame.areas.size());
-		metric.frame_number = frame.frame_number;
-		metric.valid = true;
+	TreeItem *cpp_source = error_tree->create_item(error);
+	cpp_source->set_text(0, "<" + (source_is_project_file ? TTR("Source") : TTR("C++ Source")) + ">");
+	cpp_source->set_text(1, source_txt);
+	cpp_source->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
+	tooltip += (source_is_project_file ? TTR("Source:") : TTR("C++ Source:")) + " " + source_txt + "\n";
 
-		{
-			EditorVisualProfiler::Metric::Area *areas_ptr = metric.areas.ptrw();
-			for (int i = 0; i < frame.areas.size(); i++) {
-				areas_ptr[i].name = frame.areas[i].name;
-				areas_ptr[i].cpu_time = frame.areas[i].cpu_msec;
-				areas_ptr[i].gpu_time = frame.areas[i].gpu_msec;
-			}
-		}
-		visual_profiler->add_frame_metric(metric);
+	// Set metadata to highlight error line in scripts.
+	if (source_is_project_file) {
+		error->set_metadata(0, source_meta);
+		cpp_source->set_metadata(0, source_meta);
+	}
 
-	} else if (p_msg == "error") {
-		DebuggerMarshalls::OutputError oe;
-		ERR_FAIL_COND_MSG(oe.deserialize(p_data) == false, "Failed to deserialize error message");
-
-		// Format time.
-		Array time_vals;
-		time_vals.push_back(oe.hr);
-		time_vals.push_back(oe.min);
-		time_vals.push_back(oe.sec);
-		time_vals.push_back(oe.msec);
-		bool e;
-		String time = String("%d:%02d:%02d:%04d").sprintf(time_vals, &e);
-
-		// Rest of the error data.
-		bool source_is_project_file = oe.source_file.begins_with("res://");
-
-		// Metadata to highlight error line in scripts.
-		Array source_meta;
-		source_meta.push_back(oe.source_file);
-		source_meta.push_back(oe.source_line);
-
-		// Create error tree to display above error or warning details.
-		TreeItem *r = error_tree->get_root();
-		if (!r) {
-			r = error_tree->create_item();
+	// Format stack trace.
+	// stack_items_count is the number of elements to parse, with 3 items per frame
+	// of the stack trace (script, method, line).
+	const ScriptLanguageThreadContext::StackInfo *infos = oe.callstack.ptr();
+	for (unsigned int i = 0; i < (unsigned int)oe.callstack.size(); i++) {
+		TreeItem *stack_trace = error_tree->create_item(error);
+
+		Array meta;
+		meta.push_back(infos[i].file);
+		meta.push_back(infos[i].line);
+		stack_trace->set_metadata(0, meta);
+
+		if (i == 0) {
+			stack_trace->set_text(0, "<" + TTR("Stack Trace") + ">");
+			stack_trace->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
+			error->set_metadata(0, meta);
+			tooltip += TTR("Stack Trace:") + "\n";
 		}
 
-		// Also provide the relevant details as tooltip to quickly check without
-		// uncollapsing the tree.
-		String tooltip = oe.warning ? TTR("Warning:") : TTR("Error:");
+		String frame_txt = infos[i].file.get_file() + ":" + itos(infos[i].line) + " @ " + infos[i].func + "()";
+		tooltip += frame_txt + "\n";
+		stack_trace->set_text(1, frame_txt);
+	}
 
-		TreeItem *error = error_tree->create_item(r);
-		error->set_collapsed(true);
+	error->set_tooltip_text(0, tooltip);
+	error->set_tooltip_text(1, tooltip);
 
-		error->set_icon(0, get_theme_icon(oe.warning ? SNAME("Warning") : SNAME("Error"), SNAME("EditorIcons")));
-		error->set_text(0, time);
-		error->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
+	if (warning_count == 0 && error_count == 0) {
+		expand_all_button->set_disabled(false);
+		collapse_all_button->set_disabled(false);
+		clear_button->set_disabled(false);
+	}
 
-		const Color color = get_theme_color(oe.warning ? SNAME("warning_color") : SNAME("error_color"), SNAME("Editor"));
-		error->set_custom_color(0, color);
-		error->set_custom_color(1, color);
+	if (oe.warning) {
+		warning_count++;
+	} else {
+		error_count++;
+	}
+}
 
-		String error_title;
-		if (oe.callstack.size() > 0) {
-			// If available, use the script's stack in the error title.
-			error_title = oe.callstack[oe.callstack.size() - 1].func + ": ";
-		} else if (!oe.source_func.is_empty()) {
-			// Otherwise try to use the C++ source function.
-			error_title += oe.source_func + ": ";
-		}
-		// If we have a (custom) error message, use it as title, and add a C++ Error
-		// item with the original error condition.
-		error_title += oe.error_descr.is_empty() ? oe.error : oe.error_descr;
-		error->set_text(1, error_title);
-		tooltip += " " + error_title + "\n";
-
-		if (!oe.error_descr.is_empty()) {
-			// Add item for C++ error condition.
-			TreeItem *cpp_cond = error_tree->create_item(error);
-			cpp_cond->set_text(0, "<" + TTR("C++ Error") + ">");
-			cpp_cond->set_text(1, oe.error);
-			cpp_cond->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
-			tooltip += TTR("C++ Error:") + " " + oe.error + "\n";
-			if (source_is_project_file) {
-				cpp_cond->set_metadata(0, source_meta);
-			}
-		}
-		Vector<uint8_t> v;
-		v.resize(100);
+void ScriptEditorDebugger::_handle_servers_function_signature(const Array &p_data) {
+	// Cache a profiler signature.
+	ServersDebugger::ScriptFunctionSignature sig;
+	sig.deserialize(p_data);
+	profiler_signature[sig.id] = sig.name;
+}
 
-		// Source of the error.
-		String source_txt = (source_is_project_file ? oe.source_file.get_file() : oe.source_file) + ":" + itos(oe.source_line);
-		if (!oe.source_func.is_empty()) {
-			source_txt += " @ " + oe.source_func + "()";
-		}
+void ScriptEditorDebugger::_handle_servers_profile_requests(const Array &p_data, EditorProfiler::Metric &metric) {
+	ServersDebugger::ServersProfilerFrame frame;
+	frame.deserialize(p_data);
+	metric.valid = true;
+	metric.frame_number = frame.frame_number;
+	metric.frame_time = frame.frame_time;
+	metric.process_time = frame.process_time;
+	metric.physics_time = frame.physics_time;
+	metric.physics_frame_time = frame.physics_frame_time;
 
-		TreeItem *cpp_source = error_tree->create_item(error);
-		cpp_source->set_text(0, "<" + (source_is_project_file ? TTR("Source") : TTR("C++ Source")) + ">");
-		cpp_source->set_text(1, source_txt);
-		cpp_source->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
-		tooltip += (source_is_project_file ? TTR("Source:") : TTR("C++ Source:")) + " " + source_txt + "\n";
+	if (frame.servers.size()) {
+		EditorProfiler::Metric::Category frame_time;
+		frame_time.signature = "category_frame_time";
+		frame_time.name = "Frame Time";
+		frame_time.total_time = metric.frame_time;
 
-		// Set metadata to highlight error line in scripts.
-		if (source_is_project_file) {
-			error->set_metadata(0, source_meta);
-			cpp_source->set_metadata(0, source_meta);
-		}
+		EditorProfiler::Metric::Category::Item item;
+		item.calls = 1;
+		item.line = 0;
 
-		// Format stack trace.
-		// stack_items_count is the number of elements to parse, with 3 items per frame
-		// of the stack trace (script, method, line).
-		const ScriptLanguage::StackInfo *infos = oe.callstack.ptr();
-		for (unsigned int i = 0; i < (unsigned int)oe.callstack.size(); i++) {
-			TreeItem *stack_trace = error_tree->create_item(error);
-
-			Array meta;
-			meta.push_back(infos[i].file);
-			meta.push_back(infos[i].line);
-			stack_trace->set_metadata(0, meta);
-
-			if (i == 0) {
-				stack_trace->set_text(0, "<" + TTR("Stack Trace") + ">");
-				stack_trace->set_text_alignment(0, HORIZONTAL_ALIGNMENT_LEFT);
-				error->set_metadata(0, meta);
-				tooltip += TTR("Stack Trace:") + "\n";
-			}
+		item.name = "Physics Time";
+		item.total = metric.physics_time;
+		item.self = item.total;
+		item.signature = "physics_time";
 
-			String frame_txt = infos[i].file.get_file() + ":" + itos(infos[i].line) + " @ " + infos[i].func + "()";
-			tooltip += frame_txt + "\n";
-			stack_trace->set_text(1, frame_txt);
-		}
+		frame_time.items.push_back(item);
 
-		error->set_tooltip_text(0, tooltip);
-		error->set_tooltip_text(1, tooltip);
+		item.name = "Process Time";
+		item.total = metric.process_time;
+		item.self = item.total;
+		item.signature = "process_time";
 
-		if (warning_count == 0 && error_count == 0) {
-			expand_all_button->set_disabled(false);
-			collapse_all_button->set_disabled(false);
-			clear_button->set_disabled(false);
-		}
+		frame_time.items.push_back(item);
 
-		if (oe.warning) {
-			warning_count++;
-		} else {
-			error_count++;
-		}
+		item.name = "Physics Frame Time";
+		item.total = metric.physics_frame_time;
+		item.self = item.total;
+		item.signature = "physics_frame_time";
 
-	} else if (p_msg == "servers:function_signature") {
-		// Cache a profiler signature.
-		ServersDebugger::ScriptFunctionSignature sig;
-		sig.deserialize(p_data);
-		profiler_signature[sig.id] = sig.name;
+		frame_time.items.push_back(item);
 
-	} else if (p_msg == "servers:profile_frame" || p_msg == "servers:profile_total") {
-		EditorProfiler::Metric metric;
-		ServersDebugger::ServersProfilerFrame frame;
-		frame.deserialize(p_data);
-		metric.valid = true;
-		metric.frame_number = frame.frame_number;
-		metric.frame_time = frame.frame_time;
-		metric.process_time = frame.process_time;
-		metric.physics_time = frame.physics_time;
-		metric.physics_frame_time = frame.physics_frame_time;
-
-		if (frame.servers.size()) {
-			EditorProfiler::Metric::Category frame_time;
-			frame_time.signature = "category_frame_time";
-			frame_time.name = "Frame Time";
-			frame_time.total_time = metric.frame_time;
+		metric.categories.push_back(frame_time);
+	}
 
+	for (int i = 0; i < frame.servers.size(); i++) {
+		const ServersDebugger::ServerInfo &srv = frame.servers[i];
+		EditorProfiler::Metric::Category c;
+		const String name = srv.name;
+		c.name = EditorPropertyNameProcessor::get_singleton()->process_name(name, EditorPropertyNameProcessor::STYLE_CAPITALIZED);
+		c.items.resize(srv.functions.size());
+		c.total_time = 0;
+		c.signature = "categ::" + name;
+		for (int j = 0; j < srv.functions.size(); j++) {
 			EditorProfiler::Metric::Category::Item item;
 			item.calls = 1;
 			item.line = 0;
+			item.name = srv.functions[j].name;
+			item.self = srv.functions[j].time;
+			item.total = item.self;
+			item.signature = "categ::" + name + "::" + item.name;
+			item.name = EditorPropertyNameProcessor::get_singleton()->process_name(item.name, EditorPropertyNameProcessor::STYLE_CAPITALIZED);
+			c.total_time += item.total;
+			c.items.write[j] = item;
+		}
+		metric.categories.push_back(c);
+	}
+
+	EditorProfiler::Metric::Category funcs;
+	funcs.total_time = frame.script_time;
+	funcs.items.resize(frame.script_functions.size());
+	funcs.name = "Script Functions";
+	funcs.signature = "script_functions";
+	for (int i = 0; i < frame.script_functions.size(); i++) {
+		int signature = frame.script_functions[i].sig_id;
+		int calls = frame.script_functions[i].call_count;
+		float total = frame.script_functions[i].total_time;
+		float self = frame.script_functions[i].self_time;
+
+		EditorProfiler::Metric::Category::Item item;
+		if (profiler_signature.has(signature)) {
+			item.signature = profiler_signature[signature];
+
+			String name = profiler_signature[signature];
+			Vector<String> strings = name.split("::");
+			if (strings.size() == 3) {
+				item.name = strings[2];
+				item.script = strings[0];
+				item.line = strings[1].to_int();
+			} else if (strings.size() == 4) { // Built-in scripts have an :: in their name
+				item.name = strings[3];
+				item.script = strings[0] + "::" + strings[1];
+				item.line = strings[2].to_int();
+			}
 
-			item.name = "Physics Time";
-			item.total = metric.physics_time;
-			item.self = item.total;
-			item.signature = "physics_time";
+		} else {
+			item.name = "SigErr " + itos(signature);
+		}
 
-			frame_time.items.push_back(item);
+		item.calls = calls;
+		item.self = self;
+		item.total = total;
+		funcs.items.write[i] = item;
+	}
 
-			item.name = "Process Time";
-			item.total = metric.process_time;
-			item.self = item.total;
-			item.signature = "process_time";
+	metric.categories.push_back(funcs);
+}
 
-			frame_time.items.push_back(item);
+void ScriptEditorDebugger::request_stack_dump(const Variant &p_tid) {
+	Array request_args;
+	request_args.append(p_tid);
+	_put_msg(Channels::CHANNEL_OTHER, "get_stack_dump", request_args);
+}
 
-			item.name = "Physics Frame Time";
-			item.total = metric.physics_frame_time;
-			item.self = item.total;
-			item.signature = "physics_frame_time";
+void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_data) {
+	emit_signal(SNAME("debug_data"), p_msg, p_data);
+	// The validate_message calls here implement the external contract of the
+	// debugger protocol and must not change or be directly validated against
+	// signal MethodInfo, because those are a separate contract.
+	Vector<const Variant *> validated;
+	if (p_msg == "thread_paused") {
+		ERR_FAIL_COND(!_validate_message(p_msg, p_data, { Variant::PACKED_BYTE_ARRAY, Variant::BOOL }, &validated));
+		request_stack_dump(p_data[0]);
+		// REVISIT: emit_signalp is declared with const Variant **, instead of const Variant * const *
+		emit_signalp("thread_paused", validated.ptrw(), validated.size());
+
+	} else if (p_msg == "thread_alert") {
+		ERR_FAIL_COND(!_validate_message(p_msg, p_data, { Variant::PACKED_BYTE_ARRAY, Variant::BOOL, Variant::STRING, Variant::INT, Variant::BOOL, Variant::BOOL }, &validated));
+		if (static_cast<bool>(p_data[5])) {
+			request_stack_dump(p_data[0]);
+		}
+		emit_signalp("thread_alert", validated.ptrw(), validated.size());
+
+	} else if (p_msg == "debug_enter") {
+		// REVISIT: For some reason, the previous implementation queries for stack dump
+		// even if the message says there isn't one?
+		_put_msg(Channels::CHANNEL_OTHER, "get_stack_dump", Array());
+		ERR_FAIL_COND(!_validate_message(p_msg, p_data, { Variant::BOOL, Variant::STRING, Variant::BOOL }));
+		_handle_debug_enter(p_data, nullptr, true);
+
+	} else if (p_msg == "debug_enter_thread") {
+		ERR_FAIL_COND(!_validate_message(p_msg, p_data, { Variant::BOOL, Variant::STRING, Variant::BOOL, Variant::PACKED_BYTE_ARRAY, Variant::BOOL, Variant::INT }, &validated));
+		if (static_cast<bool>(p_data[2])) {
+			request_stack_dump(p_data[3]);
+		}
+		DebugThreadID tid = p_data[3];
+		_handle_debug_enter(p_data, &tid, p_data[4].booleanize(), p_data[5]);
 
-			frame_time.items.push_back(item);
+	} else if (p_msg == "debug_exit") {
+		_handle_debug_exit();
 
-			metric.categories.push_back(frame_time);
-		}
+	} else if (p_msg == "debug_exit_thread") {
+		ERR_FAIL_COND(!_validate_message(p_msg, p_data, { Variant::PACKED_BYTE_ARRAY }, &validated));
+		DebugThreadID tid = p_data[0];
+		_handle_debug_exit(&tid);
 
-		for (int i = 0; i < frame.servers.size(); i++) {
-			const ServersDebugger::ServerInfo &srv = frame.servers[i];
-			EditorProfiler::Metric::Category c;
-			const String name = srv.name;
-			c.name = EditorPropertyNameProcessor::get_singleton()->process_name(name, EditorPropertyNameProcessor::STYLE_CAPITALIZED);
-			c.items.resize(srv.functions.size());
-			c.total_time = 0;
-			c.signature = "categ::" + name;
-			for (int j = 0; j < srv.functions.size(); j++) {
-				EditorProfiler::Metric::Category::Item item;
-				item.calls = 1;
-				item.line = 0;
-				item.name = srv.functions[j].name;
-				item.self = srv.functions[j].time;
-				item.total = item.self;
-				item.signature = "categ::" + name + "::" + item.name;
-				item.name = EditorPropertyNameProcessor::get_singleton()->process_name(item.name, EditorPropertyNameProcessor::STYLE_CAPITALIZED);
-				c.total_time += item.total;
-				c.items.write[j] = item;
-			}
-			metric.categories.push_back(c);
+	} else if (p_msg == "set_pid") {
+		ERR_FAIL_COND(p_data.size() < 1);
+		remote_pid = p_data[0];
+
+	} else if (p_msg == "scene:click_ctrl") {
+		ERR_FAIL_COND(p_data.size() < 2);
+		clicked_ctrl->set_text(p_data[0]);
+		clicked_ctrl_type->set_text(p_data[1]);
+
+	} else if (p_msg == "scene:scene_tree") {
+		scene_tree->nodes.clear();
+		scene_tree->deserialize(p_data);
+		emit_signal(SNAME("remote_tree_updated"));
+		_update_buttons_state();
+
+	} else if (p_msg == "scene:inspect_object") {
+		ObjectID id = inspector->add_object(p_data);
+		if (id.is_valid()) {
+			emit_signal(SNAME("remote_object_updated"), id);
 		}
 
-		EditorProfiler::Metric::Category funcs;
-		funcs.total_time = frame.script_time;
-		funcs.items.resize(frame.script_functions.size());
-		funcs.name = "Script Functions";
-		funcs.signature = "script_functions";
-		for (int i = 0; i < frame.script_functions.size(); i++) {
-			int signature = frame.script_functions[i].sig_id;
-			int calls = frame.script_functions[i].call_count;
-			float total = frame.script_functions[i].total_time;
-			float self = frame.script_functions[i].self_time;
+	} else if (p_msg == "servers:memory_usage") {
+		_handle_servers_memory_usage(p_data);
 
-			EditorProfiler::Metric::Category::Item item;
-			if (profiler_signature.has(signature)) {
-				item.signature = profiler_signature[signature];
-
-				String name = profiler_signature[signature];
-				Vector<String> strings = name.split("::");
-				if (strings.size() == 3) {
-					item.name = strings[2];
-					item.script = strings[0];
-					item.line = strings[1].to_int();
-				} else if (strings.size() == 4) { //Built-in scripts have an :: in their name
-					item.name = strings[3];
-					item.script = strings[0] + "::" + strings[1];
-					item.line = strings[2].to_int();
-				}
+	} else if (p_msg == "stack_dump") {
+		_handle_stack_dump(p_data);
 
-			} else {
-				item.name = "SigErr " + itos(signature);
-			}
+	} else if (p_msg == "stack_frame_vars") {
+		_handle_stack_frame_vars(p_data);
 
-			item.calls = calls;
-			item.self = self;
-			item.total = total;
-			funcs.items.write[i] = item;
-		}
+	} else if (p_msg == "stack_frame_var") {
+		inspector->add_stack_variable(p_data);
+		emit_signal(SNAME("stack_frame_var"), p_data);
+
+	} else if (p_msg == "output") {
+		_handle_output(p_data);
 
-		metric.categories.push_back(funcs);
+	} else if (p_msg == "performance:profile_frame") {
+		_handle_peformance_profile_frame(p_data);
+
+	} else if (p_msg == "visual:profile_frame") {
+		_handle_visual_profile_frame(p_data);
 
+	} else if (p_msg == "error") {
+		_handle_error(p_data);
+
+	} else if (p_msg == "servers:function_signature") {
+		_handle_servers_function_signature(p_data);
+
+	} else if (p_msg == "servers:profile_frame" || p_msg == "servers:profile_total") {
+		EditorProfiler::Metric metric;
+		_handle_servers_profile_requests(p_data, metric);
 		if (p_msg == "servers:profile_frame") {
 			profiler->add_frame_metric(metric, false);
 		} else {
@@ -737,7 +871,6 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 			monitors.set(i, p_data[i]);
 		}
 		performance_profiler->update_monitors(monitors);
-
 	} else {
 		int colon_index = p_msg.find_char(':');
 		ERR_FAIL_COND_MSG(colon_index < 1, "Invalid message received");
@@ -781,6 +914,12 @@ void ScriptEditorDebugger::_set_reason_text(const String &p_reason, MessageType
 
 void ScriptEditorDebugger::_notification(int p_what) {
 	switch (p_what) {
+		case NOTIFICATION_EXIT_TREE: {
+			if (stack_dump != nullptr) {
+				stack_dump->disconnect(*this);
+			}
+		} break;
+
 		case NOTIFICATION_ENTER_TREE: {
 			le_set->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_live_edit_set));
 			le_clear->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_live_edit_clear));
@@ -805,7 +944,9 @@ void ScriptEditorDebugger::_notification(int p_what) {
 
 		case NOTIFICATION_PROCESS: {
 			if (is_session_active()) {
-				peer->poll();
+				peer->poll(Channels::CHANNEL_MAIN_THREAD);
+				peer->poll(Channels::CHANNEL_DISCARDABLE);
+				peer->poll(Channels::CHANNEL_OTHER);
 
 				if (camera_override == CameraOverride::OVERRIDE_2D) {
 					Dictionary state = CanvasItemEditor::get_singleton()->get_state();
@@ -818,7 +959,7 @@ void ScriptEditorDebugger::_notification(int p_what) {
 
 					Array msg;
 					msg.push_back(transform);
-					_put_msg("scene:override_camera_2D:transform", msg);
+					_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_2D:transform", msg);
 
 				} else if (camera_override >= CameraOverride::OVERRIDE_3D_1) {
 					int viewport_idx = camera_override - CameraOverride::OVERRIDE_3D_1;
@@ -836,23 +977,27 @@ void ScriptEditorDebugger::_notification(int p_what) {
 					}
 					msg.push_back(cam->get_near());
 					msg.push_back(cam->get_far());
-					_put_msg("scene:override_camera_3D:transform", msg);
+					_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_3D:transform", msg);
 				}
 				if (breaked) {
-					_put_msg("servers:draw", Array());
+					_put_msg(Channels::CHANNEL_DISCARDABLE, "servers:draw", Array());
 				}
 			}
 
 			const uint64_t until = OS::get_singleton()->get_ticks_msec() + 20;
 
-			while (peer.is_valid() && peer->has_message()) {
-				Array arr = peer->get_message();
-				if (arr.size() != 2 || arr[0].get_type() != Variant::STRING || arr[1].get_type() != Variant::ARRAY) {
-					_stop_and_notify();
-					ERR_FAIL_MSG("Invalid message format received from peer");
+			while (peer.is_valid()) {
+				for (int channel_index = 0; channel_index < Channels::NUM_CHANNELS; ++channel_index) {
+					if (!peer->has_message(channel_index)) {
+						continue;
+					}
+					Array arr = peer->get_message(channel_index);
+					if (arr.size() != 2 || arr[0].get_type() != Variant::STRING || arr[1].get_type() != Variant::ARRAY) {
+						_stop_and_notify();
+						ERR_FAIL_MSG("Invalid message format received from peer");
+					}
+					_parse_message(arr[0], arr[1]);
 				}
-				_parse_message(arr[0], arr[1]);
-
 				if (OS::get_singleton()->get_ticks_msec() > until) {
 					break;
 				}
@@ -877,21 +1022,21 @@ void ScriptEditorDebugger::_notification(int p_what) {
 			vmem_export->set_icon(get_theme_icon(SNAME("Save"), SNAME("EditorIcons")));
 			search->set_right_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));
 		} break;
+
+		case NOTIFICATION_POSTINITIALIZE: {
+			const Error ret = stack_dump->connect(*this);
+			ERR_FAIL_COND_MSG(ret != OK, "Failed to connect required debugger signals; please report broken implementation.");
+		} break;
 	}
 }
 
 void ScriptEditorDebugger::_clear_execution() {
-	TreeItem *ti = stack_dump->get_selected();
-	if (!ti) {
+	if (script_frame_info.is_empty()) {
 		return;
 	}
-
-	Dictionary d = ti->get_metadata(0);
-
-	stack_script = ResourceLoader::load(d["file"]);
+	stack_script = ResourceLoader::load(script_frame_info["file"]);
 	emit_signal(SNAME("clear_execution"), stack_script);
 	stack_script.unref();
-	stack_dump->clear();
 	inspector->clear_stack_variables();
 }
 
@@ -912,7 +1057,7 @@ void ScriptEditorDebugger::_breakpoint_tree_clicked() {
 	}
 }
 
-void ScriptEditorDebugger::start(Ref<RemoteDebuggerPeer> p_peer) {
+void ScriptEditorDebugger::start(Ref<Channels> p_peer) {
 	_clear_errors_list();
 	stop();
 
@@ -980,11 +1125,11 @@ void ScriptEditorDebugger::_profiler_activate(bool p_enable, int p_type) {
 	data.push_back(p_enable);
 	switch (p_type) {
 		case PROFILER_NETWORK:
-			_put_msg("profiler:multiplayer", data);
-			_put_msg("profiler:rpc", data);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "profiler:multiplayer", data);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "profiler:rpc", data);
 			break;
 		case PROFILER_VISUAL:
-			_put_msg("profiler:visual", data);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "profiler:visual", data);
 			break;
 		case PROFILER_SCRIPTS_SERVERS:
 			if (p_enable) {
@@ -996,7 +1141,7 @@ void ScriptEditorDebugger::_profiler_activate(bool p_enable, int p_type) {
 				opts.push_back(CLAMP(max_funcs, 16, 512));
 				data.push_back(opts);
 			}
-			_put_msg("profiler:servers", data);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "profiler:servers", data);
 			break;
 		default:
 			ERR_FAIL_MSG("Invalid profiler type");
@@ -1010,16 +1155,24 @@ void ScriptEditorDebugger::_profiler_seeked() {
 	debug_break();
 }
 
-void ScriptEditorDebugger::_stack_dump_frame_selected() {
+void ScriptEditorDebugger::_thread_frame_selected(const PackedByteArray &p_thread_id, int p_frame, const Dictionary &p_frame_info) {
+	script_frame_info = p_frame_info;
+	// REVISIT: This code is used both to select the thread when it first breaks and then to position to the code when we
+	// receive the stack dump info.  As a result, we end up requestsing the stack variables twice.  This is a non-trivial
+	// problem because we can't assume all languages will actually send stack dump information.
 	emit_signal(SNAME("stack_frame_selected"));
-
-	int frame = get_stack_script_frame();
-
-	if (!request_stack_dump(frame)) {
+	if (!request_stack_frame_variables(p_thread_id, p_frame)) {
 		inspector->edit(nullptr);
 	}
 }
 
+void ScriptEditorDebugger::_thread_nodebug_frame_selected(const PackedByteArray &, int p_frame, const Dictionary &p_frame_info) {
+	script_frame_info = p_frame_info;
+	emit_signal(SNAME("stack_frame_selected"));
+	inspector->clear_stack_variables();
+	inspector->edit(nullptr);
+}
+
 void ScriptEditorDebugger::_export_csv() {
 	file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
 	file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
@@ -1046,7 +1199,7 @@ int ScriptEditorDebugger::_get_node_path_cache(const NodePath &p_path) {
 	Array msg;
 	msg.push_back(p_path);
 	msg.push_back(last_path_id);
-	_put_msg("scene:live_node_path", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_node_path", msg);
 
 	return last_path_id;
 }
@@ -1064,7 +1217,7 @@ int ScriptEditorDebugger::_get_res_path_cache(const String &p_path) {
 	Array msg;
 	msg.push_back(p_path);
 	msg.push_back(last_path_id);
-	_put_msg("scene:live_res_path", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_res_path", msg);
 
 	return last_path_id;
 }
@@ -1077,7 +1230,7 @@ void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_n
 	Node *node = Object::cast_to<Node>(p_base);
 
 	for (int i = 0; i < p_argcount; i++) {
-		//no pointers, sorry
+		// no pointers, sorry
 		if (p_args[i]->get_type() == Variant::OBJECT || p_args[i]->get_type() == Variant::RID) {
 			return;
 		}
@@ -1091,10 +1244,10 @@ void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_n
 		msg.push_back(pathid);
 		msg.push_back(p_name);
 		for (int i = 0; i < p_argcount; i++) {
-			//no pointers, sorry
+			// no pointers, sorry
 			msg.push_back(*p_args[i]);
 		}
-		_put_msg("scene:live_node_call", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_node_call", msg);
 
 		return;
 	}
@@ -1109,10 +1262,10 @@ void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_n
 		msg.push_back(pathid);
 		msg.push_back(p_name);
 		for (int i = 0; i < p_argcount; i++) {
-			//no pointers, sorry
+			// no pointers, sorry
 			msg.push_back(*p_args[i]);
 		}
-		_put_msg("scene:live_res_call", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_res_call", msg);
 
 		return;
 	}
@@ -1136,14 +1289,14 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 				msg.push_back(pathid);
 				msg.push_back(p_property);
 				msg.push_back(res->get_path());
-				_put_msg("scene:live_node_prop_res", msg);
+				_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_node_prop_res", msg);
 			}
 		} else {
 			Array msg;
 			msg.push_back(pathid);
 			msg.push_back(p_property);
 			msg.push_back(p_value);
-			_put_msg("scene:live_node_prop", msg);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_node_prop", msg);
 		}
 
 		return;
@@ -1162,14 +1315,14 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 				msg.push_back(pathid);
 				msg.push_back(p_property);
 				msg.push_back(res2->get_path());
-				_put_msg("scene:live_res_prop_res", msg);
+				_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_res_prop_res", msg);
 			}
 		} else {
 			Array msg;
 			msg.push_back(pathid);
 			msg.push_back(p_property);
 			msg.push_back(p_value);
-			_put_msg("scene:live_res_prop", msg);
+			_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_res_prop", msg);
 		}
 
 		return;
@@ -1185,38 +1338,43 @@ void ScriptEditorDebugger::set_move_to_foreground(const bool &p_move_to_foregrou
 }
 
 String ScriptEditorDebugger::get_stack_script_file() const {
-	TreeItem *ti = stack_dump->get_selected();
-	if (!ti) {
+	if (script_frame_info.is_empty()) {
 		return "";
 	}
-	Dictionary d = ti->get_metadata(0);
-	return d["file"];
+	return script_frame_info["file"];
 }
 
 int ScriptEditorDebugger::get_stack_script_line() const {
-	TreeItem *ti = stack_dump->get_selected();
-	if (!ti) {
+	if (script_frame_info.is_empty()) {
 		return -1;
 	}
-	Dictionary d = ti->get_metadata(0);
-	return d["line"];
+	return script_frame_info["line"];
 }
 
 int ScriptEditorDebugger::get_stack_script_frame() const {
-	TreeItem *ti = stack_dump->get_selected();
-	if (!ti) {
+	if (!script_frame_info.is_empty()) {
 		return -1;
 	}
-	Dictionary d = ti->get_metadata(0);
-	return d["frame"];
+	return script_frame_info["frame"];
 }
 
-bool ScriptEditorDebugger::request_stack_dump(const int &p_frame) {
+bool ScriptEditorDebugger::request_stack_frame_variables(const int &p_frame) {
 	ERR_FAIL_COND_V(!is_session_active() || p_frame < 0, false);
 
+	// Request current thread's data by not specifying TID.
 	Array msg;
 	msg.push_back(p_frame);
-	_put_msg("get_stack_frame_vars", msg);
+	_put_msg(Channels::CHANNEL_OTHER, "get_stack_frame_vars", msg);
+	return true;
+}
+
+bool ScriptEditorDebugger::request_stack_frame_variables(const DebugThreadID &p_thread_id, const int &p_frame) {
+	ERR_FAIL_COND_V(!is_session_active() || p_frame < 0, false);
+
+	Array msg;
+	msg.push_back(p_frame);
+	msg.push_back(p_thread_id);
+	_put_msg(Channels::CHANNEL_OTHER, "get_stack_frame_vars", msg);
 	return true;
 }
 
@@ -1266,7 +1424,7 @@ void ScriptEditorDebugger::update_live_edit_root() {
 	} else {
 		msg.push_back("");
 	}
-	_put_msg("scene:live_set_root", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_set_root", msg);
 	live_edit_root->set_text(np);
 }
 
@@ -1276,7 +1434,7 @@ void ScriptEditorDebugger::live_debug_create_node(const NodePath &p_parent, cons
 		msg.push_back(p_parent);
 		msg.push_back(p_type);
 		msg.push_back(p_name);
-		_put_msg("scene:live_create_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_create_node", msg);
 	}
 }
 
@@ -1286,7 +1444,7 @@ void ScriptEditorDebugger::live_debug_instance_node(const NodePath &p_parent, co
 		msg.push_back(p_parent);
 		msg.push_back(p_path);
 		msg.push_back(p_name);
-		_put_msg("scene:live_instance_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_instance_node", msg);
 	}
 }
 
@@ -1294,7 +1452,7 @@ void ScriptEditorDebugger::live_debug_remove_node(const NodePath &p_at) {
 	if (live_debug) {
 		Array msg;
 		msg.push_back(p_at);
-		_put_msg("scene:live_remove_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_remove_node", msg);
 	}
 }
 
@@ -1303,7 +1461,7 @@ void ScriptEditorDebugger::live_debug_remove_and_keep_node(const NodePath &p_at,
 		Array msg;
 		msg.push_back(p_at);
 		msg.push_back(p_keep_id);
-		_put_msg("scene:live_remove_and_keep_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_remove_and_keep_node", msg);
 	}
 }
 
@@ -1313,7 +1471,7 @@ void ScriptEditorDebugger::live_debug_restore_node(ObjectID p_id, const NodePath
 		msg.push_back(p_id);
 		msg.push_back(p_at);
 		msg.push_back(p_at_pos);
-		_put_msg("scene:live_restore_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_restore_node", msg);
 	}
 }
 
@@ -1322,7 +1480,7 @@ void ScriptEditorDebugger::live_debug_duplicate_node(const NodePath &p_at, const
 		Array msg;
 		msg.push_back(p_at);
 		msg.push_back(p_new_name);
-		_put_msg("scene:live_duplicate_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_duplicate_node", msg);
 	}
 }
 
@@ -1333,7 +1491,7 @@ void ScriptEditorDebugger::live_debug_reparent_node(const NodePath &p_at, const
 		msg.push_back(p_new_place);
 		msg.push_back(p_new_name);
 		msg.push_back(p_at_pos);
-		_put_msg("scene:live_reparent_node", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:live_reparent_node", msg);
 	}
 }
 
@@ -1345,19 +1503,19 @@ void ScriptEditorDebugger::set_camera_override(CameraOverride p_override) {
 	if (p_override == CameraOverride::OVERRIDE_2D && camera_override != CameraOverride::OVERRIDE_2D) {
 		Array msg;
 		msg.push_back(true);
-		_put_msg("scene:override_camera_2D:set", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_2D:set", msg);
 	} else if (p_override != CameraOverride::OVERRIDE_2D && camera_override == CameraOverride::OVERRIDE_2D) {
 		Array msg;
 		msg.push_back(false);
-		_put_msg("scene:override_camera_2D:set", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_2D:set", msg);
 	} else if (p_override >= CameraOverride::OVERRIDE_3D_1 && camera_override < CameraOverride::OVERRIDE_3D_1) {
 		Array msg;
 		msg.push_back(true);
-		_put_msg("scene:override_camera_3D:set", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_3D:set", msg);
 	} else if (p_override < CameraOverride::OVERRIDE_3D_1 && camera_override >= CameraOverride::OVERRIDE_3D_1) {
 		Array msg;
 		msg.push_back(false);
-		_put_msg("scene:override_camera_3D:set", msg);
+		_put_msg(Channels::CHANNEL_MAIN_THREAD, "scene:override_camera_3D:set", msg);
 	}
 
 	camera_override = p_override;
@@ -1368,7 +1526,7 @@ void ScriptEditorDebugger::set_breakpoint(const String &p_path, int p_line, bool
 	msg.push_back(p_path);
 	msg.push_back(p_line);
 	msg.push_back(p_enabled);
-	_put_msg("breakpoint", msg);
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "breakpoint", msg);
 
 	TreeItem *path_item = breakpoints_tree->search_item_text(p_path);
 	if (path_item == nullptr) {
@@ -1411,7 +1569,7 @@ void ScriptEditorDebugger::set_breakpoint(const String &p_path, int p_line, bool
 }
 
 void ScriptEditorDebugger::reload_scripts() {
-	_put_msg("reload_scripts", Array());
+	_put_msg(Channels::CHANNEL_MAIN_THREAD, "reload_scripts", Array());
 }
 
 bool ScriptEditorDebugger::is_skip_breakpoints() {
@@ -1608,6 +1766,7 @@ void ScriptEditorDebugger::_tab_changed(int p_tab) {
 }
 
 void ScriptEditorDebugger::_bind_methods() {
+	// FIXME remove these and replace with callables where used.
 	ClassDB::bind_method(D_METHOD("live_debug_create_node"), &ScriptEditorDebugger::live_debug_create_node);
 	ClassDB::bind_method(D_METHOD("live_debug_instance_node"), &ScriptEditorDebugger::live_debug_instance_node);
 	ClassDB::bind_method(D_METHOD("live_debug_remove_node"), &ScriptEditorDebugger::live_debug_remove_node);
@@ -1621,7 +1780,7 @@ void ScriptEditorDebugger::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("started"));
 	ADD_SIGNAL(MethodInfo("stopped"));
 	ADD_SIGNAL(MethodInfo("stop_requested"));
-	ADD_SIGNAL(MethodInfo("stack_frame_selected", PropertyInfo(Variant::INT, "frame")));
+	ADD_SIGNAL(MethodInfo("stack_frame_selected"));
 	ADD_SIGNAL(MethodInfo("error_selected", PropertyInfo(Variant::INT, "error")));
 	ADD_SIGNAL(MethodInfo("breakpoint_selected", PropertyInfo("script"), PropertyInfo(Variant::INT, "line")));
 	ADD_SIGNAL(MethodInfo("set_execution", PropertyInfo("script"), PropertyInfo(Variant::INT, "line")));
@@ -1632,13 +1791,48 @@ void ScriptEditorDebugger::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("remote_object_property_updated", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::STRING, "property")));
 	ADD_SIGNAL(MethodInfo("remote_tree_updated"));
 	ADD_SIGNAL(MethodInfo("output"));
+
+	// FIXME Legacy signals to be removed once DAP is thread-aware.
 	ADD_SIGNAL(MethodInfo("stack_dump", PropertyInfo(Variant::ARRAY, "stack_dump")));
 	ADD_SIGNAL(MethodInfo("stack_frame_vars", PropertyInfo(Variant::INT, "num_vars")));
 	ADD_SIGNAL(MethodInfo("stack_frame_var", PropertyInfo(Variant::ARRAY, "data")));
+
 	ADD_SIGNAL(MethodInfo("debug_data", PropertyInfo(Variant::STRING, "msg"), PropertyInfo(Variant::ARRAY, "data")));
 	ADD_SIGNAL(MethodInfo("set_breakpoint", PropertyInfo("script"), PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::BOOL, "enabled")));
 	ADD_SIGNAL(MethodInfo("clear_breakpoints"));
 	ADD_SIGNAL(MethodInfo("errors_cleared"));
+
+	// Signals that potentially introduce new threads.
+	ADD_SIGNAL(MethodInfo("thread_breaked",
+			PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"),
+			PropertyInfo(Variant::BOOL, "is_main_thread"),
+			PropertyInfo(Variant::STRING, "reason"),
+			PropertyInfo(Variant::INT, "severity_code"),
+			PropertyInfo(Variant::BOOL, "can_debug")));
+	ADD_SIGNAL(MethodInfo("thread_paused",
+			PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"),
+			PropertyInfo(Variant::BOOL, "is_main_thread")));
+	ADD_SIGNAL(MethodInfo("thread_alert",
+			PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"),
+			PropertyInfo(Variant::BOOL, "is_main_thread"),
+			PropertyInfo(Variant::STRING, "reason"),
+			PropertyInfo(Variant::INT, "severity_code"),
+			PropertyInfo(Variant::BOOL, "can_debug"),
+			PropertyInfo(Variant::BOOL, "has_stack_dump")));
+
+	// Signals referring to threads already known.
+	ADD_SIGNAL(MethodInfo("thread_continued", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id")));
+	ADD_SIGNAL(MethodInfo("thread_exited", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id")));
+	ADD_SIGNAL(MethodInfo("thread_stack_dump", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"), PropertyInfo(Variant::ARRAY, "stack_dump")));
+	ADD_SIGNAL(MethodInfo("thread_stack_frame_vars", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"), PropertyInfo(Variant::INT, "num_vars")));
+	ADD_SIGNAL(MethodInfo("thread_stack_frame_var", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"), PropertyInfo(Variant::ARRAY, "data")));
+	ADD_SIGNAL(MethodInfo("thread_info",
+			PropertyInfo(Variant::PACKED_BYTE_ARRAY, "debug_thread_id"),
+			PropertyInfo(Variant::STRING, "language"),
+			// Debug thread contexts that have the same value here are from the same thread, but for different language.
+			// This is not guaranteed to be a real OS thread ID (even though it will be for core languages.)
+			PropertyInfo(Variant::PACKED_BYTE_ARRAY, "thread_tag"),
+			PropertyInfo(Variant::STRING, "name")));
 }
 
 void ScriptEditorDebugger::add_debugger_plugin(const Ref<Script> &p_script) {
@@ -1660,8 +1854,31 @@ void ScriptEditorDebugger::remove_debugger_plugin(const Ref<Script> &p_script) {
 	}
 }
 
-void ScriptEditorDebugger::send_message(const String &p_message, const Array &p_args) {
-	_put_msg(p_message, p_args);
+void ScriptEditorDebugger::send_message(int p_channel, const String &p_message, const Array &p_args) {
+	_put_msg(p_channel, p_message, p_args);
+}
+
+static const HashSet<String> s_thread_safe_messages = [] {
+	HashSet<String> temp;
+	for (const String &value : {
+				 "thread",
+				 "step",
+				 "next",
+				 "continue",
+				 "break",
+				 "get_stack_dump",
+				 "get_stack_frame_vars" }) {
+		temp.insert(value);
+	}
+	return temp;
+}();
+
+void ScriptEditorDebugger::send_message_auto(const String &p_message, const Array &p_args) {
+	int channel = Channels::CHANNEL_MAIN_THREAD;
+	if (s_thread_safe_messages.has(p_message)) {
+		channel = Channels::CHANNEL_OTHER;
+	}
+	send_message(channel, p_message, p_args);
 }
 
 void ScriptEditorDebugger::register_message_capture(const StringName &p_name, const Callable &p_callable) {
@@ -1678,14 +1895,38 @@ bool ScriptEditorDebugger::has_capture(const StringName &p_name) {
 	return captures.has(p_name);
 }
 
+void ScriptEditorDebugger::_build_thread_list(Node *parent) {
+	stack_dump = memnew(editor::dbg::sd::StackDump);
+	Node *thread_list_view = stack_dump->detach_thread_list_view();
+	Error ret = thread_list_view->connect("thread_frame_selected", callable_mp(this, &ScriptEditorDebugger::_thread_frame_selected));
+	if (ret != OK) {
+		ERR_PRINT("Failed to connect required debugger signal 'thread_frame_selected'; please report broken implementation.");
+		// Survivable failure, still put the view in the tree because we own it now.
+	}
+	ret = thread_list_view->connect("thread_nodebug_frame_selected", callable_mp(this, &ScriptEditorDebugger::_thread_nodebug_frame_selected));
+	if (ret != OK) {
+		ERR_PRINT("Failed to connect required debugger signal 'thread_nodebug_frame_selected'; please report broken implementation.");
+		// Survivable failure, still put the view in the tree because we own it now.
+	}
+	parent->add_child(thread_list_view);
+}
+
 ScriptEditorDebugger::ScriptEditorDebugger() {
+	live_debug = true;
+	camera_override = CameraOverride::OVERRIDE_NONE;
+	last_path_id = false;
+	error_count = 0;
+	warning_count = 0;
+
+	// REVISIT: All this construction should be deferred to PostInitialize so that signal maps and class
+	// information are ready, but the rest of the Editor currently assumes all these are ready after this constructor returns.
 	tabs = memnew(TabContainer);
 	tabs->add_theme_style_override("panel", EditorNode::get_singleton()->get_gui_base()->get_theme_stylebox(SNAME("DebuggerPanel"), SNAME("EditorStyles")));
 	tabs->connect("tab_changed", callable_mp(this, &ScriptEditorDebugger::_tab_changed));
 
 	add_child(tabs);
 
-	{ //debugger
+	{ // debugger
 		VBoxContainer *vbc = memnew(VBoxContainer);
 		vbc->set_name(TTR("Debugger"));
 		Control *dbg = vbc;
@@ -1759,15 +2000,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 		sc->set_h_size_flags(SIZE_EXPAND_FILL);
 		parent_sc->add_child(sc);
 
-		stack_dump = memnew(Tree);
-		stack_dump->set_allow_reselect(true);
-		stack_dump->set_columns(1);
-		stack_dump->set_column_titles_visible(true);
-		stack_dump->set_column_title(0, TTR("Stack Frames"));
-		stack_dump->set_h_size_flags(SIZE_EXPAND_FILL);
-		stack_dump->set_hide_root(true);
-		stack_dump->connect("cell_selected", callable_mp(this, &ScriptEditorDebugger::_stack_dump_frame_selected));
-		sc->add_child(stack_dump);
+		_build_thread_list(sc);
 
 		VBoxContainer *inspector_vbox = memnew(VBoxContainer);
 		inspector_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
@@ -1812,7 +2045,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 		breakpoints_tree->add_child(breakpoints_menu);
 	}
 
-	{ //errors
+	{ // errors
 		errors_tab = memnew(VBoxContainer);
 		errors_tab->set_name(TTR("Errors"));
 
@@ -1872,7 +2105,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 		add_child(file_dialog);
 	}
 
-	{ //profiler
+	{ // profiler
 		profiler = memnew(EditorProfiler);
 		profiler->set_name(TTR("Profiler"));
 		tabs->add_child(profiler);
@@ -1880,26 +2113,26 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 		profiler->connect("break_request", callable_mp(this, &ScriptEditorDebugger::_profiler_seeked));
 	}
 
-	{ //frame profiler
+	{ // frame profiler
 		visual_profiler = memnew(EditorVisualProfiler);
 		visual_profiler->set_name(TTR("Visual Profiler"));
 		tabs->add_child(visual_profiler);
 		visual_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate).bind(PROFILER_VISUAL));
 	}
 
-	{ //network profiler
+	{ // network profiler
 		network_profiler = memnew(EditorNetworkProfiler);
 		network_profiler->set_name(TTR("Network Profiler"));
 		tabs->add_child(network_profiler);
 		network_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate).bind(PROFILER_NETWORK));
 	}
 
-	{ //monitors
+	{ // monitors
 		performance_profiler = memnew(EditorPerformanceProfiler);
 		tabs->add_child(performance_profiler);
 	}
 
-	{ //vmem inspect
+	{ // vmem inspect
 		VBoxContainer *vmem_vb = memnew(VBoxContainer);
 		HBoxContainer *vmem_hb = memnew(HBoxContainer);
 		Label *vmlb = memnew(Label(TTR("List of Video Memory Usage by Resource:") + " "));
@@ -1999,11 +2232,6 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 	msgdialog = memnew(AcceptDialog);
 	add_child(msgdialog);
 
-	live_debug = true;
-	camera_override = CameraOverride::OVERRIDE_NONE;
-	last_path_id = false;
-	error_count = 0;
-	warning_count = 0;
 	_update_buttons_state();
 }
 
@@ -2013,4 +2241,8 @@ ScriptEditorDebugger::~ScriptEditorDebugger() {
 		peer.unref();
 	}
 	memdelete(scene_tree);
+	if (stack_dump != nullptr) {
+		memdelete(stack_dump);
+		stack_dump = nullptr;
+	}
 }
diff --git a/editor/debugger/script_editor_debugger.h b/editor/debugger/script_editor_debugger.h
index aa0a50ff03f5..40c900c87eae 100644
--- a/editor/debugger/script_editor_debugger.h
+++ b/editor/debugger/script_editor_debugger.h
@@ -35,6 +35,7 @@
 #include "editor/debugger/editor_debugger_inspector.h"
 #include "editor/debugger/editor_debugger_node.h"
 #include "editor/debugger/editor_debugger_server.h"
+#include "editor_profiler.h"
 #include "scene/gui/button.h"
 #include "scene/gui/margin_container.h"
 
@@ -57,6 +58,10 @@ class EditorDebuggerPlugin;
 class DebugAdapterProtocol;
 class DebugAdapterParser;
 
+namespace editor::dbg::sd {
+class StackDump;
+}
+
 class ScriptEditorDebugger : public MarginContainer {
 	GDCLASS(ScriptEditorDebugger, MarginContainer);
 
@@ -64,7 +69,9 @@ class ScriptEditorDebugger : public MarginContainer {
 	friend class DebugAdapterProtocol;
 	friend class DebugAdapterParser;
 
-private:
+public:
+	typedef ScriptLanguageThreadContext::DebugThreadID DebugThreadID;
+
 	enum MessageType {
 		MESSAGE_ERROR,
 		MESSAGE_WARNING,
@@ -105,11 +112,13 @@ class ScriptEditorDebugger : public MarginContainer {
 	PopupMenu *breakpoints_menu = nullptr;
 
 	EditorFileDialog *file_dialog = nullptr;
+
 	enum FileDialogPurpose {
 		SAVE_MONITORS_CSV,
 		SAVE_VRAM_CSV,
 	};
-	FileDialogPurpose file_dialog_purpose;
+
+	FileDialogPurpose file_dialog_purpose = SAVE_MONITORS_CSV;
 
 	int error_count;
 	int warning_count;
@@ -138,10 +147,10 @@ class ScriptEditorDebugger : public MarginContainer {
 	Button *vmem_export = nullptr;
 	LineEdit *vmem_total = nullptr;
 
-	Tree *stack_dump = nullptr;
 	LineEdit *search = nullptr;
 	EditorDebuggerInspector *inspector = nullptr;
 	SceneDebuggerTree *scene_tree = nullptr;
+	editor::dbg::sd::StackDump *stack_dump = nullptr;
 
 	Ref<RemoteDebuggerPeer> peer;
 
@@ -156,6 +165,7 @@ class ScriptEditorDebugger : public MarginContainer {
 
 	OS::ProcessID remote_pid = 0;
 	bool breaked = false;
+	DebugThreadID focused_thread;
 	bool can_debug = false;
 	bool move_to_foreground = true;
 
@@ -167,15 +177,19 @@ class ScriptEditorDebugger : public MarginContainer {
 
 	HashMap<StringName, Callable> captures;
 
-	void _stack_dump_frame_selected();
+	Dictionary script_frame_info;
+
+	void _thread_frame_selected(const PackedByteArray &p_thread_id, int p_frame, const Dictionary &p_frame_info);
+	void _thread_nodebug_frame_selected(const PackedByteArray &p_thread_id, int p_frame, const Dictionary &p_frame_info);
 
 	void _file_selected(const String &p_file);
+	static bool _validate_message(const String &p_name, Array p_data, std::initializer_list<Variant::Type> p_types, Vector<const Variant *> *p_out_validated = nullptr, bool p_allow_extra_data = true);
 	void _parse_message(const String &p_msg, const Array &p_data);
 	void _set_reason_text(const String &p_reason, MessageType p_type);
 	void _update_buttons_state();
-	void _remote_object_selected(ObjectID p_object);
+	void _remote_object_selected(ObjectID p_obj_id);
 	void _remote_object_edited(ObjectID, const String &p_prop, const Variant &p_value);
-	void _remote_object_property_updated(ObjectID p_id, const String &p_property);
+	void _remote_object_property_updated(ObjectID p_obj_id, const String &p_property);
 
 	void _video_mem_request();
 	void _video_mem_export();
@@ -206,7 +220,7 @@ class ScriptEditorDebugger : public MarginContainer {
 	void _item_menu_id_pressed(int p_option);
 	void _tab_changed(int p_tab);
 
-	void _put_msg(String p_message, Array p_data);
+	void _put_msg(int p_channel, String p_message, Array p_data);
 	void _export_csv();
 
 	void _clear_execution();
@@ -219,12 +233,13 @@ class ScriptEditorDebugger : public MarginContainer {
 
 protected:
 	void _notification(int p_what);
+
 	static void _bind_methods();
 
 public:
 	void request_remote_object(ObjectID p_obj_id);
 	void update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value);
-	Object *get_remote_object(ObjectID p_id);
+	Object *get_remote_object(ObjectID p_obj_id);
 
 	// Needed by _live_edit_set, buttons state.
 	void set_editor_remote_tree(const Tree *p_tree) { editor_remote_tree = p_tree; }
@@ -256,7 +271,10 @@ class ScriptEditorDebugger : public MarginContainer {
 	int get_stack_script_line() const;
 	int get_stack_script_frame() const;
 
-	bool request_stack_dump(const int &p_frame);
+	// FIXME Legacy function that always requests main thread info.  Remove once DAP is thread-aware.
+	bool request_stack_frame_variables(const int &p_frame);
+	bool request_stack_frame_variables(const DebugThreadID &p_thread_id, const int &p_frame);
+	void request_stack_dump(const Variant &p_tid);
 
 	void update_tabs();
 	void clear_style();
@@ -286,14 +304,30 @@ class ScriptEditorDebugger : public MarginContainer {
 
 	virtual Size2 get_minimum_size() const override;
 
+	void _handle_debug_enter(const Array &p_data, DebugThreadID *p_tid = nullptr, bool p_is_main = true, int p_severity_code = 1);
+	void _handle_debug_exit(DebugThreadID *p_tid = nullptr);
+	void _handle_servers_memory_usage(const Array &p_data) const;
+	void _handle_stack_dump(const Array &p_data);
+	void _handle_stack_frame_vars(const Array &p_data);
+	void _handle_output(const Array &p_data);
+	void _handle_peformance_profile_frame(const Array &p_data) const;
+	void _handle_visual_profile_frame(const Array &p_data) const;
+	void _handle_error(const Array &p_data);
+	void _handle_servers_function_signature(const Array &p_data);
+	void _handle_servers_profile_requests(const Array &p_data, EditorProfiler::Metric &metric);
+
 	void add_debugger_plugin(const Ref<Script> &p_script);
 	void remove_debugger_plugin(const Ref<Script> &p_script);
 
-	void send_message(const String &p_message, const Array &p_args);
+	void send_message(int p_channel, const String &p_message, const Array &p_args);
+
+	// Version of send_message(p_channel) for clients that don't know which messages go in which channel.
+	void send_message_auto(const String &p_message, const Array &p_args);
 
 	void register_message_capture(const StringName &p_name, const Callable &p_callable);
 	void unregister_message_capture(const StringName &p_name);
 	bool has_capture(const StringName &p_name);
+	void _build_thread_list(Node *parent);
 
 	ScriptEditorDebugger();
 	~ScriptEditorDebugger();
diff --git a/editor/debugger/stack_dump/SCsub b/editor/debugger/stack_dump/SCsub
new file mode 100644
index 000000000000..359d04e5df2a
--- /dev/null
+++ b/editor/debugger/stack_dump/SCsub
@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env.add_source_files(env.editor_sources, "*.cpp")
diff --git a/editor/debugger/stack_dump/stack_dump.cpp b/editor/debugger/stack_dump/stack_dump.cpp
new file mode 100644
index 000000000000..8d820cee1cd5
--- /dev/null
+++ b/editor/debugger/stack_dump/stack_dump.cpp
@@ -0,0 +1,73 @@
+/*************************************************************************/
+/*  stack_dump.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "stack_dump.h"
+
+#include "thread_list.h"
+#include "thread_list_tree.h"
+
+namespace editor::dbg::sd {
+
+Error StackDump::connect(Object &p_debugger) const {
+	Error ret = _thread_list->connect(p_debugger);
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signals debugger");
+
+	return OK;
+}
+
+void StackDump::disconnect(Object &p_debugger) const {
+	_thread_list->disconnect(p_debugger);
+}
+
+Node *StackDump::detach_thread_list_view() {
+	Node *result = _thread_list_view;
+	// Ownership transfer to Scene tree.
+	_thread_list_view = nullptr;
+	return result;
+}
+
+StackDump::StackDump() {
+	_thread_list = memnew(ThreadList);
+	_thread_list_view = memnew(View);
+	_thread_list->set_view(_thread_list_view);
+}
+
+StackDump::~StackDump() {
+	if (_thread_list != nullptr) {
+		memdelete(_thread_list);
+		_thread_list = nullptr;
+	}
+	if (_thread_list_view != nullptr) {
+		memdelete(_thread_list_view);
+		_thread_list_view = nullptr;
+	}
+}
+
+} // namespace editor::dbg::sd
diff --git a/editor/debugger/stack_dump/stack_dump.h b/editor/debugger/stack_dump/stack_dump.h
new file mode 100644
index 000000000000..9aa1805b7fcd
--- /dev/null
+++ b/editor/debugger/stack_dump/stack_dump.h
@@ -0,0 +1,58 @@
+/*************************************************************************/
+/*  stack_dump.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef STACK_DUMP_H
+#define STACK_DUMP_H
+
+#include "core/error/error_list.h"
+#include "scene/main/node.h"
+
+namespace editor::dbg::sd {
+
+class View;
+class ThreadList;
+
+class StackDump {
+	ThreadList *_thread_list = nullptr;
+	View *_thread_list_view = nullptr;
+
+public:
+	Error connect(Object &p_debugger) const;
+	void disconnect(Object &p_debugger) const;
+
+	Node *detach_thread_list_view();
+
+	StackDump();
+	~StackDump();
+};
+
+} // namespace editor::dbg::sd
+
+#endif // STACK_DUMP_H
diff --git a/editor/debugger/stack_dump/thread_info.cpp b/editor/debugger/stack_dump/thread_info.cpp
new file mode 100644
index 000000000000..14ab40f6d50c
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_info.cpp
@@ -0,0 +1,71 @@
+/*************************************************************************/
+/*  thread_info.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "thread_info.h"
+
+#include "scene/gui/tree.h"
+
+namespace editor::dbg::sd {
+
+const ThreadInfo::DebugThreadID &ThreadInfo::get_debug_thread_id() const {
+	return debug_thread_id;
+}
+
+const String &ThreadInfo::get_debug_thread_id_hex() const {
+	// Lazy update the hex string and cache it.
+	if (debug_thread_id.size() > 0) {
+		if (debug_thread_id_hex.size() < 1) {
+			debug_thread_id_hex = String::hex_encode_buffer(debug_thread_id.ptr(), debug_thread_id.size());
+		}
+	} else {
+		if (debug_thread_id_hex.size() > 0) {
+			debug_thread_id_hex.clear();
+		}
+	}
+	return debug_thread_id_hex;
+}
+
+void ThreadInfo::free_tree_item() {
+	if (nullptr == tree_item) {
+		return;
+	}
+	memdelete(tree_item);
+	tree_item = nullptr;
+}
+
+ThreadInfo::ThreadInfo(int p_thread_number, const DebugThreadID &p_debug_thread_id, bool p_is_main_thread) {
+	thread_number = p_thread_number;
+	debug_thread_id = p_debug_thread_id;
+	is_main_thread = p_is_main_thread;
+}
+
+ThreadInfo::~ThreadInfo() = default;
+
+} // namespace editor::dbg::sd
diff --git a/editor/debugger/stack_dump/thread_info.h b/editor/debugger/stack_dump/thread_info.h
new file mode 100644
index 000000000000..40ec7424ee52
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_info.h
@@ -0,0 +1,127 @@
+/*************************************************************************/
+/*  thread_info.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef THREAD_INFO_H
+#define THREAD_INFO_H
+
+#include "core/object/ref_counted.h"
+#include "core/variant/typed_array.h"
+
+class TreeItem;
+
+/**
+ * \brief Godot Editor / IDE
+ */
+namespace editor {
+/**
+ * \brief Editor / IDE side of Debugger Functionality
+ */
+namespace dbg {
+/**
+ * \brief Stack Dump Debugger Functionality
+ */
+namespace sd {
+
+// Received information about a thread.  Used like a struct with public data, but
+// declared as class to get ref counting.
+class ThreadInfo : public RefCounted {
+	GDCLASS(ThreadInfo, RefCounted)
+
+public:
+	using DebugThreadID = PackedByteArray;
+
+private:
+	DebugThreadID debug_thread_id;
+	mutable String debug_thread_id_hex;
+
+public:
+	enum class Status : int {
+		BLOCKED = 0,
+		RUNNING,
+		PAUSED,
+		ALERT,
+		BREAKPOINT,
+		CRASHED,
+		DEAD,
+		NUM_VALUES
+	};
+
+	// Supported column IDs for sorting the data or for display, not the same as currently visible column indices.
+	// WARNING: Also used as integer indices for array access, so must be consecutive.
+	enum class Field : int {
+		STATUS = 0,
+		ID,
+		NAME,
+		STACK,
+		LANGUAGE,
+		CATEGORY,
+		DEBUG_ID,
+		NUM_VALUES
+	};
+
+	struct Hasher {
+		static uint32_t hash(const PackedByteArray &p_buffer) {
+			// This is the same hasher selection as Variant uses for PackedByteArray.
+			if (likely(p_buffer.size() > 0)) {
+				return hash_murmur3_buffer(p_buffer.ptr(), p_buffer.size());
+			}
+			return hash_murmur3_one_64(0);
+		}
+	};
+
+	// Link to view, could be separated to appropriate class, but would require another lookup.
+	TreeItem *tree_item = nullptr;
+
+	// Aggregated data
+	int thread_number;
+	const DebugThreadID &get_debug_thread_id() const;
+	const String &get_debug_thread_id_hex() const;
+	bool is_main_thread = false;
+	String reason;
+	Status status = Status::RUNNING;
+	int severity_code = 0;
+	bool can_debug = false;
+	bool has_stack_dump = false;
+	String language;
+	PackedByteArray thread_tag;
+	String thread_name;
+	TypedArray<Dictionary> stack_dump_info;
+
+	void free_tree_item();
+
+	ThreadInfo(int p_thread_number, const DebugThreadID &p_debug_thread_id, bool p_is_main_thread);
+	~ThreadInfo();
+};
+
+} // namespace sd
+} // namespace dbg
+} // namespace editor
+
+#endif // THREAD_INFO_H
diff --git a/editor/debugger/stack_dump/thread_list.cpp b/editor/debugger/stack_dump/thread_list.cpp
new file mode 100644
index 000000000000..a8d759be219f
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_list.cpp
@@ -0,0 +1,415 @@
+/*************************************************************************/
+/*  thread_list.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "thread_list.h"
+#include "thread_info.h"
+#include "thread_list_tree.h"
+
+#include "core/object/callable_method_pointer.h"
+#include "core/object/script_language.h"
+
+namespace editor::dbg::sd {
+
+//
+// Implementation notes common to all these functions:
+//
+// These functions repeatedly check if _threads.has(key) because code that interacts with UI may erroneously process
+// events late because someone inserts a call_deferred() somewhere.  When these late calls can be safely ignored, they
+// are.
+//
+// These functions do not optimize the double lookups into _threads (HashMap::has, HashMap::operator[]) by using HashMap::get_ptr() because
+// that would make the code less clean, by introducing more nullable pointers.  Optimization of lookups that happen at GUI
+// interaction speed is not a goal of this code.
+//
+
+void ThreadList::_update_placeholder_main(bool p_is_main_thread) {
+	if (!p_is_main_thread && _placeholder_main.is_null() && _threads.is_empty()) {
+		// Show a blocked main thread because we know it exists.
+		const DebugThreadID placeholder_thread_id = DebugThreadID();
+		Ref<ThreadInfo> thread = _create_thread_info(placeholder_thread_id, true);
+		thread->reason = "Main thread is blocked and unavailable for debugging";
+		thread->can_debug = false;
+		thread->severity_code = 0;
+		thread->status = Status::BLOCKED;
+		thread->thread_name = "Main (blocked)";
+		_placeholder_main = thread;
+		_threads[placeholder_thread_id] = thread;
+		if (_view != nullptr) {
+			_view->add_row(thread);
+		}
+		return;
+	}
+	if (p_is_main_thread && _placeholder_main.is_valid()) {
+		const DebugThreadID placeholder_thread_id = DebugThreadID();
+		_threads.erase(placeholder_thread_id);
+		// Self-removes from tree on delete.
+		_placeholder_main->free_tree_item();
+		_placeholder_main.unref();
+	}
+}
+
+void ThreadList::set_view(View *view) {
+	_view = view;
+	Error ret = _view->connect("tree_exiting", callable_mp(this, &ThreadList::_on_view_tree_exiting));
+	ERR_FAIL_COND_MSG(ret != OK, "failed to connect required signal 'tree_exiting' from Tree control");
+	ret = _view->connect("item_edited", callable_mp(this, &ThreadList::_on_view_item_edited));
+	ERR_FAIL_COND_MSG(ret != OK, "failed to connect required signal 'item_edited' from Tree control");
+	ret = _view->connect("sort_requested", callable_mp(this, &ThreadList::_on_view_sort_requested));
+	if (ret != OK) {
+		// This isn't strictly required.
+		WARN_PRINT("failed to connect signal 'sort_requested' from thread list view control");
+	}
+}
+
+void ThreadList::_on_view_item_edited() {
+	_sort_table();
+}
+
+void ThreadList::_on_view_sort_requested(int p_field_index) {
+	if (nullptr == _view) {
+		// Deferred late.
+		return;
+	}
+	_current_sort_field = _view->get_field(p_field_index);
+	_sort_table();
+}
+
+void ThreadList::clear_threads() {
+	for (KeyValue<DebugThreadID, Ref<ThreadInfo>> record : _threads) {
+		record.value->free_tree_item();
+	}
+	_threads.clear();
+	if (_placeholder_main.is_valid()) {
+		_placeholder_main->free_tree_item();
+		_placeholder_main.unref();
+	}
+}
+
+void ThreadList::_on_view_tree_exiting() {
+	if (nullptr == _view) {
+		// Deferred late.
+		return;
+	}
+
+	// About to be deallocated by Scene tree.
+	_view->disconnect("item_edited", callable_mp(this, &ThreadList::_on_view_item_edited));
+	_view->disconnect("tree_exiting", callable_mp(this, &ThreadList::_on_view_tree_exiting));
+	_view->disconnect("sort_requested", callable_mp(this, &ThreadList::_on_view_sort_requested));
+	_view = nullptr;
+}
+
+Ref<ThreadInfo> ThreadList::_create_thread_info(const DebugThreadID &p_debug_thread_id, bool p_is_main_thread) {
+	const int thread_number = p_is_main_thread ? _next_main_thread_number++ : _next_thread_number++;
+	return Ref<ThreadInfo>(memnew(ThreadInfo(thread_number, p_debug_thread_id, p_is_main_thread)));
+}
+
+bool ThreadList::thread_info_less_than(const ThreadInfo *const &p_left, const ThreadInfo *const &p_right) const {
+	if (_view != nullptr) {
+		if (_view->is_pin_column_visible()) {
+			// Pinned threads sort above all other ones.
+			const bool left_flag = _view->is_pinned(*p_left);
+			const bool right_flag = _view->is_pinned(*p_right);
+			if (right_flag && !left_flag) {
+				return false;
+			}
+			if (left_flag && !right_flag) {
+				return true;
+			}
+		}
+	}
+	switch (_current_sort_field) {
+		case Field::ID: {
+			if (p_left->thread_number == p_right->thread_number) {
+				break;
+			}
+			return (p_left->thread_number < p_right->thread_number);
+		}
+		case Field::NAME: {
+			// Sort empty last instead of first.
+			if (p_left->thread_name.size() < 1) {
+				if (p_right->thread_name.size() < 1) {
+					break;
+				}
+				return false;
+			}
+			if (p_right->thread_name.size() < 1) {
+				return true;
+			}
+			return (p_left->thread_name < p_right->thread_name);
+		}
+		case Field::LANGUAGE: {
+			// Sort empty last instead of first.
+			if (p_left->language.size() < 1) {
+				if (p_right->language.size() < 1) {
+					break;
+				}
+				return false;
+			}
+			if (p_right->language.size() < 1) {
+				return true;
+			}
+			return (p_left->language < p_right->language);
+		}
+		default:
+			break;
+	}
+	// Tie breaker on a unique value to keep view stable.
+	return (p_left->get_debug_thread_id_hex() < p_right->get_debug_thread_id_hex());
+}
+
+void ThreadList::_update_status_for_threads() {
+	if (nullptr == _view) {
+		return;
+	}
+	for (const KeyValue<DebugThreadID, Ref<ThreadInfo>> &record : _threads) {
+		_view->update_status(**record.value);
+	}
+}
+
+int ThreadList::_find_least_greater(const Ref<ThreadInfo> &p_thread) const {
+	// REVISIT: We are reaching into the view here, which is gross.  We should maintain the sorted list instead.
+	if (nullptr == _view) {
+		return -1;
+	}
+	int before_index = 0;
+	for (TreeItem *item = _view->get_root()->get_first_child(); item != nullptr; item = item->get_next()) {
+		Ref<ThreadInfo> existing = _view->get_meta_thread(*item);
+		if (thread_info_less_than(*p_thread, *existing)) {
+			// Found the first item that is greater.
+			break;
+		}
+		++before_index;
+	}
+	return before_index;
+}
+
+void ThreadList::_sort_table() {
+	if (nullptr == _view) {
+		return;
+	}
+
+	// Convert values to Array as shallow uncounted copy.
+	Vector<const ThreadInfo *> index;
+	index.resize(_threads.size());
+	int i = 0;
+	for (KeyValue<DebugThreadID, Ref<ThreadInfo>> &record : _threads) {
+		index.set(i, *record.value);
+		i++;
+	}
+
+	// Sort by current sort order.
+	index.sort_custom<CallableComparator, true>(callable_mp(this, &ThreadList::thread_info_less_than));
+
+	// Last one never needs to be moved.
+	index.resize(index.size() - 1);
+
+	// Shuffle subtree
+	bool first = true;
+	TreeItem *previous = _view->get_root()->get_first_child();
+	for (const ThreadInfo *const &thread : index) {
+		TreeItem *item = thread->tree_item;
+		if (first) {
+			// Special case first item; start the child list with it.
+			first = false;
+			if (item != previous) {
+				item->move_before(previous);
+			}
+		} else {
+			// Append every other item, except last one (see above.)
+			item->move_after(previous);
+		}
+		previous = item;
+	}
+}
+
+void ThreadList::_on_debugger_thread_breaked(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, int p_severity_code, bool p_can_debug) {
+	_update_placeholder_main(p_is_main_thread);
+	Ref<ThreadInfo> thread;
+	if (_threads.has(p_debug_thread_id)) {
+		thread = _threads[p_debug_thread_id];
+		thread->reason = p_reason;
+		if (thread->tree_item != nullptr) {
+			View::set_meta_stack(*thread->tree_item, Dictionary());
+		}
+	} else {
+		thread = _create_thread_info(p_debug_thread_id, p_is_main_thread);
+		thread->reason = p_reason;
+		_threads[p_debug_thread_id] = thread;
+		if (_view != nullptr) {
+			_view->add_row(thread, _find_least_greater(thread));
+		}
+	}
+	thread->can_debug = true;
+	thread->has_stack_dump = true;
+	thread->severity_code = p_severity_code;
+	thread->status = p_can_debug ? Status::BREAKPOINT : Status::CRASHED;
+	if (_view != nullptr) {
+		_view->set_current(**thread);
+		_update_status_for_threads();
+	}
+}
+
+void ThreadList::_update_or_create_thread(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, Status p_status, int p_severity_code, bool p_can_debug, bool p_has_stack_dump) {
+	_update_placeholder_main(p_is_main_thread);
+	Ref<ThreadInfo> thread;
+	if (_threads.has(p_debug_thread_id)) {
+		thread = _threads[p_debug_thread_id];
+		thread->reason = p_reason;
+	} else {
+		thread = _create_thread_info(p_debug_thread_id, p_is_main_thread);
+		thread->reason = p_reason;
+		_threads[p_debug_thread_id] = thread;
+		if (_view != nullptr) {
+			_view->add_row(thread, _find_least_greater(thread));
+		}
+	}
+	thread->can_debug = p_can_debug;
+	thread->has_stack_dump = p_has_stack_dump;
+	thread->severity_code = p_severity_code;
+	thread->status = p_status;
+	if (_view != nullptr) {
+		_view->update_status(**thread);
+	}
+}
+
+void ThreadList::_on_debugger_thread_paused(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread) {
+	_update_or_create_thread(p_debug_thread_id, p_is_main_thread, "", Status::PAUSED, 0, true, true);
+}
+
+void ThreadList::_on_debugger_thread_alert(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, int p_severity_code, bool p_can_debug, bool p_has_stack_dump) {
+	_update_or_create_thread(p_debug_thread_id, p_is_main_thread, p_reason, p_can_debug ? Status::ALERT : Status::CRASHED, p_severity_code, p_can_debug, p_has_stack_dump);
+}
+
+void ThreadList::_on_debugger_thread_continued(const PackedByteArray &p_debug_thread_id) {
+	if (!_threads.has(p_debug_thread_id)) {
+		// Deferred late or out of order.
+		return;
+	}
+
+	Ref<ThreadInfo> thread = _threads[p_debug_thread_id];
+	thread->can_debug = false;
+	thread->severity_code = 0;
+	thread->status = Status::RUNNING;
+	if (_view != nullptr) {
+		_view->update_status(**thread);
+	}
+}
+
+void ThreadList::_on_debugger_thread_info(const PackedByteArray &p_debug_thread_id, const String &p_language, const PackedByteArray &p_thread_tag, const String &p_thread_name) {
+	if (!_threads.has(p_debug_thread_id)) {
+		// Deferred late or out of order.
+		return;
+	}
+
+	Ref<ThreadInfo> thread = _threads[p_debug_thread_id];
+	thread->language = p_language;
+	thread->thread_tag = p_thread_tag;
+	thread->thread_name = p_thread_name;
+	if (_view != nullptr) {
+		_view->update_info(**thread);
+	}
+	switch (_current_sort_field) {
+		case Field::NAME:
+		case Field::LANGUAGE:
+			_sort_table();
+			break;
+		default:
+			break;
+	}
+}
+
+void ThreadList::_on_debugger_thread_stack_dump(const PackedByteArray &p_debug_thread_id, const TypedArray<Dictionary> &p_stack_dump_info) {
+	if (!_threads.has(p_debug_thread_id)) {
+		// Deferred late or out of order.
+		return;
+	}
+
+	Ref<ThreadInfo> thread = _threads[p_debug_thread_id];
+	thread->stack_dump_info = p_stack_dump_info;
+	if (_view != nullptr) {
+		_view->build_stack_dump(thread);
+	}
+}
+
+void ThreadList::_on_debugger_thread_exited(const PackedByteArray &p_debug_thread_id) {
+	if (!_threads.has(p_debug_thread_id)) {
+		// Deferred late or out of order.
+		return;
+	}
+
+	Ref<ThreadInfo> thread = _threads[p_debug_thread_id];
+	thread->free_tree_item();
+	_threads.erase(p_debug_thread_id);
+}
+
+void ThreadList::_on_debugger_clear_execution(const Ref<Script> &p_script) {
+	clear_threads();
+}
+
+Error ThreadList::connect(Object &debugger) {
+	Error ret = debugger.connect("thread_breaked", callable_mp(this, &ThreadList::_on_debugger_thread_breaked));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_breaked' from debugger");
+
+	ret = debugger.connect("thread_paused", callable_mp(this, &ThreadList::_on_debugger_thread_paused));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_paused' from debugger");
+
+	ret = debugger.connect("thread_alert", callable_mp(this, &ThreadList::_on_debugger_thread_alert));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_alert' from debugger");
+
+	ret = debugger.connect("thread_continued", callable_mp(this, &ThreadList::_on_debugger_thread_continued));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_continued' from debugger");
+
+	ret = debugger.connect("thread_exited", callable_mp(this, &ThreadList::_on_debugger_thread_exited));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_exited' from debugger");
+
+	ret = debugger.connect("thread_stack_dump", callable_mp(this, &ThreadList::_on_debugger_thread_stack_dump));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_stack_dump' from debugger");
+
+	ret = debugger.connect("thread_info", callable_mp(this, &ThreadList::_on_debugger_thread_info));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'thread_info' from debugger");
+
+	ret = debugger.connect("clear_execution", callable_mp(this, &ThreadList::_on_debugger_clear_execution));
+	ERR_FAIL_COND_V_MSG(ret != OK, ret, "failed to connect required signal 'clear_execution' from debugger");
+
+	return OK;
+}
+
+void ThreadList::disconnect(Object &debugger) {
+	debugger.disconnect("thread_breaked", callable_mp(this, &ThreadList::_on_debugger_thread_breaked));
+	debugger.disconnect("thread_paused", callable_mp(this, &ThreadList::_on_debugger_thread_paused));
+	debugger.disconnect("thread_alert", callable_mp(this, &ThreadList::_on_debugger_thread_alert));
+	debugger.disconnect("thread_continued", callable_mp(this, &ThreadList::_on_debugger_thread_continued));
+	debugger.disconnect("thread_exited", callable_mp(this, &ThreadList::_on_debugger_thread_exited));
+	debugger.disconnect("thread_stack_dump", callable_mp(this, &ThreadList::_on_debugger_thread_stack_dump));
+	debugger.disconnect("thread_info", callable_mp(this, &ThreadList::_on_debugger_thread_info));
+	debugger.disconnect("clear_execution", callable_mp(this, &ThreadList::_on_debugger_clear_execution));
+}
+
+} // namespace editor::dbg::sd
diff --git a/editor/debugger/stack_dump/thread_list.h b/editor/debugger/stack_dump/thread_list.h
new file mode 100644
index 000000000000..9603f7b313bf
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_list.h
@@ -0,0 +1,104 @@
+/*************************************************************************/
+/*  thread_list.h                                                        */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef THREAD_LIST_H
+#define THREAD_LIST_H
+
+#include "core/object/object.h"
+#include "thread_info.h"
+
+class Script;
+
+namespace editor::dbg::sd {
+
+class View;
+
+// Manages the thread information collection based on signals from the debugger.
+class ThreadList : public Object {
+	GDCLASS(ThreadList, Object)
+	using Status = ThreadInfo::Status;
+	using DebugThreadID = ThreadInfo::DebugThreadID;
+
+	// The GUI view for this data.
+	// REVISIT: replace with signals only.
+	View *_view = nullptr;
+	void _on_view_tree_exiting();
+
+	// Main table of threads.
+	HashMap<ThreadInfo::DebugThreadID, Ref<ThreadInfo>, ThreadInfo::Hasher> _threads;
+
+	// A synthetic record shown when main's state is not known.
+	Ref<ThreadInfo> _placeholder_main;
+
+	// Running counters to give friendly ID numbers to main/worker thread contexts, respectively.
+	// Note there will be more than one numbered context for the same OS thread if multiple languages are used.
+	int _next_main_thread_number = 1;
+	int _next_thread_number = 100;
+
+	using Field = ThreadInfo::Field;
+	Field _current_sort_field = Field::DEBUG_ID;
+
+	Ref<ThreadInfo> _create_thread_info(const DebugThreadID &p_debug_thread_id, bool p_is_main_thread);
+
+	// Custom sorting based on current sort key.
+	bool thread_info_less_than(const ThreadInfo *const &p_left, const ThreadInfo *const &p_right) const;
+
+	void _sort_table();
+	void _update_placeholder_main(bool p_is_main_thread);
+	void _update_or_create_thread(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, Status p_status, int p_severity_code, bool p_can_debug, bool p_has_stack_dump);
+	void _update_status_for_threads();
+	int _find_least_greater(const Ref<ThreadInfo> &p_thread) const;
+
+	// Warning: The signals that call these are defined as PackedByteArray, even if DebugThreadID ends up being something else, so we don't use that type here.
+	void _on_debugger_thread_breaked(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, int p_severity_code, bool p_can_debug);
+	void _on_debugger_thread_paused(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread);
+	void _on_debugger_thread_alert(const PackedByteArray &p_debug_thread_id, bool p_is_main_thread, const String &p_reason, int p_severity_code, bool p_can_debug, bool p_has_stack_dump);
+	void _on_debugger_thread_continued(const PackedByteArray &p_debug_thread_id);
+	void _on_debugger_thread_info(const PackedByteArray &p_debug_thread_id, const String &p_language, const PackedByteArray &p_thread_tag, const String &p_thread_name);
+	void _on_debugger_thread_stack_dump(const PackedByteArray &p_debug_thread_id, const TypedArray<Dictionary> &p_stack_dump_info);
+	void _on_debugger_thread_exited(const PackedByteArray &p_debug_thread_id);
+	void _on_debugger_clear_execution(const Ref<Script> &p_script);
+
+public:
+	// Connect to all the signals that we need from the debugger.
+	Error connect(Object &debugger);
+	void disconnect(Object &debugger);
+
+	// Connect to the view. REVISIT: Change to opaque signals only relationship.
+	void set_view(View *view);
+	void _on_view_item_edited();
+	void _on_view_sort_requested(int p_field_index);
+
+	void clear_threads();
+};
+
+} // namespace editor::dbg::sd
+
+#endif // THREAD_LIST_H
diff --git a/editor/debugger/stack_dump/thread_list_tree.cpp b/editor/debugger/stack_dump/thread_list_tree.cpp
new file mode 100644
index 000000000000..c6282e65ec00
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_list_tree.cpp
@@ -0,0 +1,559 @@
+/*************************************************************************/
+/*  thread_list_tree.cpp                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "thread_list_tree.h"
+#include "thread_info.h"
+
+namespace editor::dbg::sd {
+
+using Field = ThreadInfo::Field;
+
+struct View::ColumnDeclaration {
+	String title;
+	String long_title;
+	bool visible = false;
+	int column_index = -1;
+
+	ColumnDeclaration(const char *p_title, const char *p_long_title, bool p_visible) {
+		title = p_title;
+		long_title = p_long_title;
+		visible = p_visible;
+	}
+};
+
+// These are indexed by severity code in the debugger, but let's not bother including all that implementation detail.
+static const int SEVERITY_NUM_VALUES = 6;
+const Color View::_color_by_severity[SEVERITY_NUM_VALUES] = {
+	Color(0.8, 0.8, 0.8, 1.0),
+	Color(1.0, 1.0, 1.0, 1.0),
+	Color(1.0, 1.0, 0.0, 1.0),
+	Color(1.0, 0.89, 0.027, 1.0),
+	Color(1.0, 0.78, 0.054, 1.0),
+	Color(1.0, 0.0, 0.0, 1.0)
+};
+
+const String View::_tooltip_by_status[static_cast<int>(ThreadInfo::Status::NUM_VALUES)] = {
+	"Thread is blocked and not available for debugging",
+	"Thread is running",
+	"Thread is paused after break on another thread",
+	"Thread hit break or error during step execution",
+	"Thread is paused for debugging",
+	"Thread has encountered an error",
+	"Thread has exited"
+};
+
+// Hard coded sizing.
+enum Pixels {
+	PIXEL_ICON_SIZE = 24,
+	PIXEL_H_SEPARATION = 6,
+	PIXEL_H_CHILD_MARGIN = 18,
+	PIXEL_ID_WIDTH = 48
+};
+
+PopupMenu *View::_build_column_title_context_menu() const {
+	PopupMenu *menu = memnew(PopupMenu());
+	menu->set_allow_search(true);
+	for (Field field : { Field::NAME, Field::CATEGORY, Field::LANGUAGE, Field::DEBUG_ID }) {
+		menu->add_check_item(_field_info[static_cast<int>(field)].long_title, static_cast<int>(field));
+		const int index = menu->get_item_index(static_cast<int>(field));
+		menu->set_item_as_checkable(index, true);
+		menu->set_item_checked(index, _field_info[static_cast<int>(field)].visible);
+	}
+	return menu;
+}
+
+inline int View::_get_column_index(Field p_field) const {
+	return _field_info[static_cast<int>(p_field)].column_index;
+}
+
+inline int View::_is_field_visible(Field p_field, int &r_column) const {
+	r_column = _field_info[static_cast<int>(p_field)].column_index;
+	return (r_column > -1);
+}
+
+String View::_format_frame_text(const Dictionary &p_stack_frame_info) {
+	return vformat("%d - %s:%d - at function: %s",
+			p_stack_frame_info["frame"],
+			p_stack_frame_info["file"],
+			p_stack_frame_info["line"],
+			p_stack_frame_info["function"]);
+}
+
+String View::_format_stack_text(const TypedArray<Dictionary> &p_stack_info) {
+	Vector<String> lines;
+	for (int frame = 0; frame < p_stack_info.size(); ++frame) {
+		lines.append(_format_frame_text(p_stack_info[frame]));
+	}
+	return String("\n").join(lines);
+}
+
+void View::set_meta_thread(TreeItem &p_item, const Ref<ThreadInfo> &p_thread) {
+	p_item.set_metadata(static_cast<int>(Meta::THREAD), p_thread);
+}
+
+// ReSharper disable once CppMemberFunctionMayBeConst because it actually modifies the tree through the non-const argument p_top.
+void View::_remove_stack_frames(TreeItem &p_top, const ThreadInfo &p_thread) {
+	if (p_thread.get_debug_thread_id() == _current &&
+			nullptr != p_top.get_first_child() &&
+			_field_index.size() > 2) {
+		// Move focus off of any child stack frames.
+		// REVISIT: Do we need to search for a selectable field in row selection mode?
+		p_top.select(2);
+	}
+	for (TreeItem *remove_me = p_top.get_first_child(); remove_me != nullptr; remove_me = p_top.get_first_child()) {
+		p_top.remove_child(remove_me);
+	}
+}
+
+// Warning: this is just the stack item build we also need to do every time we rebuild the view, so it does not imply
+// any user interaction.
+void View::_build_stack_dump_internal(const Ref<ThreadInfo> &p_thread) {
+	TreeItem &top = *p_thread->tree_item;
+	_remove_stack_frames(top, **p_thread);
+
+	const TypedArray<Dictionary> &stack = p_thread->stack_dump_info;
+	if (stack.is_empty()) {
+		set_meta_stack(top, Dictionary());
+		return;
+	}
+	set_meta_stack(top, stack[0]);
+	int stack_column;
+	if (_is_field_visible(Field::STACK, stack_column)) {
+		top.set_text(stack_column, _format_frame_text(stack[0]));
+		top.set_tooltip_text(stack_column, vformat("%s\n%s", p_thread->reason, _format_stack_text(stack)));
+	}
+	const String empty;
+	for (int frame = 1; frame < stack.size(); ++frame) {
+		TreeItem &line = *create_item(&top);
+		set_meta_stack(line, stack[frame]);
+		set_meta_thread(line, p_thread);
+		set_meta_frame(line, frame);
+		for (int scan = 0; scan < get_columns(); ++scan) {
+			line.set_selectable(scan, false);
+		}
+		int column;
+		if (_is_field_visible(Field::STATUS, column)) {
+			line.set_icon(column, Ref<Texture2D>());
+			line.set_icon_max_width(column, PIXEL_ICON_SIZE);
+		}
+		if (_is_field_visible(Field::ID, column)) {
+			line.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+			line.set_text(column, empty);
+		}
+		if (_is_field_visible(Field::DEBUG_ID, column)) {
+			line.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+			line.set_text(column, empty);
+		}
+		if (_is_field_visible(Field::CATEGORY, column)) {
+			line.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+			line.set_text(column, empty);
+		}
+		if (_is_field_visible(Field::STACK, column)) {
+			line.set_selectable(column, true);
+			line.set_text(column, _format_frame_text(stack[frame]));
+		}
+	}
+}
+
+void View::build_stack_dump(const Ref<ThreadInfo> &p_thread) {
+	if (nullptr == p_thread->tree_item) {
+		return;
+	}
+
+	_build_stack_dump_internal(p_thread);
+
+	// When first received, the current thread's stack is the debug focus.
+	if (!p_thread->stack_dump_info.is_empty()) {
+		p_thread->tree_item->set_collapsed(false);
+		if (p_thread->get_debug_thread_id() == _current) {
+			_notify_frame_selected(**p_thread, 0, p_thread->stack_dump_info[0]);
+		}
+	}
+}
+
+Ref<ThreadInfo> View::get_meta_thread(TreeItem &p_item) {
+	return static_cast<Ref<ThreadInfo>>(p_item.get_metadata(static_cast<int>(Meta::THREAD)));
+}
+
+void View::_rebuild() {
+	// Pass 0: tear down but keep source data.
+	Vector<Ref<ThreadInfo>> source_data;
+	if (get_root() != nullptr) {
+		for (TreeItem *item = get_root()->get_first_child(); item != nullptr; item = item->get_next()) {
+			Ref<ThreadInfo> thread = get_meta_thread(*item);
+			// We are about to destroy this tree item in clear() below.
+			thread->tree_item = nullptr;
+			source_data.append(thread);
+		}
+	}
+	clear();
+	_field_index.clear();
+
+	// Pass 1: measure columns.
+	int column = 0;
+	for (int field_index = 0; field_index < static_cast<int>(Field::NUM_VALUES); ++field_index) {
+		if (_field_info[field_index].visible) {
+			++column;
+		}
+	}
+	if (column < static_cast<int>(Meta::NUM_META_COLUMNS)) {
+		column = static_cast<int>(Meta::NUM_META_COLUMNS);
+	}
+	set_columns(column);
+
+	// Pass 2: build.
+	column = 0;
+	for (int field_index = 0; field_index < static_cast<int>(Field::NUM_VALUES); ++field_index) {
+		if (!_field_info[field_index].visible) {
+			_field_info[field_index].column_index = -1;
+			continue;
+		}
+		Field field = get_field(field_index);
+		switch (field) {
+			case Field::STATUS: {
+				// Extra horizontal separation in size calculation is due to an error in child size calculation in Tree control.
+				set_column_custom_minimum_width(column, (PIXEL_ICON_SIZE + PIXEL_H_SEPARATION) * 2 + PIXEL_H_CHILD_MARGIN + PIXEL_H_SEPARATION);
+				set_column_expand(column, false);
+				break;
+			}
+			case Field::ID: {
+				set_column_custom_minimum_width(column, PIXEL_ID_WIDTH);
+				set_column_expand(column, false);
+				break;
+			}
+			case Field::DEBUG_ID:
+			case Field::NAME:
+			case Field::LANGUAGE:
+			case Field::CATEGORY: {
+				set_column_expand(column, false);
+				break;
+			}
+			default:
+				// Other fields use default formatting.
+				break;
+		}
+		set_column_title(column, _field_info[field_index].title);
+		_field_info[field_index].column_index = column;
+		_field_index.append(field);
+		column++;
+	}
+
+	// Create root.
+	create_item();
+
+	// Recreate existing rows.
+	for (Ref<ThreadInfo> &thread : source_data) {
+		add_row(thread);
+		update_status(**thread);
+		update_info(**thread);
+		if (!thread->stack_dump_info.is_empty()) {
+			_build_stack_dump_internal(thread);
+		}
+	}
+}
+
+void View::_update_status_for_threads() {
+	if (get_root() != nullptr) {
+		for (TreeItem *item = get_root()->get_first_child(); item != nullptr; item = item->get_next()) {
+			Ref<ThreadInfo> thread = get_meta_thread(*item);
+			update_status(**thread);
+		}
+	}
+}
+
+void View::_notify_frame_selected(const ThreadInfo &p_thread, int p_frame, const Dictionary &p_frame_info) {
+	emit_signal(p_thread.can_debug ? "thread_frame_selected" : "thread_nodebug_frame_selected",
+			p_thread.get_debug_thread_id(),
+			p_frame,
+			p_frame_info);
+}
+
+void View::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_READY: {
+			_crashed_icon = get_theme_icon("ErrorSign", "EditorIcons");
+			_play_start_icon = get_theme_icon("PlayStart", "EditorIcons");
+			_column_title_context_menu = _build_column_title_context_menu();
+			add_child(_column_title_context_menu);
+			const Error ret = _column_title_context_menu->connect("id_pressed", callable_mp(this, &View::_on_columm_title_context_menu_id_pressed));
+			ERR_FAIL_COND_MSG(ret != OK, "failed to connect required signal from debugger");
+
+			// Initialize column mapping.
+			_rebuild();
+			break;
+		}
+		case NOTIFICATION_EXIT_TREE: {
+			if (_column_title_context_menu != nullptr) {
+				memdelete(_column_title_context_menu);
+				_column_title_context_menu = nullptr;
+			}
+			// Disconnect from signals to undo circularities.
+			if (_column_title_context_menu != nullptr) {
+				_column_title_context_menu->disconnect("id_pressed", callable_mp(this, &View::_on_columm_title_context_menu_id_pressed));
+			}
+			disconnect("item_selected", callable_mp(this, &View::_on_item_selected));
+			disconnect("column_title_clicked", callable_mp(this, &View::_on_column_title_clicked));
+			break;
+		}
+		case NOTIFICATION_POSTINITIALIZE: {
+			set_select_mode(SELECT_ROW);
+			set_allow_reselect(true);
+			set_column_titles_visible(true);
+			set_hide_root(true);
+			set_anchors_preset(PRESET_FULL_RECT);
+			set_h_size_flags(SIZE_EXPAND_FILL);
+			set_v_size_flags(SIZE_EXPAND_FILL);
+
+			Error ret = connect("item_selected", callable_mp(this, &View::_on_item_selected));
+			ERR_FAIL_COND_MSG(ret != OK, "failed to connect required signal 'item_selected' from Tree control");
+
+			ret = connect("column_title_clicked", callable_mp(this, &View::_on_column_title_clicked));
+			ERR_FAIL_COND_MSG(ret != OK, "failed to connect required signal 'column_title_clicked' from Tree control");
+
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+int View::get_meta_frame(TreeItem &p_item) {
+	return static_cast<int>(p_item.get_metadata(static_cast<int>(Meta::FRAME)));
+}
+
+Dictionary View::get_meta_stack(TreeItem &p_item) {
+	return static_cast<Dictionary>(p_item.get_metadata(static_cast<int>(Meta::STACK)));
+}
+
+void View::_on_item_selected() {
+	TreeItem *row = get_selected();
+	if (nullptr == row) {
+		return;
+	}
+	Ref<ThreadInfo> thread = get_meta_thread(*row);
+	_current = thread->get_debug_thread_id();
+	_update_status_for_threads();
+	_notify_frame_selected(**thread, get_meta_frame(*row), get_meta_stack(*row));
+}
+
+void View::_on_column_title_clicked(int p_column, int p_mouse_button_index) {
+	switch (p_mouse_button_index) {
+		case static_cast<int>(MouseButton::RIGHT): {
+			_column_title_context_menu->set_visible(true);
+			return;
+		}
+		case static_cast<int>(MouseButton::LEFT): {
+			if (p_column >= _field_index.size()) {
+				// Deferred late.
+				return;
+			}
+			const Field field = _field_index[p_column];
+			switch (field) {
+				case Field::ID:
+				case Field::DEBUG_ID:
+				case Field::NAME:
+				case Field::LANGUAGE:
+					emit_signal("sort_requested", static_cast<int>(field));
+					break;
+				default:
+					// Other fields do not sort.
+					break;
+			}
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+void View::_on_columm_title_context_menu_id_pressed(int p_id) {
+	if (nullptr == _column_title_context_menu) {
+		// Deferred late.
+		return;
+	}
+	const int index = _column_title_context_menu->get_item_index(p_id);
+	_column_title_context_menu->toggle_item_checked(index);
+	_field_info[p_id].visible = _column_title_context_menu->is_item_checked(index);
+	_rebuild();
+}
+
+void View::_bind_methods() {
+	ADD_SIGNAL(MethodInfo("thread_frame_selected", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "tid"), PropertyInfo(Variant::INT, "frame")));
+	ADD_SIGNAL(MethodInfo("thread_nodebug_frame_selected", PropertyInfo(Variant::PACKED_BYTE_ARRAY, "tid"), PropertyInfo(Variant::INT, "frame")));
+	ADD_SIGNAL(MethodInfo("sort_requested", PropertyInfo(Variant::INT, "field_index")));
+}
+
+void View::set_current(const ThreadInfo &p_thread) {
+	_current = p_thread.get_debug_thread_id();
+	if (_field_index.size() < 3) {
+		// Not enough fields shown, should not happen.
+		return;
+	}
+	// REVISIT: Do we need to search for a selectable field in row selection mode?
+	p_thread.tree_item->select(2);
+}
+
+void View::set_meta_frame(TreeItem &p_item, int p_frame) {
+	return p_item.set_metadata(static_cast<int>(Meta::FRAME), p_frame);
+}
+
+void View::set_meta_stack(TreeItem &p_item, const Dictionary &p_stack_frame_info) {
+	p_item.set_metadata(static_cast<int>(Meta::STACK), p_stack_frame_info);
+}
+
+void View::add_row(Ref<ThreadInfo> &p_thread, int p_at_position) {
+	TreeItem &item = *create_item(get_root(), p_at_position);
+	set_meta_thread(item, p_thread);
+	set_meta_frame(item, 0);
+	set_meta_stack(item, Dictionary());
+
+	int column;
+	if (_is_field_visible(Field::STATUS, column)) {
+		item.set_cell_mode(column, TreeItem::CELL_MODE_CHECK);
+		item.set_editable(column, true);
+		item.set_icon_max_width(column, PIXEL_ICON_SIZE);
+		item.set_selectable(column, false);
+		item.set_icon(column, nullptr);
+	}
+	if (_is_field_visible(Field::ID, column)) {
+		item.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+		item.set_text(column, vformat("%d", p_thread->thread_number));
+	}
+	if (_is_field_visible(Field::DEBUG_ID, column)) {
+		item.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+		item.set_text(column, p_thread->get_debug_thread_id_hex());
+	}
+	if (_is_field_visible(Field::CATEGORY, column)) {
+		item.set_text_alignment(column, HORIZONTAL_ALIGNMENT_CENTER);
+		item.set_text(column, p_thread->is_main_thread ? "Main" : "Worker");
+	}
+	if (_is_field_visible(Field::NAME, column)) {
+		item.set_text(column, "");
+	}
+	if (_is_field_visible(Field::LANGUAGE, column)) {
+		item.set_text(column, "");
+	}
+	if (_is_field_visible(Field::STACK, column)) {
+		if (p_thread->stack_dump_info.size() > 0) {
+			build_stack_dump(p_thread);
+		} else {
+			item.set_text(column, "");
+			item.set_tooltip_text(column, vformat("%s\n%s", p_thread->reason, p_thread->has_stack_dump ? "(no stack info received)" : "(stack info unavailable)"));
+			item.set_collapsed(true);
+		}
+	}
+
+	// WARNING: Memory ownership passed to caller via thread info object.
+	p_thread->tree_item = &item;
+}
+
+void View::update_status(const ThreadInfo &p_thread) {
+	using Status = ThreadInfo::Status;
+	int status_column;
+	if (!_is_field_visible(Field::STATUS, status_column)) {
+		return;
+	}
+
+	// Sanitize this value because we don't include the headers needed to know the valid range.
+	int severity = p_thread.severity_code;
+	if (severity < 0) {
+		severity = 0;
+	} else if (severity >= SEVERITY_NUM_VALUES) {
+		severity = SEVERITY_NUM_VALUES - 1;
+	}
+
+	if (p_thread.get_debug_thread_id() == _current) {
+		p_thread.tree_item->set_icon_modulate(status_column, _color_by_severity[severity]);
+	} else {
+		p_thread.tree_item->set_icon_modulate(status_column, _color_by_severity[severity] * 0.5);
+	}
+
+	switch (p_thread.status) {
+		case Status::PAUSED:
+		case Status::ALERT:
+		case Status::BREAKPOINT: {
+			p_thread.tree_item->set_icon(status_column, p_thread.can_debug ? _play_start_icon : _crashed_icon);
+			break;
+		}
+		case Status::CRASHED:
+			p_thread.tree_item->set_icon(status_column, _crashed_icon);
+			break;
+		default:
+			p_thread.tree_item->set_icon(status_column, nullptr);
+	}
+	p_thread.tree_item->set_tooltip_text(status_column, _tooltip_by_status[static_cast<int>(p_thread.status)]);
+}
+
+// ReSharper disable once CppMemberFunctionMayBeConst because it actually modifies the tree through p_thread.tree_item.
+void View::update_info(const ThreadInfo &p_thread) {
+	if (nullptr == p_thread.tree_item) {
+		return;
+	}
+	int column;
+	if (_is_field_visible(Field::NAME, column)) {
+		p_thread.tree_item->set_text(column, p_thread.thread_name);
+	}
+	if (_is_field_visible(Field::LANGUAGE, column)) {
+		p_thread.tree_item->set_text(column, p_thread.language);
+	}
+}
+
+bool View::is_pin_column_visible() const {
+	return _get_column_index(Field::STATUS) > -1;
+}
+
+bool View::is_pinned(const ThreadInfo &p_thread) const {
+	if (nullptr == p_thread.tree_item) {
+		return false;
+	}
+	int column;
+	if (!_is_field_visible(Field::STATUS, column)) {
+		return false;
+	}
+	return p_thread.tree_item->is_checked(column);
+}
+
+View::View() {
+	_field_info = new ColumnDeclaration[static_cast<int>(Field::NUM_VALUES)]{
+		ColumnDeclaration("Pin State", "Pin and State", true),
+		ColumnDeclaration("ID", "ID", true),
+		ColumnDeclaration("Name", "Name", true),
+		ColumnDeclaration("Where", "Where", true),
+		ColumnDeclaration("Lang.", "Language", false),
+		ColumnDeclaration("Category", "Category", false),
+		ColumnDeclaration("Debug ID", "Debug ID", false)
+	};
+}
+
+View::~View() {
+	delete[] _field_info;
+}
+
+} // namespace editor::dbg::sd
diff --git a/editor/debugger/stack_dump/thread_list_tree.h b/editor/debugger/stack_dump/thread_list_tree.h
new file mode 100644
index 000000000000..00ffdeb7e77f
--- /dev/null
+++ b/editor/debugger/stack_dump/thread_list_tree.h
@@ -0,0 +1,128 @@
+/*************************************************************************/
+/*  thread_list_tree.h                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef THREAD_LIST_TREE_H
+#define THREAD_LIST_TREE_H
+
+#include "scene/gui/tree.h"
+#include "thread_info.h"
+
+namespace editor::dbg::sd {
+
+class View : public Tree {
+	GDCLASS(View, Tree)
+
+	using Field = ThreadInfo::Field;
+	using DebugThreadID = ThreadInfo::DebugThreadID;
+
+	// ReSharper disable once CppHidingFunction as this is normal behavior for GDCLASS objects.
+	void _notification(int p_what);
+
+	// Debug Thread ID for currently selected thread.
+	DebugThreadID _current;
+
+	// Columns defined for the tree, not necessarily all visible.  Indexed by Field enum above.
+	struct ColumnDeclaration;
+	ColumnDeclaration *_field_info;
+
+	// Index from tree column to field id.
+	Vector<Field> _field_index;
+
+	// Popup menu to select shown columns.
+	PopupMenu *_column_title_context_menu = nullptr;
+
+	// Hard coded color preferences.
+	static const Color _color_by_severity[];
+
+	// Tooltip text by status code. Indexed by FieldInfo::Status.
+	static const String _tooltip_by_status[];
+
+	// Icons
+	Ref<Texture2D> _play_start_icon;
+	Ref<Texture2D> _crashed_icon;
+
+	int _get_column_index(Field p_field) const;
+	int _is_field_visible(Field p_field, int &r_column) const;
+	PopupMenu *_build_column_title_context_menu() const;
+	String _format_frame_text(const Dictionary &p_stack_frame_info);
+	String _format_stack_text(const TypedArray<Dictionary> &p_stack_info);
+	void _rebuild();
+	void _remove_stack_frames(TreeItem &p_top, const ThreadInfo &p_thread);
+	void _build_stack_dump_internal(const Ref<ThreadInfo> &p_thread);
+	void _update_status_for_threads();
+	void _notify_frame_selected(const ThreadInfo &p_thread, int p_frame, const Dictionary &p_frame_info);
+
+	// Signal handlers.
+	void _on_columm_title_context_menu_id_pressed(int p_id);
+	void _on_item_selected();
+	void _on_column_title_clicked(int p_column, int p_mouse_button_index);
+
+protected:
+	static void _bind_methods();
+
+public:
+	// Column indexes in the tree view that we use to store meta information in each tree item.
+	enum class Meta {
+		STACK = 0,
+		THREAD,
+		FRAME,
+		NUM_META_COLUMNS
+	};
+
+	Field get_field(int field_index) {
+		return static_cast<Field>(field_index);
+	}
+
+	void add_row(Ref<ThreadInfo> &p_thread, int p_at_position = -1);
+	void build_stack_dump(const Ref<ThreadInfo> &p_thread);
+	void update_status(const ThreadInfo &p_thread);
+	void update_info(const ThreadInfo &p_thread);
+
+	void set_current(const ThreadInfo &p_thread);
+
+	bool is_pin_column_visible() const;
+	bool is_pinned(const ThreadInfo &p_thread) const;
+
+	static Ref<ThreadInfo> get_meta_thread(TreeItem &p_item);
+	static void set_meta_thread(TreeItem &p_item, const Ref<ThreadInfo> &p_thread);
+
+	static int get_meta_frame(TreeItem &p_item);
+	static void set_meta_frame(TreeItem &p_item, int p_frame);
+
+	static Dictionary get_meta_stack(TreeItem &p_item);
+	static void set_meta_stack(TreeItem &p_item, const Dictionary &p_stack_frame_info);
+
+	View();
+	~View();
+};
+
+} // namespace editor::dbg::sd
+
+#endif // THREAD_LIST_TREE_H
diff --git a/editor/editor_log.cpp b/editor/editor_log.cpp
index a3d4296edb11..b9f200f1eb3e 100644
--- a/editor/editor_log.cpp
+++ b/editor/editor_log.cpp
@@ -281,16 +281,20 @@ void EditorLog::_add_log_line(LogMessage &p_message, bool p_replace_previous) {
 		case MSG_TYPE_ERROR: {
 			log->push_color(theme_cache.error_color);
 			Ref<Texture2D> icon = theme_cache.error_icon;
-			log->add_image(icon);
+			if (icon.is_valid()) {
+				log->add_image(icon);
+				tool_button->set_icon(icon);
+			}
 			log->add_text(" ");
-			tool_button->set_icon(icon);
 		} break;
 		case MSG_TYPE_WARNING: {
 			log->push_color(theme_cache.warning_color);
 			Ref<Texture2D> icon = theme_cache.warning_icon;
-			log->add_image(icon);
+			if (icon.is_valid()) {
+				log->add_image(icon);
+				tool_button->set_icon(icon);
+			}
 			log->add_text(" ");
-			tool_button->set_icon(icon);
 		} break;
 		case MSG_TYPE_EDITOR: {
 			// Distinguish editor messages from messages printed by the project
diff --git a/editor/plugins/editor_debugger_plugin.cpp b/editor/plugins/editor_debugger_plugin.cpp
index 4ce3d7cfd52b..2672e205a15f 100644
--- a/editor/plugins/editor_debugger_plugin.cpp
+++ b/editor/plugins/editor_debugger_plugin.cpp
@@ -86,7 +86,7 @@ void EditorDebuggerPlugin::detach_debugger(bool p_call_debugger) {
 
 void EditorDebuggerPlugin::send_message(const String &p_message, const Array &p_args) {
 	ERR_FAIL_COND_MSG(!debugger, "Plugin is not attached to debugger");
-	debugger->send_message(p_message, p_args);
+	debugger->send_message_auto(p_message, p_args);
 }
 
 void EditorDebuggerPlugin::register_message_capture(const StringName &p_name, const Callable &p_callable) {
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 10babad37820..9983e42e1438 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -38,6 +38,7 @@
 #include "core/core_string_names.h"
 #include "core/io/file_access.h"
 #include "core/io/file_access_encrypted.h"
+#include "core/object/script_language_internals.h"
 #include "core/os/os.h"
 #include "gdscript_analyzer.h"
 #include "gdscript_cache.h"
@@ -54,7 +55,23 @@
 #include "editor/editor_paths.h"
 #endif
 
-///////////////////////////
+// This gets initialized for each thread.  If debugging is enabled, it will be
+// accessed and will lazy create a thread local storage context for that thread.
+thread_local ThreadContextRef<GDScriptLanguage, GDScriptThreadContext> t_gdscript_current_thread;
+
+// static
+GDScriptThreadContext &GDScriptThreadContext::current() {
+	return t_gdscript_current_thread.context();
+}
+
+// virtual
+ScriptLanguageThreadContext &GDScriptLanguage::current_thread() {
+	return t_gdscript_current_thread.context();
+}
+
+bool GDScriptThreadContext::is_main_thread() const {
+	return _is_main;
+}
 
 GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) {
 	name = p_name;
@@ -142,7 +159,7 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 	instance->owner = p_owner;
 	instance->owner_id = p_owner->get_instance_id();
 #ifdef DEBUG_ENABLED
-	//needed for hot reloading
+	// needed for hot reloading
 	for (const KeyValue<StringName, MemberInfo> &E : member_indices) {
 		instance->member_indices_cache[E.key] = E.value.index;
 	}
@@ -208,7 +225,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Callable::CallErr
 	if (_baseptr->native.ptr()) {
 		owner = _baseptr->native->instantiate();
 	} else {
-		owner = memnew(RefCounted); //by default, no base means use reference
+		owner = memnew(RefCounted); // by default, no base means use reference
 	}
 	ERR_FAIL_COND_V_MSG(!owner, Variant(), "Can't inherit from a virtual class.");
 
@@ -220,7 +237,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Callable::CallErr
 	GDScriptInstance *instance = _create_instance(p_args, p_argcount, owner, r != nullptr, r_error);
 	if (!instance) {
 		if (ref.is_null()) {
-			memdelete(owner); //no owner, sorry
+			memdelete(owner); // no owner, sorry
 		}
 		return Variant();
 	}
@@ -396,7 +413,7 @@ ScriptInstance *GDScript::instance_create(Object *p_this) {
 	if (top->native.is_valid()) {
 		if (!ClassDB::is_parent_class(p_this->get_class_name(), top->native->get_name())) {
 			if (EngineDebugger::is_active()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), 1, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instantiated in object of type: '" + p_this->get_class() + "'");
+				GDScriptThreadContext::current().debug_break_parse(_get_debug_path(), 1, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instantiated in object of type: '" + p_this->get_class() + "'");
 			}
 			ERR_FAIL_V_MSG(nullptr, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instantiated in object of type '" + p_this->get_class() + "'" + ".");
 		}
@@ -779,7 +796,7 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 		}
 	}
 
-	if ((changed || p_instance_to_update) && placeholders.size()) { //hm :(
+	if ((changed || p_instance_to_update) && placeholders.size()) { // hm :(
 
 		// update placeholders if any
 		HashMap<StringName, Variant> values;
@@ -811,7 +828,7 @@ void GDScript::update_exports() {
 		return;
 	}
 
-	HashSet<ObjectID> copy = inheriters_cache; //might get modified
+	HashSet<ObjectID> copy = inheriters_cache; // might get modified
 
 	for (const ObjectID &E : copy) {
 		Object *id = ObjectDB::get_instance(E);
@@ -885,7 +902,7 @@ Error GDScript::reload(bool p_keep_state) {
 	Error err = parser.parse(source, path, false);
 	if (err) {
 		if (EngineDebugger::is_active()) {
-			GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), parser.get_errors().front()->get().line, "Parser Error: " + parser.get_errors().front()->get().message);
+			GDScriptThreadContext::current().debug_break_parse(_get_debug_path(), parser.get_errors().front()->get().line, "Parser Error: " + parser.get_errors().front()->get().message);
 		}
 		// TODO: Show all error messages.
 		_err_print_error("GDScript::reload", path.is_empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_errors().front()->get().line, ("Parse Error: " + parser.get_errors().front()->get().message).utf8().get_data(), false, ERR_HANDLER_SCRIPT);
@@ -897,7 +914,7 @@ Error GDScript::reload(bool p_keep_state) {
 
 	if (err) {
 		if (EngineDebugger::is_active()) {
-			GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), parser.get_errors().front()->get().line, "Parser Error: " + parser.get_errors().front()->get().message);
+			GDScriptThreadContext::current().debug_break_parse(_get_debug_path(), parser.get_errors().front()->get().line, "Parser Error: " + parser.get_errors().front()->get().message);
 		}
 
 		const List<GDScriptParser::ParserError>::Element *e = parser.get_errors().front();
@@ -920,7 +937,7 @@ Error GDScript::reload(bool p_keep_state) {
 	if (err) {
 		if (can_run) {
 			if (EngineDebugger::is_active()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
+				GDScriptThreadContext::current().debug_break_parse(_get_debug_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
 			}
 			_err_print_error("GDScript::reload", path.is_empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), false, ERR_HANDLER_SCRIPT);
 			return ERR_COMPILATION_FAILED;
@@ -931,8 +948,7 @@ Error GDScript::reload(bool p_keep_state) {
 #ifdef DEBUG_ENABLED
 	for (const GDScriptWarning &warning : parser.get_warnings()) {
 		if (EngineDebugger::is_active()) {
-			Vector<ScriptLanguage::StackInfo> si;
-			EngineDebugger::get_script_debugger()->send_error("", get_path(), warning.start_line, warning.get_name(), warning.get_message(), false, ERR_HANDLER_WARNING, si);
+			EngineDebugger::get_singleton()->send_error("", get_path(), warning.start_line, warning.get_name(), warning.get_message(), false, ERR_HANDLER_WARNING);
 		}
 	}
 #endif
@@ -984,7 +1000,7 @@ Variant GDScript::callp(const StringName &p_method, const Variant **p_args, int
 		top = top->_base;
 	}
 
-	//none found, regular
+	// none found, regular
 
 	return Script::callp(p_method, p_args, p_argcount, r_error);
 }
@@ -1200,7 +1216,7 @@ void GDScript::_save_orphaned_subclasses() {
 	Vector<ClassRefWithName> weak_subclasses;
 	// collect subclasses ObjectID and name
 	for (KeyValue<StringName, Ref<GDScript>> &E : subclasses) {
-		E.value->_owner = nullptr; //bye, you are no longer owned cause I died
+		E.value->_owner = nullptr; // bye, you are no longer owned cause I died
 		ClassRefWithName subclass;
 		subclass.id = E.value->get_instance_id();
 		subclass.fully_qualified_name = E.value->fully_qualified_name;
@@ -1305,7 +1321,7 @@ GDScript::~GDScript() {
 //////////////////////////////
 
 bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
-	//member
+	// member
 	{
 		HashMap<StringName, GDScript::MemberInfo>::Iterator E = script->member_indices.find(p_name);
 		if (E) {
@@ -1315,7 +1331,7 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 				Callable::CallError err;
 				callp(member->setter, &val, 1, err);
 				if (err.error == Callable::CallError::CALL_OK) {
-					return true; //function exists, call was successful
+					return true; // function exists, call was successful
 				} else {
 					return false;
 				}
@@ -1381,7 +1397,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 					}
 				}
 				r_ret = members[E->value.index];
-				return true; //index found
+				return true; // index found
 			}
 		}
 
@@ -1391,7 +1407,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 				HashMap<StringName, Variant>::ConstIterator E = sl->constants.find(p_name);
 				if (E) {
 					r_ret = E->value;
-					return true; //index found
+					return true; // index found
 				}
 				sl = sl->_base;
 			}
@@ -1404,7 +1420,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 				HashMap<StringName, Vector<StringName>>::ConstIterator E = sl->_signals.find(p_name);
 				if (E) {
 					r_ret = Signal(this->owner, E->key);
-					return true; //index found
+					return true; // index found
 				}
 				sl = sl->_base;
 			}
@@ -1421,7 +1437,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 					} else {
 						r_ret = Callable(this->owner, E->key);
 					}
-					return true; //index found
+					return true; // index found
 				}
 				sl = sl->_base;
 			}
@@ -1507,7 +1523,7 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 			}
 		}
 
-		//instance a fake script for editing the values
+		// instance a fake script for editing the values
 
 		Vector<_GDScriptMemberSort> msort;
 		for (const KeyValue<StringName, PropertyInfo> &F : sptr->member_info) {
@@ -1633,7 +1649,7 @@ Variant GDScriptInstance::callp(const StringName &p_method, const Variant **p_ar
 }
 
 void GDScriptInstance::notification(int p_notification) {
-	//notification is not virtual, it gets called at ALL levels just like in C.
+	// notification is not virtual, it gets called at ALL levels just like in C.
 	Variant value = p_notification;
 	const Variant *args[1] = { &value };
 
@@ -1644,7 +1660,7 @@ void GDScriptInstance::notification(int p_notification) {
 			Callable::CallError err;
 			E->value->call(this, args, 1, err);
 			if (err.error != Callable::CallError::CALL_OK) {
-				//print error about notification call
+				// print error about notification call
 			}
 		}
 		sptr = sptr->_base;
@@ -1692,7 +1708,7 @@ void GDScriptInstance::reload_members() {
 	Vector<Variant> new_members;
 	new_members.resize(script->member_indices.size());
 
-	//pass the values to the new indices
+	// pass the values to the new indices
 	for (KeyValue<StringName, GDScript::MemberInfo> &E : script->member_indices) {
 		if (member_indices_cache.has(E.key)) {
 			Variant value = members[member_indices_cache[E.key]];
@@ -1700,12 +1716,12 @@ void GDScriptInstance::reload_members() {
 		}
 	}
 
-	members.resize(new_members.size()); //resize
+	members.resize(new_members.size()); // resize
 
 	//apply
 	members = new_members;
 
-	//pass the values to the new indices
+	// pass the values to the new indices
 	member_indices_cache.clear();
 	for (const KeyValue<StringName, GDScript::MemberInfo> &E : script->member_indices) {
 		member_indices_cache[E.key] = E.value.index;
@@ -1746,7 +1762,7 @@ String GDScriptLanguage::get_name() const {
 
 void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) {
 	if (globals.has(p_name)) {
-		//overwrite existing
+		// overwrite existing
 		global_array.write[globals[p_name]] = p_value;
 		return;
 	}
@@ -1768,8 +1784,10 @@ void GDScriptLanguage::remove_named_global_constant(const StringName &p_name) {
 	named_globals.erase(p_name);
 }
 
-void GDScriptLanguage::init() {
-	//populate global constants
+void GDScriptLanguage::init(int p_language_index) {
+	ScriptLanguage::init(p_language_index);
+
+	// populate global constants
 	int gcc = CoreConstants::get_global_constant_count();
 	for (int i = 0; i < gcc; i++) {
 		_add_global(StaticCString::create(CoreConstants::get_global_constant_name(i)), CoreConstants::get_global_constant_value(i));
@@ -1780,7 +1798,7 @@ void GDScriptLanguage::init() {
 	_add_global(StaticCString::create("INF"), INFINITY);
 	_add_global(StaticCString::create("NAN"), NAN);
 
-	//populate native classes
+	// populate native classes
 
 	List<StringName> class_list;
 	ClassDB::get_class_list(&class_list);
@@ -1792,7 +1810,7 @@ void GDScriptLanguage::init() {
 		_add_global(n, nc);
 	}
 
-	//populate singletons
+	// populate singletons
 
 	List<Engine::Singleton> singletons;
 	Engine::get_singleton()->get_singletons(&singletons);
@@ -1819,6 +1837,8 @@ Error GDScriptLanguage::execute_file(const String &p_path) {
 }
 
 void GDScriptLanguage::finish() {
+	// Free main thread context so that it does not trigger ObjectDB leak detection.
+	t_gdscript_current_thread.free_context();
 }
 
 void GDScriptLanguage::profiling_start() {
@@ -1900,10 +1920,10 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_
 }
 
 struct GDScriptDepSort {
-	//must support sorting so inheritance works properly (parent must be reloaded first)
+	// must support sorting so inheritance works properly (parent must be reloaded first)
 	bool operator()(const Ref<GDScript> &A, const Ref<GDScript> &B) const {
 		if (A == B) {
-			return false; //shouldn't happen but..
+			return false; // shouldn't happen but..
 		}
 		const GDScript *I = B->get_base().ptr();
 		while (I) {
@@ -1915,7 +1935,7 @@ struct GDScriptDepSort {
 			I = I->get_base().ptr();
 		}
 
-		return false; //not a base
+		return false; // not a base
 	}
 };
 
@@ -1930,15 +1950,15 @@ void GDScriptLanguage::reload_all_scripts() {
 		while (elem) {
 			if (elem->self()->get_path().is_resource_file()) {
 				print_verbose("GDScript: Found: " + elem->self()->get_path());
-				scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+				scripts.push_back(Ref<GDScript>(elem->self())); // cast to gdscript to avoid being erased by accident
 			}
 			elem = elem->next();
 		}
 	}
 
-	//as scripts are going to be reloaded, must proceed without locking here
+	// as scripts are going to be reloaded, must proceed without locking here
 
-	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+	scripts.sort_custom<GDScriptDepSort>(); // update in inheritance dependency order
 
 	for (Ref<GDScript> &script : scripts) {
 		print_verbose("GDScript: Reloading: " + script->get_path());
@@ -1958,19 +1978,19 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 		SelfList<GDScript> *elem = script_list.first();
 		while (elem) {
 			if (elem->self()->get_path().is_resource_file()) {
-				scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+				scripts.push_back(Ref<GDScript>(elem->self())); // cast to gdscript to avoid being erased by accident
 			}
 			elem = elem->next();
 		}
 	}
 
-	//when someone asks you why dynamically typed languages are easier to write....
+	// when someone asks you why dynamically typed languages are easier to write....
 
 	HashMap<Ref<GDScript>, HashMap<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
 
-	//as scripts are going to be reloaded, must proceed without locking here
+	// as scripts are going to be reloaded, must proceed without locking here
 
-	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+	scripts.sort_custom<GDScriptDepSort>(); // update in inheritance dependency order
 
 	for (Ref<GDScript> &script : scripts) {
 		bool reload = script == p_script || to_reload.has(script->get_base());
@@ -1982,12 +2002,12 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 		to_reload.insert(script, HashMap<ObjectID, List<Pair<StringName, Variant>>>());
 
 		if (!p_soft_reload) {
-			//save state and remove script from instances
+			// save state and remove script from instances
 			HashMap<ObjectID, List<Pair<StringName, Variant>>> &map = to_reload[script];
 
 			while (script->instances.front()) {
 				Object *obj = script->instances.front()->get();
-				//save instance info
+				// save instance info
 				List<Pair<StringName, Variant>> state;
 				if (obj->get_script_instance()) {
 					obj->get_script_instance()->get_property_state(state);
@@ -1996,13 +2016,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 				}
 			}
 
-//same thing for placeholders
+// same thing for placeholders
 #ifdef TOOLS_ENABLED
 
 			while (script->placeholders.size()) {
 				Object *obj = (*script->placeholders.begin())->get_owner();
 
-				//save instance info
+				// save instance info
 				if (obj->get_script_instance()) {
 					map.insert(obj->get_instance_id(), List<Pair<StringName, Variant>>());
 					List<Pair<StringName, Variant>> &state = map[obj->get_instance_id()];
@@ -2017,7 +2037,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 #endif
 
 			for (const KeyValue<ObjectID, List<Pair<StringName, Variant>>> &F : script->pending_reload_state) {
-				map[F.key] = F.value; //pending to reload, use this one instead
+				map[F.key] = F.value; // pending to reload, use this one instead
 			}
 		}
 	}
@@ -2026,7 +2046,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 		Ref<GDScript> scr = E.key;
 		scr->reload(p_soft_reload);
 
-		//restore state if saved
+		// restore state if saved
 		for (KeyValue<ObjectID, List<Pair<StringName, Variant>>> &F : E.value) {
 			List<Pair<StringName, Variant>> &saved_state = F.value;
 
@@ -2036,7 +2056,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 			}
 
 			if (!p_soft_reload) {
-				//clear it just in case (may be a pending reload state)
+				// clear it just in case (may be a pending reload state)
 				obj->set_script(Variant());
 			}
 			obj->set_script(scr);
@@ -2044,7 +2064,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 			ScriptInstance *script_instance = obj->get_script_instance();
 
 			if (!script_instance) {
-				//failed, save reload state for next time if not saved
+				// failed, save reload state for next time if not saved
 				if (!scr->pending_reload_state.has(obj->get_instance_id())) {
 					scr->pending_reload_state[obj->get_instance_id()] = saved_state;
 				}
@@ -2062,10 +2082,10 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 				}
 			}
 
-			scr->pending_reload_state.erase(obj->get_instance_id()); //as it reloaded, remove pending state
+			scr->pending_reload_state.erase(obj->get_instance_id()); // as it reloaded, remove pending state
 		}
 
-		//if instance states were saved, set them!
+		// if instance states were saved, set them!
 	}
 
 #endif
@@ -2280,6 +2300,33 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 	return String();
 }
 
+ScriptLanguageThreadContext::DebugThreadID GDScriptThreadContext::debug_get_thread_id() const {
+	return _debug_thread_id;
+}
+
+GDScriptThreadContext::GDScriptThreadContext(GDScriptLanguage &p_parent, Thread::ID p_thread_id) :
+		_parent(p_parent) {
+	_debug_thread_id = ScriptLanguageInternals::create_thread_id(p_parent, p_thread_id);
+	_is_main = p_thread_id == Thread::get_main_id();
+	_debug_parse_err_line = -1;
+	_debug_parse_err_file = "";
+	_debug_call_stack_pos = 0;
+
+	if (EngineDebugger::is_active()) {
+		_debug_max_call_stack = GDScriptLanguage::get_singleton()->max_call_stack.get();
+		_call_stack = memnew_arr(CallLevel, _debug_max_call_stack + 1);
+	} else {
+		_debug_max_call_stack = 0;
+		_call_stack = nullptr;
+	}
+}
+
+GDScriptThreadContext::~GDScriptThreadContext() {
+	if (_call_stack) {
+		memdelete_arr(_call_stack);
+	}
+}
+
 GDScriptLanguage::GDScriptLanguage() {
 	calls = 0;
 	ERR_FAIL_COND(singleton);
@@ -2292,26 +2339,12 @@ GDScriptLanguage::GDScriptLanguage() {
 	strings._property_can_revert = StaticCString::create("_property_can_revert");
 	strings._property_get_revert = StaticCString::create("_property_get_revert");
 	strings._script_source = StaticCString::create("script/source");
-	_debug_parse_err_line = -1;
-	_debug_parse_err_file = "";
 
 	profiling = false;
 	script_frame_time = 0;
 
-	_debug_call_stack_pos = 0;
-	int dmcs = GLOBAL_DEF("debug/settings/gdscript/max_call_stack", 1024);
-	ProjectSettings::get_singleton()->set_custom_property_info("debug/settings/gdscript/max_call_stack", PropertyInfo(Variant::INT, "debug/settings/gdscript/max_call_stack", PROPERTY_HINT_RANGE, "1024,4096,1,or_greater")); //minimum is 1024
-
-	if (EngineDebugger::is_active()) {
-		//debugging enabled!
-
-		_debug_max_call_stack = dmcs;
-		_call_stack = memnew_arr(CallLevel, _debug_max_call_stack + 1);
-
-	} else {
-		_debug_max_call_stack = 0;
-		_call_stack = nullptr;
-	}
+	max_call_stack.set(GLOBAL_DEF("debug/settings/gdscript/max_call_stack", 1024));
+	ProjectSettings::get_singleton()->set_custom_property_info("debug/settings/gdscript/max_call_stack", PropertyInfo(Variant::INT, "debug/settings/gdscript/max_call_stack", PROPERTY_HINT_RANGE, "1024,4096,1,or_greater")); // minimum is 1024
 
 #ifdef DEBUG_ENABLED
 	GLOBAL_DEF("debug/gdscript/warnings/enable", true);
@@ -2330,10 +2363,6 @@ GDScriptLanguage::GDScriptLanguage() {
 }
 
 GDScriptLanguage::~GDScriptLanguage() {
-	if (_call_stack) {
-		memdelete_arr(_call_stack);
-	}
-
 	// Clear dependencies between scripts, to ensure cyclic references are broken (to avoid leaks at exit).
 	SelfList<GDScript> *s = script_list.first();
 	while (s) {
@@ -2380,6 +2409,23 @@ Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_na
 	return Ref<GDScript>(Object::cast_to<GDScript>(obj));
 }
 
+GDScriptThreadContext *GDScriptLanguage::create_thread_context() {
+	return memnew(GDScriptThreadContext(*get_singleton(), Thread::get_caller_id()));
+}
+
+Vector<ScriptLanguageThreadContext::StackInfo> GDScriptThreadContext::debug_get_current_stack_info() const {
+	Vector<StackInfo> csi;
+	csi.resize(_debug_call_stack_pos);
+	for (int i = 0; i < _debug_call_stack_pos; i++) {
+		csi.write[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
+		if (_call_stack[i].function) {
+			csi.write[_debug_call_stack_pos - i - 1].func = _call_stack[i].function->get_name();
+			csi.write[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_path();
+		}
+	}
+	return csi;
+}
+
 /*************** RESOURCE ***************/
 
 Ref<Resource> ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index e4b12d4ddbe5..d58746ff0802 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -69,6 +69,7 @@ class GDScript : public Script {
 		GDScriptDataType data_type;
 	};
 
+	friend class GDScriptThreadContext;
 	friend class GDScriptInstance;
 	friend class GDScriptFunction;
 	friend class GDScriptAnalyzer;
@@ -78,13 +79,13 @@ class GDScript : public Script {
 
 	Ref<GDScriptNativeClass> native;
 	Ref<GDScript> base;
-	GDScript *_base = nullptr; //fast pointer access
-	GDScript *_owner = nullptr; //for subclasses
+	GDScript *_base = nullptr; // fast pointer access
+	GDScript *_owner = nullptr; // for subclasses
 
-	HashSet<StringName> members; //members are just indices to the instantiated script.
+	HashSet<StringName> members; // members are just indices to the instantiated script.
 	HashMap<StringName, Variant> constants;
 	HashMap<StringName, GDScriptFunction *> member_functions;
-	HashMap<StringName, MemberInfo> member_indices; //members are just indices to the instantiated script.
+	HashMap<StringName, MemberInfo> member_indices; // members are just indices to the instantiated script.
 	HashMap<StringName, Ref<GDScript>> subclasses;
 	HashMap<StringName, Vector<StringName>> _signals;
 	Dictionary rpc_config;
@@ -119,12 +120,12 @@ class GDScript : public Script {
 	HashMap<StringName, PropertyInfo> member_info;
 
 	GDScriptFunction *implicit_initializer = nullptr;
-	GDScriptFunction *initializer = nullptr; //direct pointer to new , faster to locate
+	GDScriptFunction *initializer = nullptr; // direct pointer to new , faster to locate
 	GDScriptFunction *implicit_ready = nullptr;
 
 	int subclass_count = 0;
 	RBSet<Object *> instances;
-	//exported members
+	// exported members
 	String source;
 	String path;
 	String name;
@@ -142,7 +143,7 @@ class GDScript : public Script {
 
 #ifdef TOOLS_ENABLED
 	HashSet<PlaceHolderScriptInstance *> placeholders;
-	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
+	// void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override;
 #endif
 
@@ -196,7 +197,7 @@ class GDScript : public Script {
 	Ref<GDScript> get_base() const;
 
 	const HashMap<StringName, MemberInfo> &debug_get_member_indices() const { return member_indices; }
-	const HashMap<StringName, GDScriptFunction *> &debug_get_member_functions() const; //this is debug only
+	const HashMap<StringName, GDScriptFunction *> &debug_get_member_functions() const; // this is debug only
 	StringName debug_get_member_by_index(int p_idx) const;
 
 	Variant _new(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
@@ -222,7 +223,7 @@ class GDScript : public Script {
 
 	virtual Error reload(bool p_keep_state = false) override;
 
-	void set_script_path(const String &p_path) { path = p_path; } //because subclasses need a path too...
+	void set_script_path(const String &p_path) { path = p_path; } // because subclasses need a path too...
 	Error load_source_code(const String &p_path);
 	Error load_byte_code(const String &p_path);
 
@@ -272,7 +273,7 @@ class GDScriptInstance : public ScriptInstance {
 	Object *owner = nullptr;
 	Ref<GDScript> script;
 #ifdef DEBUG_ENABLED
-	HashMap<StringName, int> member_indices_cache; //used only for hot script reloading
+	HashMap<StringName, int> member_indices_cache; // used only for hot script reloading
 #endif
 	Vector<Variant> members;
 	bool base_ref_counted;
@@ -313,7 +314,7 @@ class GDScriptInstance : public ScriptInstance {
 	~GDScriptInstance();
 };
 
-class GDScriptLanguage : public ScriptLanguage {
+class GDScriptLanguage final : public ScriptLanguage {
 	friend class GDScriptFunctionState;
 
 	static GDScriptLanguage *singleton;
@@ -323,21 +324,6 @@ class GDScriptLanguage : public ScriptLanguage {
 	HashMap<StringName, int> globals;
 	HashMap<StringName, Variant> named_globals;
 
-	struct CallLevel {
-		Variant *stack = nullptr;
-		GDScriptFunction *function = nullptr;
-		GDScriptInstance *instance = nullptr;
-		int *ip = nullptr;
-		int *line = nullptr;
-	};
-
-	int _debug_parse_err_line;
-	String _debug_parse_err_file;
-	String _debug_error;
-	int _debug_call_stack_pos;
-	int _debug_max_call_stack;
-	CallLevel *_call_stack = nullptr;
-
 	void _add_global(const StringName &p_name, const Variant &p_value);
 
 	friend class GDScriptInstance;
@@ -358,67 +344,8 @@ class GDScriptLanguage : public ScriptLanguage {
 public:
 	int calls;
 
-	bool debug_break(const String &p_error, bool p_allow_continue = true);
-	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
-
-	_FORCE_INLINE_ void enter_function(GDScriptInstance *p_instance, GDScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
-		if (Thread::get_main_id() != Thread::get_caller_id()) {
-			return; //no support for other threads than main for now
-		}
-
-		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0) {
-			EngineDebugger::get_script_debugger()->set_depth(EngineDebugger::get_script_debugger()->get_depth() + 1);
-		}
-
-		if (_debug_call_stack_pos >= _debug_max_call_stack) {
-			//stack overflow
-			_debug_error = vformat("Stack overflow (stack size: %s). Check for infinite recursion in your script.", _debug_max_call_stack);
-			EngineDebugger::get_script_debugger()->debug(this);
-			return;
-		}
-
-		_call_stack[_debug_call_stack_pos].stack = p_stack;
-		_call_stack[_debug_call_stack_pos].instance = p_instance;
-		_call_stack[_debug_call_stack_pos].function = p_function;
-		_call_stack[_debug_call_stack_pos].ip = p_ip;
-		_call_stack[_debug_call_stack_pos].line = p_line;
-		_debug_call_stack_pos++;
-	}
-
-	_FORCE_INLINE_ void exit_function() {
-		if (Thread::get_main_id() != Thread::get_caller_id()) {
-			return; //no support for other threads than main for now
-		}
-
-		if (EngineDebugger::get_script_debugger()->get_lines_left() > 0 && EngineDebugger::get_script_debugger()->get_depth() >= 0) {
-			EngineDebugger::get_script_debugger()->set_depth(EngineDebugger::get_script_debugger()->get_depth() - 1);
-		}
-
-		if (_debug_call_stack_pos == 0) {
-			_debug_error = "Stack Underflow (Engine Bug)";
-			EngineDebugger::get_script_debugger()->debug(this);
-			return;
-		}
-
-		_debug_call_stack_pos--;
-	}
-
-	virtual Vector<StackInfo> debug_get_current_stack_info() override {
-		if (Thread::get_main_id() != Thread::get_caller_id()) {
-			return Vector<StackInfo>();
-		}
-
-		Vector<StackInfo> csi;
-		csi.resize(_debug_call_stack_pos);
-		for (int i = 0; i < _debug_call_stack_pos; i++) {
-			csi.write[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
-			if (_call_stack[i].function) {
-				csi.write[_debug_call_stack_pos - i - 1].func = _call_stack[i].function->get_name();
-				csi.write[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_path();
-			}
-		}
-		return csi;
-	}
+	// configuration only consulted once when singleton is created, then directly accessed by created threads
+	SafeNumeric<int> max_call_stack;
 
 	struct {
 		StringName _init;
@@ -429,7 +356,6 @@ class GDScriptLanguage : public ScriptLanguage {
 		StringName _property_can_revert;
 		StringName _property_get_revert;
 		StringName _script_source;
-
 	} strings;
 
 	_FORCE_INLINE_ int get_global_array_size() const { return global_array.size(); }
@@ -442,7 +368,7 @@ class GDScriptLanguage : public ScriptLanguage {
 	virtual String get_name() const override;
 
 	/* LANGUAGE FUNCTIONS */
-	virtual void init() override;
+	virtual void init(int p_language_index) override;
 	virtual String get_type() const override;
 	virtual String get_extension() const override;
 	virtual Error execute_file(const String &p_path) override;
@@ -474,19 +400,6 @@ class GDScriptLanguage : public ScriptLanguage {
 	virtual void add_named_global_constant(const StringName &p_name, const Variant &p_value) override;
 	virtual void remove_named_global_constant(const StringName &p_name) override;
 
-	/* DEBUGGER FUNCTIONS */
-
-	virtual String debug_get_error() const override;
-	virtual int debug_get_stack_level_count() const override;
-	virtual int debug_get_stack_level_line(int p_level) const override;
-	virtual String debug_get_stack_level_function(int p_level) const override;
-	virtual String debug_get_stack_level_source(int p_level) const override;
-	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override;
-	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override;
-	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) override;
-	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override;
-	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1) override;
-
 	virtual void reload_all_scripts() override;
 	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) override;
 
@@ -514,10 +427,112 @@ class GDScriptLanguage : public ScriptLanguage {
 	void add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass);
 	Ref<GDScript> get_orphan_subclass(const String &p_qualified_name);
 
+	/* DEBUG FUNCTIONS */
+
+	void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override;
+	ScriptLanguageThreadContext &current_thread() override;
+
+	/* THREAD CONTEXT FACTORY */
+
+	static GDScriptThreadContext *create_thread_context();
+
 	GDScriptLanguage();
 	~GDScriptLanguage();
 };
 
+class GDScriptThreadContext : public ScriptLanguageThreadContext {
+	friend class GDScriptLanguage;
+
+	struct CallLevel {
+		Variant *stack = nullptr;
+		GDScriptFunction *function = nullptr;
+		GDScriptInstance *instance = nullptr;
+		int *ip = nullptr;
+		int *line = nullptr;
+	};
+
+	GDScriptLanguage &_parent;
+	DebugThreadID _debug_thread_id;
+	bool _is_main;
+
+	int _debug_parse_err_line;
+	String _debug_parse_err_file;
+	String _debug_error;
+	Severity _debug_error_severity = SEVERITY_NONE;
+	int _debug_call_stack_pos;
+	int _debug_max_call_stack;
+	CallLevel *_call_stack = nullptr;
+
+public:
+	void enter_function(GDScriptInstance *p_instance, GDScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
+		debug_record_enter_frame();
+
+		if (_debug_call_stack_pos >= _debug_max_call_stack) {
+			// stack overflow
+			_debug_error = vformat("Stack overflow (stack size: %s). Check for infinite recursion in your script.", _debug_max_call_stack);
+			_debug_error_severity = SEVERITY_FATAL;
+			EngineDebugger::get_script_debugger()->debug(*this);
+			return;
+		}
+
+		_call_stack[_debug_call_stack_pos].stack = p_stack;
+		_call_stack[_debug_call_stack_pos].instance = p_instance;
+		_call_stack[_debug_call_stack_pos].function = p_function;
+		_call_stack[_debug_call_stack_pos].ip = p_ip;
+		_call_stack[_debug_call_stack_pos].line = p_line;
+		_debug_call_stack_pos++;
+	}
+
+	void exit_function() {
+		debug_record_exit_frame();
+
+		if (_debug_call_stack_pos == 0) {
+			_debug_error = "Stack Underflow (Engine Bug)";
+			_debug_error_severity = SEVERITY_FATAL;
+			EngineDebugger::get_script_debugger()->debug(*this);
+			return;
+		}
+
+		_debug_call_stack_pos--;
+	}
+
+	// for indirect access by classes that can't see our thread
+	// local storage object
+	static GDScriptThreadContext &current();
+
+	GDScriptLanguage *get_language() const override {
+		return &_parent;
+	}
+
+	bool is_main_thread() const override;
+
+	bool debug_break(const String &p_error, Severity p_severity);
+	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
+
+	DebugThreadID debug_get_thread_id() const override;
+	Vector<StackInfo> debug_get_current_stack_info() const override;
+	String debug_get_error() const override;
+	Severity debug_get_error_severity() const override;
+	int debug_get_stack_level_count() const override;
+	int debug_get_stack_level_line(int p_level) const override;
+	String debug_get_stack_level_function(int p_level) const override;
+	String debug_get_stack_level_source(int p_level) const override;
+	void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override;
+	void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override;
+	ScriptInstance *debug_get_stack_level_instance(int p_level) const override;
+	String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1) const override;
+
+	~GDScriptThreadContext();
+
+	GDScriptThreadContext(const GDScriptThreadContext &) = delete;
+	GDScriptThreadContext(const GDScriptThreadContext &&) = delete;
+	GDScriptThreadContext &operator=(const GDScriptThreadContext &) = delete;
+	GDScriptThreadContext &operator=(const GDScriptThreadContext &&) = delete;
+
+private:
+	GDScriptThreadContext(GDScriptLanguage &p_parent, Thread::ID p_thread_id);
+};
+
 class ResourceFormatLoaderGDScript : public ResourceFormatLoader {
 public:
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 4c908166dfb5..70d9666821f9 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -212,40 +212,40 @@ Script *GDScriptLanguage::create_script() const {
 	return memnew(GDScript);
 }
 
-/* DEBUGGER FUNCTIONS */
-
-bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
+bool GDScriptThreadContext::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
 	// break because of parse error
-
 	if (EngineDebugger::is_active() && Thread::get_caller_id() == Thread::get_main_id()) {
 		_debug_parse_err_line = p_line;
 		_debug_parse_err_file = p_file;
 		_debug_error = p_error;
-		EngineDebugger::get_script_debugger()->debug(this, false, true);
+		_debug_error_severity = SEVERITY_FATAL;
+		EngineDebugger::get_script_debugger()->debug(*this);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
-bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
-	if (EngineDebugger::is_active() && Thread::get_caller_id() == Thread::get_main_id()) {
+bool GDScriptThreadContext::debug_break(const String &p_error, Severity p_severity) {
+	if (EngineDebugger::is_active()) {
 		_debug_parse_err_line = -1;
 		_debug_parse_err_file = "";
 		_debug_error = p_error;
-		bool is_error_breakpoint = p_error != "Breakpoint";
-		EngineDebugger::get_script_debugger()->debug(this, p_allow_continue, is_error_breakpoint);
+		_debug_error_severity = p_severity;
+		EngineDebugger::get_script_debugger()->debug(*this);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
-String GDScriptLanguage::debug_get_error() const {
+String GDScriptThreadContext::debug_get_error() const {
 	return _debug_error;
 }
 
-int GDScriptLanguage::debug_get_stack_level_count() const {
+ScriptLanguageThreadContext::Severity GDScriptThreadContext::debug_get_error_severity() const {
+	return _debug_error_severity;
+}
+
+int GDScriptThreadContext::debug_get_stack_level_count() const {
 	if (_debug_parse_err_line >= 0) {
 		return 1;
 	}
@@ -253,7 +253,7 @@ int GDScriptLanguage::debug_get_stack_level_count() const {
 	return _debug_call_stack_pos;
 }
 
-int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
+int GDScriptThreadContext::debug_get_stack_level_line(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_line;
 	}
@@ -265,7 +265,7 @@ int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
 	return *(_call_stack[l].line);
 }
 
-String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
+String GDScriptThreadContext::debug_get_stack_level_function(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return "";
 	}
@@ -275,7 +275,7 @@ String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
 	return _call_stack[l].function->get_name();
 }
 
-String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
+String GDScriptThreadContext::debug_get_stack_level_source(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_file;
 	}
@@ -285,7 +285,7 @@ String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
 	return _call_stack[l].function->get_source();
 }
 
-void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+void GDScriptThreadContext::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const {
 	if (_debug_parse_err_line >= 0) {
 		return;
 	}
@@ -304,7 +304,7 @@ void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p
 	}
 }
 
-void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+void GDScriptThreadContext::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const {
 	if (_debug_parse_err_line >= 0) {
 		return;
 	}
@@ -329,7 +329,7 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *
 	}
 }
 
-ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
+ScriptInstance *GDScriptThreadContext::debug_get_stack_level_instance(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return nullptr;
 	}
@@ -342,7 +342,7 @@ ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
 	return instance;
 }
 
-void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const {
 	const HashMap<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
 	const Variant *globals = GDScriptLanguage::get_singleton()->get_global_array();
 
@@ -388,7 +388,7 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 	}
 }
 
-String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
+String GDScriptThreadContext::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) const {
 	return "";
 }
 
@@ -2995,7 +2995,7 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 
 		String st = l.substr(tc, l.length()).strip_edges();
 		if (st.is_empty() || st.begins_with("#")) {
-			continue; //ignore!
+			continue; // ignore!
 		}
 
 		int ilevel = 0;
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index cd3b7d69c57e..e5fc3bd18df1 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -172,7 +172,7 @@ Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_ar
 		r_error.argument = 1;
 		return Variant();
 	} else if (p_argcount == 1) {
-		//noooneee
+		// noooneee
 	} else if (p_argcount == 2) {
 		arg = *p_args[0];
 	} else {
@@ -256,7 +256,7 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 		}
 	}
 
-	function = nullptr; //cleaned up;
+	function = nullptr; // cleaned up;
 	state.result = Variant();
 
 	if (completed) {
@@ -268,7 +268,7 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 
 #ifdef DEBUG_ENABLED
 		if (EngineDebugger::is_active()) {
-			GDScriptLanguage::get_singleton()->exit_function();
+			GDScriptThreadContext::current().exit_function();
 		}
 
 		_clear_stack();
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index e44038d6da3b..e0bc3fe99c6e 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -40,6 +40,7 @@
 #include "core/variant/variant.h"
 #include "gdscript_utility_functions.h"
 
+class GDScriptThreadContext;
 class GDScriptInstance;
 class GDScript;
 
@@ -557,7 +558,7 @@ class GDScriptFunction {
 
 	_FORCE_INLINE_ bool is_static() const { return _static; }
 
-	const int *get_code() const; //used for debug
+	const int *get_code() const; // used for debug
 	int get_code_size() const;
 	Variant get_constant(int p_idx) const;
 	StringName get_global_name(int p_idx) const;
diff --git a/modules/gdscript/gdscript_utility_functions.cpp b/modules/gdscript/gdscript_utility_functions.cpp
index bcbe8b8d2bd2..6a08ff6d25c4 100644
--- a/modules/gdscript/gdscript_utility_functions.cpp
+++ b/modules/gdscript/gdscript_utility_functions.cpp
@@ -439,13 +439,11 @@ struct GDScriptUtilityFunctionsDefinitions {
 			s += p_args[i]->operator String();
 		}
 
-		if (Thread::get_caller_id() == Thread::get_main_id()) {
-			ScriptLanguage *script = GDScriptLanguage::get_singleton();
-			if (script->debug_get_stack_level_count() > 0) {
-				s += "\n   At: " + script->debug_get_stack_level_source(0) + ":" + itos(script->debug_get_stack_level_line(0)) + ":" + script->debug_get_stack_level_function(0) + "()";
-			}
-		} else {
-			s += "\n   At: Cannot retrieve debug info outside the main thread. Thread ID: " + itos(Thread::get_caller_id());
+		GDScriptThreadContext &stack = GDScriptThreadContext::current();
+		if (stack.debug_get_stack_level_count() > 0) {
+			s += "\n   At: " + stack.debug_get_stack_level_source(0) + ":" +
+					itos(stack.debug_get_stack_level_line(0)) + ":" +
+					stack.debug_get_stack_level_function(0) + "()";
 		}
 
 		print_line(s);
@@ -454,32 +452,25 @@ struct GDScriptUtilityFunctionsDefinitions {
 
 	static inline void print_stack(Variant *r_ret, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) {
 		VALIDATE_ARG_COUNT(0);
-		if (Thread::get_caller_id() != Thread::get_main_id()) {
-			print_line("Cannot retrieve debug info outside the main thread. Thread ID: " + itos(Thread::get_caller_id()));
-			return;
-		}
-
-		ScriptLanguage *script = GDScriptLanguage::get_singleton();
-		for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
-			print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
+		GDScriptThreadContext &stack = GDScriptThreadContext::current();
+		for (int i = 0; i < stack.debug_get_stack_level_count(); i++) {
+			print_line("Frame " + itos(i) + " - " + stack.debug_get_stack_level_source(i) +
+					":" + itos(stack.debug_get_stack_level_line(i)) + " in function '" +
+					stack.debug_get_stack_level_function(i) + "'");
 		};
 		*r_ret = Variant();
 	}
 
 	static inline void get_stack(Variant *r_ret, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) {
 		VALIDATE_ARG_COUNT(0);
-		if (Thread::get_caller_id() != Thread::get_main_id()) {
-			*r_ret = TypedArray<Dictionary>();
-			return;
-		}
 
-		ScriptLanguage *script = GDScriptLanguage::get_singleton();
+		GDScriptThreadContext &stack = GDScriptThreadContext::current();
 		TypedArray<Dictionary> ret;
-		for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
+		for (int i = 0; i < stack.debug_get_stack_level_count(); i++) {
 			Dictionary frame;
-			frame["source"] = script->debug_get_stack_level_source(i);
-			frame["function"] = script->debug_get_stack_level_function(i);
-			frame["line"] = script->debug_get_stack_level_line(i);
+			frame["source"] = stack.debug_get_stack_level_source(i);
+			frame["function"] = stack.debug_get_stack_level_function(i);
+			frame["line"] = stack.debug_get_stack_level_line(i);
 			ret.push_back(frame);
 		};
 		*r_ret = ret;
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 61e2c61abcff..6e103b1dba5d 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -38,7 +38,7 @@
 Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_instance, Variant *p_stack, String &r_error) const {
 	int address = p_address & ADDR_MASK;
 
-	//sequential table (jump table generated by compiler)
+	// sequential table (jump table generated by compiler)
 	switch ((p_address & ADDR_TYPE_MASK) >> ADDR_BITS) {
 		case ADDR_TYPE_STACK: {
 #ifdef DEBUG_ENABLED
@@ -59,7 +59,7 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 				return nullptr;
 			}
 #endif
-			//member indexing is O(1)
+			// member indexing is O(1)
 			return &p_instance->members.write[address];
 		} break;
 	}
@@ -490,7 +490,12 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 #ifdef DEBUG_ENABLED
 
-	//GDScriptLanguage::get_singleton()->calls++;
+	// GDScriptLanguage::get_singleton()->calls++;
+
+	// Shorter names for current implementations of various concepts.
+	// Also intentionally makes code that uses these not compile in release builds.
+	using Severity = ScriptLanguageThreadContext;
+	using Stack = GDScriptThreadContext;
 
 #endif
 
@@ -500,9 +505,9 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 	int line = _initial_line;
 
 	if (p_state) {
-		//use existing (supplied) state (awaited)
+		// use existing (supplied) state (awaited)
 		stack = (Variant *)p_state->stack.ptr();
-		instruction_args = (Variant **)&p_state->stack.ptr()[sizeof(Variant) * p_state->stack_size]; //ptr() to avoid bounds check
+		instruction_args = (Variant **)&p_state->stack.ptr()[sizeof(Variant) * p_state->stack_size]; // ptr() to avoid bounds check
 		line = p_state->line;
 		ip = p_state->ip;
 		alloca_size = p_state->stack.size();
@@ -593,7 +598,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 #ifdef DEBUG_ENABLED
 
 	if (EngineDebugger::is_active()) {
-		GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
+		Stack::current().enter_function(p_instance, this, stack, &ip, &line);
 	}
 
 #define GD_ERR_BREAK(m_cond)                                                                                           \
@@ -643,6 +648,10 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 #ifdef DEBUG_ENABLED
 	OPCODE_WHILE(ip < _code_size) {
 		int last_opcode = _code_ptr[ip] & INSTR_MASK;
+		if (EngineDebugger::is_active()) {
+			// Step execute if this thread is being held.  Will block as long as held by debugger.
+			EngineDebugger::get_script_debugger()->step(Stack::current());
+		}
 #else
 	OPCODE_WHILE(true) {
 #endif
@@ -675,7 +684,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 #ifdef DEBUG_ENABLED
 				if (!valid) {
 					if (ret.get_type() == Variant::STRING) {
-						//return a string when invalid with the error
+						// return a string when invalid with the error
 						err_text = ret;
 						err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
 					} else {
@@ -746,15 +755,15 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					GDScript *scr_B = Object::cast_to<GDScript>(obj_B);
 
 					if (scr_B) {
-						//if B is a script, the only valid condition is that A has an instance which inherits from the script
-						//in other situation, this should return false.
+						// if B is a script, the only valid condition is that A has an instance which inherits from the script
+						// in other situation, this should return false.
 
 						if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) {
 							GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr());
-							//bool found=false;
+							// bool found=false;
 							while (cmp) {
 								if (cmp == scr_B) {
-									//inherits from script, all ok
+									// inherits from script, all ok
 									extends_ok = true;
 									break;
 								}
@@ -1036,7 +1045,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 				bool valid;
 #ifdef DEBUG_ENABLED
-				//allow better error message in cases where src and dst are the same stack position
+				// allow better error message in cases where src and dst are the same stack position
 				Variant ret = src->get_named(*index, valid);
 
 #else
@@ -2974,7 +2983,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 						OPCODE_BREAK;
 					}
 #endif
-					ip += 5; //loop again
+					ip += 5; // loop again
 				}
 			}
 			DISPATCH_OPCODE;
@@ -3380,7 +3389,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			OPCODE(OPCODE_BREAKPOINT) {
 #ifdef DEBUG_ENABLED
 				if (EngineDebugger::is_active()) {
-					GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
+					Stack::current().debug_break("Breakpoint Statement", Severity::SEVERITY_BREAKPOINT_STATEMENT);
 				}
 #endif
 				ip += 1;
@@ -3393,29 +3402,21 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				line = _code_ptr[ip + 1];
 				ip += 2;
 
+#ifdef DEBUG_ENABLED
 				if (EngineDebugger::is_active()) {
-					// line
-					bool do_break = false;
-
-					if (EngineDebugger::get_script_debugger()->get_lines_left() > 0) {
-						if (EngineDebugger::get_script_debugger()->get_depth() <= 0) {
-							EngineDebugger::get_script_debugger()->set_lines_left(EngineDebugger::get_script_debugger()->get_lines_left() - 1);
-						}
-						if (EngineDebugger::get_script_debugger()->get_lines_left() <= 0) {
-							do_break = true;
-						}
-					}
+					bool do_break = Stack::current().debug_record_step_taken();
 
 					if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source)) {
 						do_break = true;
 					}
 
 					if (do_break) {
-						GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
+						Stack::current().debug_break("Breakpoint", Severity::SEVERITY_BREAKPOINT);
 					}
 
 					EngineDebugger::get_singleton()->line_poll();
 				}
+#endif
 			}
 			DISPATCH_OPCODE;
 
@@ -3426,7 +3427,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				OPCODE_BREAK;
 			}
 
-#if 0 // Enable for debugging.
+#if 0 // Enable for debugging of the VM during development only.
 			default: {
 				err_text = "Illegal opcode " + itos(_code_ptr[ip]) + " at address " + itos(ip);
 				OPCODE_BREAK;
@@ -3439,8 +3440,8 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 		if (exit_ok) {
 			OPCODE_OUT;
 		}
-		//error
-		// function, file, line, error, explanation
+		// error
+		//  function, file, line, error, explanation
 		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;
@@ -3459,7 +3460,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			err_text = "Internal script error! Opcode: " + itos(last_opcode) + " (please report).";
 		}
 
-		if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
+		if (!Stack::current().debug_break(err_text, Severity::SEVERITY_FATAL)) {
 			// debugger break did not happen
 
 			_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), false, ERR_HANDLER_SCRIPT);
@@ -3488,7 +3489,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 	// This ensures the call stack can be properly shown when using `await`, showing what resumed the function.
 	if (!p_state || awaited) {
 		if (EngineDebugger::is_active()) {
-			GDScriptLanguage::get_singleton()->exit_function();
+			Stack::current().exit_function();
 		}
 #endif
 
diff --git a/modules/gdscript/tests/gdscript_test_runner.cpp b/modules/gdscript/tests/gdscript_test_runner.cpp
index 6c346acb7ecd..c3e583f041af 100644
--- a/modules/gdscript/tests/gdscript_test_runner.cpp
+++ b/modules/gdscript/tests/gdscript_test_runner.cpp
@@ -110,7 +110,7 @@ void init_language(const String &p_base_path) {
 	}
 
 	// Initialize the language for the test routine.
-	GDScriptLanguage::get_singleton()->init();
+	GDScriptLanguage::get_singleton()->init(0);
 	init_autoloads();
 }
 
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index 2e59987fe6df..ddea180819c4 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -54,6 +54,7 @@
 #include "class_db_api_json.h"
 #endif
 
+#include "core/object/script_language_internals.h"
 #include "godotsharp_dirs.h"
 #include "managed_callable.h"
 #include "mono_gd/gd_mono_cache.h"
@@ -72,6 +73,27 @@ static bool _create_project_solution_if_needed() {
 
 CSharpLanguage *CSharpLanguage::singleton = nullptr;
 
+// This gets initialized for each thread.  If debugging is enabled, it will be
+// accessed and will lazy create a thread local storage context for that thread.
+thread_local ThreadContextRef<CSharpLanguage, CSharpThreadContext> t_current_thread;
+
+// virtual
+ScriptLanguageThreadContext &CSharpLanguage::current_thread() {
+	return t_current_thread.context();
+}
+
+// Privileged access to implementation for local utility code.
+CSharpThreadContext &CSharpLanguage::current_thread_implementation() {
+	return t_current_thread.context();
+}
+
+CSharpThreadContext *CSharpLanguage::create_thread_context() {
+	return memnew(CSharpThreadContext(
+			*singleton,
+			ScriptLanguageInternals::create_thread_id(*singleton, Thread::get_caller_id()),
+			Thread::get_caller_id() == Thread::get_main_id()));
+}
+
 GDNativeInstanceBindingCallbacks CSharpLanguage::_instance_binding_callbacks = {
 	&_instance_binding_create_callback,
 	&_instance_binding_free_callback,
@@ -95,7 +117,8 @@ Error CSharpLanguage::execute_file(const String &p_path) {
 	return OK;
 }
 
-void CSharpLanguage::init() {
+void CSharpLanguage::init(int p_language_index) {
+	ScriptLanguage::init(p_language_index);
 #ifdef DEBUG_METHODS_ENABLED
 	if (OS::get_singleton()->get_cmdline_args().find("--class-db-json")) {
 		class_db_api_to_json("user://class_db_api.json", ClassDB::API_CORE);
@@ -530,71 +553,92 @@ String CSharpLanguage::_get_indentation() const {
 	return "\t";
 }
 
-String CSharpLanguage::debug_get_error() const {
+ScriptLanguage *CSharpThreadContext::get_language() const {
+	return &parent;
+}
+
+bool CSharpThreadContext::is_main_thread() const {
+	return is_main;
+}
+
+String CSharpThreadContext::debug_get_error() const {
 	return _debug_error;
 }
 
-int CSharpLanguage::debug_get_stack_level_count() const {
-	if (_debug_parse_err_line >= 0) {
-		return 1;
-	}
+int CSharpThreadContext::debug_get_stack_level_count() const {
+	return _get_current_stack_info().size();
+}
 
-	// TODO: StackTrace
-	return 1;
+int CSharpThreadContext::debug_get_stack_level_line(int p_level) const {
+	return _get_current_stack_info()[p_level].line;
 }
 
-int CSharpLanguage::debug_get_stack_level_line(int p_level) const {
-	if (_debug_parse_err_line >= 0) {
-		return _debug_parse_err_line;
-	}
+String CSharpThreadContext::debug_get_stack_level_function(int p_level) const {
+	return _get_current_stack_info()[p_level].func;
+}
 
-	// TODO: StackTrace
-	return 1;
+String CSharpThreadContext::debug_get_stack_level_source(int p_level) const {
+	return _get_current_stack_info()[p_level].file;
 }
 
-String CSharpLanguage::debug_get_stack_level_function(int p_level) const {
-	if (_debug_parse_err_line >= 0) {
-		return String();
-	}
+using StackInfo = ScriptLanguageThreadContext::StackInfo;
 
-	// TODO: StackTrace
-	return String();
+Vector<StackInfo> CSharpThreadContext::debug_get_current_stack_info() const {
+	return _get_current_stack_info();
 }
 
-String CSharpLanguage::debug_get_stack_level_source(int p_level) const {
-	if (_debug_parse_err_line >= 0) {
-		return _debug_parse_err_file;
-	}
+ScriptLanguageThreadContext::DebugThreadID CSharpThreadContext::debug_get_thread_id() const {
+	return debug_thread_id;
+}
 
-	// TODO: StackTrace
-	return String();
+ScriptLanguageThreadContext::Severity CSharpThreadContext::debug_get_error_severity() const {
+	return _debug_severity;
+}
+
+void CSharpThreadContext::wait_resume() const {
+	// Prepare stack frame for access by other threads while we are paused.
+	stack_trace_cached = false;
+	(void)_get_current_stack_info();
+	ScriptLanguageThreadContext::wait_resume();
 }
 
-Vector<ScriptLanguage::StackInfo> CSharpLanguage::debug_get_current_stack_info() {
+const Vector<StackInfo> &CSharpThreadContext::_get_current_stack_info() const {
 #ifdef DEBUG_ENABLED
 	// Printing an error here will result in endless recursion, so we must be careful
 	static thread_local bool _recursion_flag_ = false;
 	if (_recursion_flag_) {
-		return Vector<StackInfo>();
+		stack_trace_cache.clear();
+		return stack_trace_cache;
 	}
 	_recursion_flag_ = true;
 	SCOPE_EXIT {
 		_recursion_flag_ = false;
 	};
 
-	if (!gdmono->is_runtime_initialized()) {
-		return Vector<StackInfo>();
+	if (stack_trace_cached) {
+		return stack_trace_cache;
+	}
+
+	if (!GDMonoCache::godot_api_cache_updated) {
+		stack_trace_cache.clear();
+		return stack_trace_cache;
 	}
 
-	Vector<StackInfo> si;
+	if (tid != Thread::get_caller_id()) {
+		// TODO we need to use the soft debugger API to implement real debugging, so for now we store the stack every pause
+		// Cannot read the stack from another thread (does not normally happen.)
+		stack_trace_cache.clear();
+		return stack_trace_cache;
+	}
 
 	if (GDMonoCache::godot_api_cache_updated) {
-		GDMonoCache::managed_callbacks.DebuggingUtils_GetCurrentStackInfo(&si);
+		GDMonoCache::managed_callbacks.DebuggingUtils_GetCurrentStackInfo(&stack_trace_cache);
 	}
 
-	return si;
+	stack_trace_cached = true;
+	return stack_trace_cache;
 #else
-	return Vector<StackInfo>();
+	return stack_trace_cache;
 #endif
 }
 
@@ -1039,30 +1083,70 @@ bool CSharpLanguage::overrides_external_editor() {
 }
 #endif
 
-bool CSharpLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
+using Severity = ScriptLanguageThreadContext;
+
+#ifdef DEBUG_ENABLED
+bool CSharpThreadContext::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
 	// Not a parser error in our case, but it's still used for other type of errors
 	if (EngineDebugger::is_active() && Thread::get_caller_id() == Thread::get_main_id()) {
 		_debug_parse_err_line = p_line;
 		_debug_parse_err_file = p_file;
 		_debug_error = p_error;
-		EngineDebugger::get_script_debugger()->debug(this, false, true);
+		_debug_severity = Severity::SEVERITY_FATAL;
+		EngineDebugger::get_script_debugger()->debug(*this);
 		return true;
 	} else {
 		return false;
 	}
 }
 
-bool CSharpLanguage::debug_break(const String &p_error, bool p_allow_continue) {
-	if (EngineDebugger::is_active() && Thread::get_caller_id() == Thread::get_main_id()) {
+void CSharpThreadContext::debug_enter_runtime() {
+	_debug_severity = SEVERITY_NONE;
+	stack_trace_cached = false;
+	debug_record_enter_frame();
+}
+
+void CSharpThreadContext::debug_exit_runtime() {
+	// Potentially block in the debugger.
+	EngineDebugger::get_script_debugger()->step(*this);
+
+	// Check if we are supposed to break.
+	debug_record_exit_frame();
+	bool do_break = debug_record_step_taken();
+	// FIXME get these from mono runtime
+	int line = 1;
+	StringName source;
+	if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source)) {
+		do_break = true;
+	}
+	if (do_break) {
+		debug_break("Breakpoint", SEVERITY_BREAKPOINT);
+	}
+}
+
+bool CSharpThreadContext::debug_break(const String &p_error, Severity p_severity) {
+	if (EngineDebugger::is_active()) {
 		_debug_parse_err_line = -1;
 		_debug_parse_err_file = "";
 		_debug_error = p_error;
-		EngineDebugger::get_script_debugger()->debug(this, p_allow_continue);
+		_debug_severity = p_severity;
+		EngineDebugger::get_script_debugger()->debug(*this);
 		return true;
-	} else {
-		return false;
 	}
+	return false;
+}
+
+void CSharpThreadContext::debug_set_stack_trace_override(const Vector<StackInfo> &p_stack, const String &p_error) {
+	has_stack_trace_override = true;
+	stack_trace_override = p_stack;
+	_debug_error = p_error;
+}
+
+void CSharpThreadContext::debug_clear_stack_trace_override() {
+	has_stack_trace_override = false;
+	stack_trace_override.clear();
 }
+#endif
 
 void CSharpLanguage::_on_scripts_domain_about_to_unload() {
 #ifdef GD_MONO_HOT_RELOAD
@@ -1101,11 +1185,6 @@ void CSharpLanguage::_editor_init_callback() {
 }
 #endif
 
-void CSharpLanguage::set_language_index(int p_idx) {
-	ERR_FAIL_COND(lang_idx != -1);
-	lang_idx = p_idx;
-}
-
 void CSharpLanguage::release_script_gchandle(MonoGCHandleData &p_gchandle) {
 	if (!p_gchandle.is_released()) { // Do not lock unnecessarily
 		MutexLock lock(get_singleton()->script_gchandle_release_mutex);
@@ -2358,11 +2437,13 @@ ScriptInstance *CSharpScript::instance_create(Object *p_this) {
 	ERR_FAIL_COND_V(native_name == StringName(), nullptr);
 
 	if (!ClassDB::is_parent_class(p_this->get_class_name(), native_name)) {
+#ifdef DEBUG_ENABLED
 		if (EngineDebugger::is_active()) {
-			CSharpLanguage::get_singleton()->debug_break_parse(get_path(), 0,
+			CSharpLanguage::current_thread_implementation().debug_break_parse(get_path(), 0,
 					"Script inherits from native type '" + String(native_name) +
 							"', so it can't be instantiated in object of type: '" + p_this->get_class() + "'");
 		}
+#endif
 		ERR_FAIL_V_MSG(nullptr, "Script inherits from native type '" + String(native_name) + "', so it can't be instantiated in object of type: '" + p_this->get_class() + "'.");
 	}
 
diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h
index 3509a5c87d89..878e7ecf5916 100644
--- a/modules/mono/csharp_script.h
+++ b/modules/mono/csharp_script.h
@@ -296,16 +296,21 @@ struct CSharpScriptBinding {
 	MonoGCHandleData gchandle;
 	Object *owner = nullptr;
 
-	CSharpScriptBinding() {}
+	CSharpScriptBinding() = default;
 };
 
 class ManagedCallableMiddleman : public Object {
 	GDCLASS(ManagedCallableMiddleman, Object);
 };
 
+class CSharpThreadContext;
+
 class CSharpLanguage : public ScriptLanguage {
+	using StackInfo = ScriptLanguageThreadContext::StackInfo;
+
 	friend class CSharpScript;
 	friend class CSharpInstance;
+	friend class CSharpThreadContext;
 
 	static CSharpLanguage *singleton;
 
@@ -337,13 +342,6 @@ class CSharpLanguage : public ScriptLanguage {
 		StringNameCache();
 	};
 
-	int lang_idx = -1;
-
-	// For debug_break and debug_break_parse
-	int _debug_parse_err_line = -1;
-	String _debug_parse_err_file;
-	String _debug_error;
-
 	friend class GDMono;
 	void _on_scripts_domain_about_to_unload();
 
@@ -374,10 +372,7 @@ class CSharpLanguage : public ScriptLanguage {
 		return script_instances_mutex;
 	}
 
-	_FORCE_INLINE_ int get_language_index() {
-		return lang_idx;
-	}
-	void set_language_index(int p_idx);
+	_FORCE_INLINE_ int get_language_index() { return language_index; }
 
 	_FORCE_INLINE_ const StringNameCache &get_string_names() {
 		return string_names;
@@ -397,9 +392,6 @@ class CSharpLanguage : public ScriptLanguage {
 	static void release_script_gchandle_thread_safe(GCHandleIntPtr p_gchandle_to_free, MonoGCHandleData &r_gchandle);
 	static void release_binding_gchandle_thread_safe(GCHandleIntPtr p_gchandle_to_free, CSharpScriptBinding &r_script_binding);
 
-	bool debug_break(const String &p_error, bool p_allow_continue = true);
-	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
-
 #ifdef GD_MONO_HOT_RELOAD
 	bool is_assembly_reloading_needed();
 	void reload_assemblies(bool p_soft_reload);
@@ -415,7 +407,7 @@ class CSharpLanguage : public ScriptLanguage {
 	String get_type() const override;
 	String get_extension() const override;
 	Error execute_file(const String &p_path) override;
-	void init() override;
+	void init(int p_language_index) override;
 	void finish() override;
 
 	void finalize();
@@ -444,29 +436,11 @@ class CSharpLanguage : public ScriptLanguage {
 	/* TODO? */ void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override {}
 	/* TODO */ void add_global_constant(const StringName &p_variable, const Variant &p_value) override {}
 
-	/* DEBUGGER FUNCTIONS */
-	String debug_get_error() const override;
-	int debug_get_stack_level_count() const override;
-	int debug_get_stack_level_line(int p_level) const override;
-	String debug_get_stack_level_function(int p_level) const override;
-	String debug_get_stack_level_source(int p_level) const override;
-	/* TODO */ void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	/* TODO */ void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	/* TODO */ void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
-	/* TODO */ String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) override {
-		return "";
-	}
-	Vector<StackInfo> debug_get_current_stack_info() override;
-
 	/* PROFILING FUNCTIONS */
 	/* TODO */ void profiling_start() override {}
 	/* TODO */ void profiling_stop() override {}
-	/* TODO */ int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override {
-		return 0;
-	}
-	/* TODO */ int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override {
-		return 0;
-	}
+	/* TODO */ int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override { return 0; }
+	/* TODO */ int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override { return 0; }
 
 	void frame() override;
 
@@ -495,10 +469,83 @@ class CSharpLanguage : public ScriptLanguage {
 	void post_unsafe_reference(Object *p_obj);
 	void pre_unsafe_unreference(Object *p_obj);
 
+	/* DEBUG FUNCTIONS */
+
+	/* TODO */ void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) const override{};
+	ScriptLanguageThreadContext &current_thread() override;
+	static CSharpThreadContext &current_thread_implementation();
+
+	/* THREAD CONTEXT FACTORY */
+
+	static CSharpThreadContext *create_thread_context();
+
 	CSharpLanguage();
 	~CSharpLanguage();
 };
 
+class CSharpThreadContext : public ScriptLanguageThreadContext {
+	friend class CSharpLanguage;
+
+	int _debug_parse_err_line = -1;
+	String _debug_parse_err_file;
+	String _debug_error;
+	Severity _debug_severity = SEVERITY_NONE;
+	CSharpLanguage &parent;
+	DebugThreadID debug_thread_id;
+	bool is_main;
+	bool has_stack_trace_override;
+
+	Vector<StackInfo> stack_trace_override;
+	mutable Vector<StackInfo> stack_trace_cache;
+	mutable bool stack_trace_cached = false;
+
+	const Vector<StackInfo> &_get_current_stack_info() const;
+
+public:
+	ScriptLanguage *get_language() const override;
+	bool is_main_thread() const override;
+
+	/* DEBUG INFO FUNCTIONS */
+
+	String debug_get_error() const override;
+	int debug_get_stack_level_count() const override;
+	int debug_get_stack_level_line(int p_level) const override;
+	String debug_get_stack_level_function(int p_level) const override;
+	String debug_get_stack_level_source(int p_level) const override;
+	/* TODO */ void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const override {}
+	/* TODO */ void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) const override {}
+	/* TODO */ String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) const override { return ""; }
+	Vector<StackInfo> debug_get_current_stack_info() const override;
+	DebugThreadID debug_get_thread_id() const override;
+	Severity debug_get_error_severity() const override;
+
+	void wait_resume() const override;
+
+#ifdef DEBUG_ENABLED
+	// Set a specific stack trace to use instead of the current thread state.  Used during exception
+	// reporting.
+	void debug_set_stack_trace_override(const Vector<StackInfo> &p_stack, const String &p_error);
+
+	void debug_clear_stack_trace_override();
+
+	bool debug_break(const String &p_error, Severity p_severity);
+	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
+
+	// Called when the C# thread is about to execute, so the stack will be changing.
+	void debug_enter_runtime();
+
+	// Called after the C# thread has executed some code, to allow the debugger to block or break, if necessary.
+	void debug_exit_runtime();
+#endif
+
+	CSharpThreadContext(CSharpLanguage &p_parent, const DebugThreadID &p_debug_thread_id, bool p_is_main) :
+			parent(p_parent) {
+		debug_thread_id = p_debug_thread_id;
+		is_main = p_is_main;
+		has_stack_trace_override = false;
+	}
+};
+
 class ResourceFormatLoaderCSharpScript : public ResourceFormatLoader {
 public:
 	Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
diff --git a/modules/mono/glue/runtime_interop.cpp b/modules/mono/glue/runtime_interop.cpp
index 276701cdaab7..848c8f3f2e04 100644
--- a/modules/mono/glue/runtime_interop.cpp
+++ b/modules/mono/glue/runtime_interop.cpp
@@ -50,6 +50,8 @@
 extern "C" {
 #endif
 
+using StackInfo = ScriptLanguageThreadContext::StackInfo;
+
 // For ArrayPrivate and DictionaryPrivate
 static_assert(sizeof(SafeRefCount) == sizeof(uint32_t));
 
@@ -72,20 +74,29 @@ Object *godotsharp_engine_get_singleton(const String *p_name) {
 }
 
 int32_t godotsharp_stack_info_vector_resize(
-		Vector<ScriptLanguage::StackInfo> *p_stack_info_vector, int p_size) {
+		Vector<StackInfo> *p_stack_info_vector, int p_size) {
 	return (int32_t)p_stack_info_vector->resize(p_size);
 }
 
 void godotsharp_stack_info_vector_destroy(
-		Vector<ScriptLanguage::StackInfo> *p_stack_info_vector) {
+		Vector<StackInfo> *p_stack_info_vector) {
 	p_stack_info_vector->~Vector();
 }
 
 void godotsharp_internal_script_debugger_send_error(const String *p_func,
 		const String *p_file, int32_t p_line, const String *p_err, const String *p_descr,
-		bool p_warning, const Vector<ScriptLanguage::StackInfo> *p_stack_info_vector) {
-	EngineDebugger::get_script_debugger()->send_error(*p_func, *p_file, p_line, *p_err, *p_descr,
-			true, p_warning ? ERR_HANDLER_WARNING : ERR_HANDLER_ERROR, *p_stack_info_vector);
+		bool p_warning, const Vector<StackInfo> *p_stack_info_vector) {
+#ifdef DEBUG_ENABLED
+	if (!EngineDebugger::is_active()) {
+		return;
+	}
+	// Set the current thread's context to have the specified stack temporarily, so debugger will send it.
+	CSharpLanguage::current_thread_implementation().debug_set_stack_trace_override(*p_stack_info_vector, *p_err);
+	// Engine debugger will query our thread context via ScriptDebugger
+	EngineDebugger::get_singleton()->send_error(*p_func, *p_file, p_line, *p_err, *p_descr,
+			true, p_warning ? ERR_HANDLER_WARNING : ERR_HANDLER_ERROR);
+	CSharpLanguage::current_thread_implementation().debug_clear_stack_trace_override();
+#endif
 }
 
 bool godotsharp_internal_script_debugger_is_active() {
diff --git a/modules/mono/mono_gd/gd_mono_cache.h b/modules/mono/mono_gd/gd_mono_cache.h
index ca3a6c95a715..f60f9e61a0d3 100644
--- a/modules/mono/mono_gd/gd_mono_cache.h
+++ b/modules/mono/mono_gd/gd_mono_cache.h
@@ -100,7 +100,7 @@ struct ManagedCallbacks {
 	using FuncCSharpInstanceBridge_SerializeState = void(GD_CLR_STDCALL *)(GCHandleIntPtr, const Dictionary *, const Dictionary *);
 	using FuncCSharpInstanceBridge_DeserializeState = void(GD_CLR_STDCALL *)(GCHandleIntPtr, const Dictionary *, const Dictionary *);
 	using FuncGCHandleBridge_FreeGCHandle = void(GD_CLR_STDCALL *)(GCHandleIntPtr);
-	using FuncDebuggingUtils_GetCurrentStackInfo = void(GD_CLR_STDCALL *)(Vector<ScriptLanguage::StackInfo> *);
+	using FuncDebuggingUtils_GetCurrentStackInfo = void(GD_CLR_STDCALL *)(Vector<ScriptLanguageThreadContext::StackInfo> *);
 	using FuncDisposablesTracker_OnGodotShuttingDown = void(GD_CLR_STDCALL *)();
 	using FuncGD_OnCoreApiAssemblyLoaded = void(GD_CLR_STDCALL *)(bool);
 
diff --git a/modules/mono/register_types.cpp b/modules/mono/register_types.cpp
index 755e1f7a3003..297a6f656208 100644
--- a/modules/mono/register_types.cpp
+++ b/modules/mono/register_types.cpp
@@ -53,7 +53,6 @@ void initialize_mono_module(ModuleInitializationLevel p_level) {
 	Engine::get_singleton()->add_singleton(Engine::Singleton("GodotSharp", mono_bind::GodotSharp::get_singleton()));
 
 	script_language_cs = memnew(CSharpLanguage);
-	script_language_cs->set_language_index(ScriptServer::get_language_count());
 	ScriptServer::register_language(script_language_cs);
 
 	resource_loader_cs.instantiate();
diff --git a/modules/websocket/remote_debugger_peer_websocket.cpp b/modules/websocket/remote_debugger_peer_websocket.cpp
index f703873cbfa2..204c5c8a0110 100644
--- a/modules/websocket/remote_debugger_peer_websocket.cpp
+++ b/modules/websocket/remote_debugger_peer_websocket.cpp
@@ -53,7 +53,10 @@ bool RemoteDebuggerPeerWebSocket::is_peer_connected() {
 	return ws_peer.is_valid() && ws_peer->is_connected_to_host();
 }
 
-void RemoteDebuggerPeerWebSocket::poll() {
+void RemoteDebuggerPeerWebSocket::poll(int p_channel) {
+	if (p_channel != CHANNEL_MAIN_THREAD) {
+		return;
+	}
 	ws_client->poll();
 
 	while (ws_peer->is_connected_to_host() && ws_peer->get_available_packet_count() > 0 && in_queue.size() < max_queued_messages) {
@@ -76,18 +79,24 @@ int RemoteDebuggerPeerWebSocket::get_max_message_size() const {
 	return 8 << 20; // 8 Mib
 }
 
-bool RemoteDebuggerPeerWebSocket::has_message() {
+bool RemoteDebuggerPeerWebSocket::has_message(int p_channel) {
+	if (p_channel != CHANNEL_MAIN_THREAD) {
+		return false;
+	}
 	return in_queue.size() > 0;
 }
 
-Array RemoteDebuggerPeerWebSocket::get_message() {
+Array RemoteDebuggerPeerWebSocket::get_message(int p_channel) {
+	if (p_channel != CHANNEL_MAIN_THREAD) {
+		return Array();
+	}
 	ERR_FAIL_COND_V(in_queue.size() < 1, Array());
 	Array msg = in_queue[0];
 	in_queue.pop_front();
 	return msg;
 }
 
-Error RemoteDebuggerPeerWebSocket::put_message(const Array &p_arr) {
+Error RemoteDebuggerPeerWebSocket::put_message(int, const Array &p_arr) {
 	if (out_queue.size() >= max_queued_messages) {
 		return ERR_OUT_OF_MEMORY;
 	}
@@ -102,7 +111,8 @@ void RemoteDebuggerPeerWebSocket::close() {
 	ws_client->disconnect_from_host();
 }
 
-bool RemoteDebuggerPeerWebSocket::can_block() const {
+bool RemoteDebuggerPeerWebSocket::can_block(int p_channel) const {
+	(void)p_channel;
 #ifdef WEB_ENABLED
 	return false;
 #else
diff --git a/modules/websocket/remote_debugger_peer_websocket.h b/modules/websocket/remote_debugger_peer_websocket.h
index a37a789cbebf..a9edae8015ee 100644
--- a/modules/websocket/remote_debugger_peer_websocket.h
+++ b/modules/websocket/remote_debugger_peer_websocket.h
@@ -53,12 +53,12 @@ class RemoteDebuggerPeerWebSocket : public RemoteDebuggerPeer {
 	Error connect_to_host(const String &p_uri);
 	bool is_peer_connected() override;
 	int get_max_message_size() const override;
-	bool has_message() override;
-	Error put_message(const Array &p_arr) override;
-	Array get_message() override;
+	bool has_message(int p_channel) override;
+	Error put_message(int p_channel, const Array &p_arr) override;
+	Array get_message(int p_channel) override;
 	void close() override;
-	void poll() override;
-	bool can_block() const override;
+	void poll(int p_channel) override;
+	bool can_block(int p_channel) const override;
 
 	RemoteDebuggerPeerWebSocket(Ref<WebSocketPeer> p_peer = Ref<WebSocketPeer>());
 };
diff --git a/platform/windows/os_windows.cpp b/platform/windows/os_windows.cpp
index 403d53ae530f..04506c721e7a 100644
--- a/platform/windows/os_windows.cpp
+++ b/platform/windows/os_windows.cpp
@@ -114,8 +114,7 @@ BOOL WINAPI HandlerRoutine(_In_ DWORD dwCtrlType) {
 
 	switch (dwCtrlType) {
 		case CTRL_C_EVENT:
-			EngineDebugger::get_script_debugger()->set_depth(-1);
-			EngineDebugger::get_script_debugger()->set_lines_left(1);
+			EngineDebugger::get_script_debugger()->debug_request_break();
 			return TRUE;
 		default:
 			return FALSE;