diff --git a/core/config/engine.cpp b/core/config/engine.cpp
index d77c91331426..0ce12ee78ab6 100644
--- a/core/config/engine.cpp
+++ b/core/config/engine.cpp
@@ -110,7 +110,7 @@ void Engine::set_time_scale(double p_scale) {
 }
 
 double Engine::get_time_scale() const {
-	return _time_scale;
+	return freeze_time_scale ? 0 : _time_scale;
 }
 
 Dictionary Engine::get_version_info() const {
@@ -392,6 +392,10 @@ bool Engine::notify_frame_server_synced() {
 	return server_syncs > SERVER_SYNC_FRAME_COUNT_WARNING;
 }
 
+void Engine::set_freeze_time_scale(bool p_frozen) {
+	freeze_time_scale = p_frozen;
+}
+
 Engine::Engine() {
 	singleton = this;
 }
diff --git a/core/config/engine.h b/core/config/engine.h
index a0b1ffa98123..bac9c907490e 100644
--- a/core/config/engine.h
+++ b/core/config/engine.h
@@ -96,6 +96,8 @@ class Engine {
 	int server_syncs = 0;
 	bool frame_server_synced = false;
 
+	bool freeze_time_scale = false;
+
 public:
 	static Engine *get_singleton();
 
@@ -191,6 +193,8 @@ class Engine {
 	void increment_frames_drawn();
 	bool notify_frame_server_synced();
 
+	void set_freeze_time_scale(bool p_frozen);
+
 	Engine();
 	virtual ~Engine();
 };
diff --git a/core/input/input.cpp b/core/input/input.cpp
index eba7ded267ba..c2becd53fb7c 100644
--- a/core/input/input.cpp
+++ b/core/input/input.cpp
@@ -87,6 +87,12 @@ Input *Input::get_singleton() {
 
 void Input::set_mouse_mode(MouseMode p_mode) {
 	ERR_FAIL_INDEX((int)p_mode, 5);
+
+	if (!active) {
+		active_mouse_mode = p_mode;
+		return;
+	}
+
 	set_mouse_mode_func(p_mode);
 }
 
@@ -252,6 +258,10 @@ Input::VelocityTrack::VelocityTrack() {
 bool Input::is_anything_pressed() const {
 	_THREAD_SAFE_METHOD_
 
+	if (!active) {
+		return false;
+	}
+
 	if (!keys_pressed.is_empty() || !joy_buttons_pressed.is_empty() || !mouse_button_mask.is_empty()) {
 		return true;
 	}
@@ -267,21 +277,41 @@ bool Input::is_anything_pressed() const {
 
 bool Input::is_key_pressed(Key p_keycode) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return false;
+	}
+
 	return keys_pressed.has(p_keycode);
 }
 
 bool Input::is_physical_key_pressed(Key p_keycode) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return false;
+	}
+
 	return physical_keys_pressed.has(p_keycode);
 }
 
 bool Input::is_key_label_pressed(Key p_keycode) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return false;
+	}
+
 	return key_label_pressed.has(p_keycode);
 }
 
 bool Input::is_mouse_button_pressed(MouseButton p_button) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return false;
+	}
+
 	return mouse_button_mask.has_flag(mouse_button_to_mask(p_button));
 }
 
@@ -295,11 +325,21 @@ static JoyButton _combine_device(JoyButton p_value, int p_device) {
 
 bool Input::is_joy_button_pressed(int p_device, JoyButton p_button) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return false;
+	}
+
 	return joy_buttons_pressed.has(_combine_device(p_button, p_device));
 }
 
 bool Input::is_action_pressed(const StringName &p_action, bool p_exact) const {
 	ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
+
+	if (!active) {
+		return false;
+	}
+
 	HashMap<StringName, ActionState>::ConstIterator E = action_states.find(p_action);
 	if (!E) {
 		return false;
@@ -310,6 +350,11 @@ bool Input::is_action_pressed(const StringName &p_action, bool p_exact) const {
 
 bool Input::is_action_just_pressed(const StringName &p_action, bool p_exact) const {
 	ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
+
+	if (!active) {
+		return false;
+	}
+
 	HashMap<StringName, ActionState>::ConstIterator E = action_states.find(p_action);
 	if (!E) {
 		return false;
@@ -331,6 +376,11 @@ bool Input::is_action_just_pressed(const StringName &p_action, bool p_exact) con
 
 bool Input::is_action_just_released(const StringName &p_action, bool p_exact) const {
 	ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), false, InputMap::get_singleton()->suggest_actions(p_action));
+
+	if (!active) {
+		return false;
+	}
+
 	HashMap<StringName, ActionState>::ConstIterator E = action_states.find(p_action);
 	if (!E) {
 		return false;
@@ -352,6 +402,11 @@ bool Input::is_action_just_released(const StringName &p_action, bool p_exact) co
 
 float Input::get_action_strength(const StringName &p_action, bool p_exact) const {
 	ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), 0.0, InputMap::get_singleton()->suggest_actions(p_action));
+
+	if (!active) {
+		return 0.0f;
+	}
+
 	HashMap<StringName, ActionState>::ConstIterator E = action_states.find(p_action);
 	if (!E) {
 		return 0.0f;
@@ -366,6 +421,11 @@ float Input::get_action_strength(const StringName &p_action, bool p_exact) const
 
 float Input::get_action_raw_strength(const StringName &p_action, bool p_exact) const {
 	ERR_FAIL_COND_V_MSG(!InputMap::get_singleton()->has_action(p_action), 0.0, InputMap::get_singleton()->suggest_actions(p_action));
+
+	if (!active) {
+		return 0.0f;
+	}
+
 	HashMap<StringName, ActionState>::ConstIterator E = action_states.find(p_action);
 	if (!E) {
 		return 0.0f;
@@ -410,6 +470,11 @@ Vector2 Input::get_vector(const StringName &p_negative_x, const StringName &p_po
 
 float Input::get_joy_axis(int p_device, JoyAxis p_axis) const {
 	_THREAD_SAFE_METHOD_
+
+	if (!active) {
+		return 0;
+	}
+
 	JoyAxis c = _combine_device(p_axis, p_device);
 	if (_joy_axis.has(c)) {
 		return _joy_axis[c];
@@ -1662,6 +1727,21 @@ int Input::get_unused_joy_id() {
 	return -1;
 }
 
+void Input::set_active(bool p_active) {
+	if (p_active == active) {
+		return;
+	}
+
+	active = p_active;
+
+	if (p_active) {
+		set_mouse_mode_func(active_mouse_mode);
+	} else {
+		active_mouse_mode = get_mouse_mode_func();
+		set_mouse_mode_func(MOUSE_MODE_VISIBLE);
+	}
+}
+
 Input::Input() {
 	singleton = this;
 
diff --git a/core/input/input.h b/core/input/input.h
index 95dd623cc032..9ae4a7e90f7b 100644
--- a/core/input/input.h
+++ b/core/input/input.h
@@ -104,6 +104,9 @@ class Input : public Object {
 	int64_t mouse_window = 0;
 	bool legacy_just_pressed_behavior = false;
 
+	bool active = true;
+	MouseMode active_mouse_mode = MOUSE_MODE_VISIBLE;
+
 	struct ActionState {
 		uint64_t pressed_physics_frame = UINT64_MAX;
 		uint64_t pressed_process_frame = UINT64_MAX;
@@ -380,6 +383,8 @@ class Input : public Object {
 
 	void set_event_dispatch_function(EventDispatchFunc p_function);
 
+	void set_active(bool p_active);
+
 	Input();
 	~Input();
 };
diff --git a/doc/classes/EditorFeatureProfile.xml b/doc/classes/EditorFeatureProfile.xml
index 3aa1e63aac14..c125c923efbe 100644
--- a/doc/classes/EditorFeatureProfile.xml
+++ b/doc/classes/EditorFeatureProfile.xml
@@ -121,7 +121,10 @@
 		<constant name="FEATURE_HISTORY_DOCK" value="7" enum="Feature">
 			The History dock. If this feature is disabled, the History dock won't be visible.
 		</constant>
-		<constant name="FEATURE_MAX" value="8" enum="Feature">
+		<constant name="FEATURE_GAME" value="8" enum="Feature">
+			The Game tab, which allows embedding the game window and selecting nodes by clicking inside of it. If this feature is disabled, the Game tab won't display.
+		</constant>
+		<constant name="FEATURE_MAX" value="9" enum="Feature">
 			Represents the size of the [enum Feature] enum.
 		</constant>
 	</constants>
diff --git a/editor/debugger/editor_debugger_node.cpp b/editor/debugger/editor_debugger_node.cpp
index b4265f9fc0e0..f4476f57aaf5 100644
--- a/editor/debugger/editor_debugger_node.cpp
+++ b/editor/debugger/editor_debugger_node.cpp
@@ -105,6 +105,7 @@ ScriptEditorDebugger *EditorDebuggerNode::_add_debugger() {
 	node->connect("breakpoint_selected", callable_mp(this, &EditorDebuggerNode::_error_selected).bind(id));
 	node->connect("clear_execution", callable_mp(this, &EditorDebuggerNode::_clear_execution));
 	node->connect("breaked", callable_mp(this, &EditorDebuggerNode::_breaked).bind(id));
+	node->connect("remote_tree_select_requested", callable_mp(this, &EditorDebuggerNode::_remote_tree_select_requested).bind(id));
 	node->connect("remote_tree_updated", callable_mp(this, &EditorDebuggerNode::_remote_tree_updated).bind(id));
 	node->connect("remote_object_updated", callable_mp(this, &EditorDebuggerNode::_remote_object_updated).bind(id));
 	node->connect("remote_object_property_updated", callable_mp(this, &EditorDebuggerNode::_remote_object_property_updated).bind(id));
@@ -637,6 +638,13 @@ void EditorDebuggerNode::request_remote_tree() {
 	get_current_debugger()->request_remote_tree();
 }
 
+void EditorDebuggerNode::_remote_tree_select_requested(ObjectID p_id, int p_debugger) {
+	if (p_debugger != tabs->get_current_tab()) {
+		return;
+	}
+	remote_scene_tree->select_node(p_id);
+}
+
 void EditorDebuggerNode::_remote_tree_updated(int p_debugger) {
 	if (p_debugger != tabs->get_current_tab()) {
 		return;
diff --git a/editor/debugger/editor_debugger_node.h b/editor/debugger/editor_debugger_node.h
index 12e097f65221..14ea8666f28d 100644
--- a/editor/debugger/editor_debugger_node.h
+++ b/editor/debugger/editor_debugger_node.h
@@ -51,11 +51,8 @@ class EditorDebuggerNode : public MarginContainer {
 public:
 	enum CameraOverride {
 		OVERRIDE_NONE,
-		OVERRIDE_2D,
-		OVERRIDE_3D_1, // 3D Viewport 1
-		OVERRIDE_3D_2, // 3D Viewport 2
-		OVERRIDE_3D_3, // 3D Viewport 3
-		OVERRIDE_3D_4 // 3D Viewport 4
+		OVERRIDE_INGAME,
+		OVERRIDE_EDITORS
 	};
 
 private:
@@ -132,6 +129,7 @@ class EditorDebuggerNode : public MarginContainer {
 	void _debugger_stopped(int p_id);
 	void _debugger_wants_stop(int p_id);
 	void _debugger_changed(int p_tab);
+	void _remote_tree_select_requested(ObjectID p_id, int p_debugger);
 	void _remote_tree_updated(int p_debugger);
 	void _remote_tree_button_pressed(Object *p_item, int p_column, int p_id, MouseButton p_button);
 	void _remote_object_updated(ObjectID p_id, int p_debugger);
diff --git a/editor/debugger/editor_debugger_tree.cpp b/editor/debugger/editor_debugger_tree.cpp
index c4d7899b2d18..ba9d61da0f20 100644
--- a/editor/debugger/editor_debugger_tree.cpp
+++ b/editor/debugger/editor_debugger_tree.cpp
@@ -34,6 +34,7 @@
 #include "editor/editor_string_names.h"
 #include "editor/gui/editor_file_dialog.h"
 #include "editor/scene_tree_dock.h"
+#include "editor_debugger_node.h"
 #include "scene/debugger/scene_debugger.h"
 #include "scene/gui/texture_rect.h"
 #include "scene/resources/packed_scene.h"
@@ -185,7 +186,17 @@ void EditorDebuggerTree::update_scene_tree(const SceneDebuggerTree *p_tree, int
 		// Select previously selected node.
 		if (debugger_id == p_debugger) { // Can use remote id.
 			if (node.id == inspected_object_id) {
+				if (selection_uncollapse_all) {
+					selection_uncollapse_all = false;
+
+					// Temporarily set to `false`, to allow caching the unfolds.
+					updating_scene_tree = false;
+					item->uncollapse_tree();
+					updating_scene_tree = true;
+				}
+
 				item->select(0);
+
 				if (filter_changed) {
 					scroll_item = item;
 				}
@@ -258,7 +269,7 @@ void EditorDebuggerTree::update_scene_tree(const SceneDebuggerTree *p_tree, int
 			}
 		}
 	}
-	debugger_id = p_debugger; // Needed by hook, could be avoided if every debugger had its own tree
+	debugger_id = p_debugger; // Needed by hook, could be avoided if every debugger had its own tree.
 	if (scroll_item) {
 		callable_mp((Tree *)this, &Tree::scroll_to_item).call_deferred(scroll_item, false);
 	}
@@ -266,6 +277,16 @@ void EditorDebuggerTree::update_scene_tree(const SceneDebuggerTree *p_tree, int
 	updating_scene_tree = false;
 }
 
+void EditorDebuggerTree::select_node(ObjectID p_id) {
+	// Manually select, as the tree control may be out-of-date for some reason (e.g. not shown yet).
+	selection_uncollapse_all = true;
+	inspected_object_id = uint64_t(p_id);
+	emit_signal(SNAME("object_selected"), inspected_object_id, debugger_id);
+
+	// Request a tree refresh.
+	EditorDebuggerNode::get_singleton()->request_remote_tree();
+}
+
 Variant EditorDebuggerTree::get_drag_data(const Point2 &p_point) {
 	if (get_button_id_at_position(p_point) != -1) {
 		return Variant();
diff --git a/editor/debugger/editor_debugger_tree.h b/editor/debugger/editor_debugger_tree.h
index 705df17baf10..7ee54f188fec 100644
--- a/editor/debugger/editor_debugger_tree.h
+++ b/editor/debugger/editor_debugger_tree.h
@@ -49,6 +49,7 @@ class EditorDebuggerTree : public Tree {
 	ObjectID inspected_object_id;
 	int debugger_id = 0;
 	bool updating_scene_tree = false;
+	bool selection_uncollapse_all = false;
 	HashSet<ObjectID> unfold_cache;
 	PopupMenu *item_menu = nullptr;
 	EditorFileDialog *file_dialog = nullptr;
@@ -78,6 +79,7 @@ class EditorDebuggerTree : public Tree {
 	ObjectID get_selected_object();
 	int get_current_debugger(); // Would love to have one tree for every debugger.
 	void update_scene_tree(const SceneDebuggerTree *p_tree, int p_debugger);
+	void select_node(ObjectID p_id);
 	EditorDebuggerTree();
 };
 
diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
index 642244ebeb18..21ef0c349b6f 100644
--- a/editor/debugger/script_editor_debugger.cpp
+++ b/editor/debugger/script_editor_debugger.cpp
@@ -799,6 +799,10 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, uint64_t p_thread
 	} else if (p_msg == "request_quit") {
 		emit_signal(SNAME("stop_requested"));
 		_stop_and_notify();
+	} else if (p_msg == "remote_node_clicked") {
+		if (!p_data.is_empty()) {
+			emit_signal(SNAME("remote_tree_select_requested"), p_data[0]);
+		}
 	} else if (p_msg == "performance:profile_names") {
 		Vector<StringName> monitors;
 		monitors.resize(p_data.size());
@@ -898,37 +902,42 @@ void ScriptEditorDebugger::_notification(int p_what) {
 			if (is_session_active()) {
 				peer->poll();
 
-				if (camera_override == CameraOverride::OVERRIDE_2D) {
-					Dictionary state = CanvasItemEditor::get_singleton()->get_state();
-					float zoom = state["zoom"];
-					Point2 offset = state["ofs"];
-					Transform2D transform;
-
-					transform.scale_basis(Size2(zoom, zoom));
-					transform.columns[2] = -offset * zoom;
-
-					Array msg;
-					msg.push_back(transform);
-					_put_msg("scene:override_camera_2D:transform", msg);
-
-				} else if (camera_override >= CameraOverride::OVERRIDE_3D_1) {
-					int viewport_idx = camera_override - CameraOverride::OVERRIDE_3D_1;
-					Node3DEditorViewport *viewport = Node3DEditor::get_singleton()->get_editor_viewport(viewport_idx);
-					Camera3D *const cam = viewport->get_camera_3d();
-
-					Array msg;
-					msg.push_back(cam->get_camera_transform());
-					if (cam->get_projection() == Camera3D::PROJECTION_ORTHOGONAL) {
-						msg.push_back(false);
-						msg.push_back(cam->get_size());
-					} else {
-						msg.push_back(true);
-						msg.push_back(cam->get_fov());
+				if (camera_override == CameraOverride::OVERRIDE_EDITORS) {
+					// CanvasItem Editor
+					{
+						Dictionary state = CanvasItemEditor::get_singleton()->get_state();
+						float zoom = state["zoom"];
+						Point2 offset = state["ofs"];
+						Transform2D transform;
+
+						transform.scale_basis(Size2(zoom, zoom));
+						transform.columns[2] = -offset * zoom;
+
+						Array msg;
+						msg.push_back(transform);
+						_put_msg("scene:transform_camera_2D", msg);
+					}
+
+					// Node3D Editor
+					{
+						Node3DEditorViewport *viewport = Node3DEditor::get_singleton()->get_last_used_viewport();
+						Camera3D *const cam = viewport->get_camera_3d();
+
+						Array msg;
+						msg.push_back(cam->get_camera_transform());
+						if (cam->get_projection() == Camera3D::PROJECTION_ORTHOGONAL) {
+							msg.push_back(false);
+							msg.push_back(cam->get_size());
+						} else {
+							msg.push_back(true);
+							msg.push_back(cam->get_fov());
+						}
+						msg.push_back(cam->get_near());
+						msg.push_back(cam->get_far());
+						_put_msg("scene:transform_camera_3D", msg);
 					}
-					msg.push_back(cam->get_near());
-					msg.push_back(cam->get_far());
-					_put_msg("scene:override_camera_3D:transform", msg);
 				}
+
 				if (is_breaked() && can_request_idle_draw) {
 					_put_msg("servers:draw", Array());
 					can_request_idle_draw = false;
@@ -1462,23 +1471,10 @@ CameraOverride ScriptEditorDebugger::get_camera_override() const {
 }
 
 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);
-	} 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);
-	} 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);
-	} 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);
-	}
+	Array msg;
+	msg.push_back(p_override != CameraOverride::OVERRIDE_NONE);
+	msg.push_back(p_override == CameraOverride::OVERRIDE_EDITORS);
+	_put_msg("scene:override_cameras", msg);
 
 	camera_override = p_override;
 }
@@ -1769,6 +1765,7 @@ void ScriptEditorDebugger::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("remote_object_updated", PropertyInfo(Variant::INT, "id")));
 	ADD_SIGNAL(MethodInfo("remote_object_property_updated", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::STRING, "property")));
 	ADD_SIGNAL(MethodInfo("remote_tree_updated"));
+	ADD_SIGNAL(MethodInfo("remote_tree_select_requested", PropertyInfo(Variant::NODE_PATH, "path")));
 	ADD_SIGNAL(MethodInfo("output", PropertyInfo(Variant::STRING, "msg"), PropertyInfo(Variant::INT, "level")));
 	ADD_SIGNAL(MethodInfo("stack_dump", PropertyInfo(Variant::ARRAY, "stack_dump")));
 	ADD_SIGNAL(MethodInfo("stack_frame_vars", PropertyInfo(Variant::INT, "num_vars")));
diff --git a/editor/editor_feature_profile.cpp b/editor/editor_feature_profile.cpp
index 44fc9e37020c..9cd2a1aa81d5 100644
--- a/editor/editor_feature_profile.cpp
+++ b/editor/editor_feature_profile.cpp
@@ -43,6 +43,7 @@
 const char *EditorFeatureProfile::feature_names[FEATURE_MAX] = {
 	TTRC("3D Editor"),
 	TTRC("Script Editor"),
+	TTRC("Game Editor"),
 	TTRC("Asset Library"),
 	TTRC("Scene Tree Editing"),
 	TTRC("Node Dock"),
@@ -54,6 +55,7 @@ const char *EditorFeatureProfile::feature_names[FEATURE_MAX] = {
 const char *EditorFeatureProfile::feature_descriptions[FEATURE_MAX] = {
 	TTRC("Allows to view and edit 3D scenes."),
 	TTRC("Allows to edit scripts using the integrated script editor."),
+	TTRC("Provides tools for selecting and debugging nodes at runtime."),
 	TTRC("Provides built-in access to the Asset Library."),
 	TTRC("Allows editing the node hierarchy in the Scene dock."),
 	TTRC("Allows to work with signals and groups of the node selected in the Scene dock."),
@@ -65,6 +67,7 @@ const char *EditorFeatureProfile::feature_descriptions[FEATURE_MAX] = {
 const char *EditorFeatureProfile::feature_identifiers[FEATURE_MAX] = {
 	"3d",
 	"script",
+	"game",
 	"asset_lib",
 	"scene_tree",
 	"node_dock",
@@ -307,6 +310,7 @@ void EditorFeatureProfile::_bind_methods() {
 	BIND_ENUM_CONSTANT(FEATURE_FILESYSTEM_DOCK);
 	BIND_ENUM_CONSTANT(FEATURE_IMPORT_DOCK);
 	BIND_ENUM_CONSTANT(FEATURE_HISTORY_DOCK);
+	BIND_ENUM_CONSTANT(FEATURE_GAME);
 	BIND_ENUM_CONSTANT(FEATURE_MAX);
 }
 
diff --git a/editor/editor_feature_profile.h b/editor/editor_feature_profile.h
index 7458a04e195e..e84936dd348e 100644
--- a/editor/editor_feature_profile.h
+++ b/editor/editor_feature_profile.h
@@ -55,6 +55,7 @@ class EditorFeatureProfile : public RefCounted {
 		FEATURE_FILESYSTEM_DOCK,
 		FEATURE_IMPORT_DOCK,
 		FEATURE_HISTORY_DOCK,
+		FEATURE_GAME,
 		FEATURE_MAX
 	};
 
diff --git a/editor/editor_main_screen.h b/editor/editor_main_screen.h
index 153a182bc213..ca78ceaa8850 100644
--- a/editor/editor_main_screen.h
+++ b/editor/editor_main_screen.h
@@ -47,6 +47,7 @@ class EditorMainScreen : public PanelContainer {
 		EDITOR_2D = 0,
 		EDITOR_3D,
 		EDITOR_SCRIPT,
+		EDITOR_GAME,
 		EDITOR_ASSETLIB,
 	};
 
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index 2853ebc4994c..859aa7d5c9a9 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -144,6 +144,7 @@
 #include "editor/plugins/editor_plugin.h"
 #include "editor/plugins/editor_preview_plugins.h"
 #include "editor/plugins/editor_resource_conversion_plugin.h"
+#include "editor/plugins/game_editor_plugin.h"
 #include "editor/plugins/gdextension_export_plugin.h"
 #include "editor/plugins/material_editor_plugin.h"
 #include "editor/plugins/mesh_library_editor_plugin.h"
@@ -356,6 +357,8 @@ void EditorNode::shortcut_input(const Ref<InputEvent> &p_event) {
 			editor_main_screen->select(EditorMainScreen::EDITOR_3D);
 		} else if (ED_IS_SHORTCUT("editor/editor_script", p_event)) {
 			editor_main_screen->select(EditorMainScreen::EDITOR_SCRIPT);
+		} else if (ED_IS_SHORTCUT("editor/editor_game", p_event)) {
+			editor_main_screen->select(EditorMainScreen::EDITOR_GAME);
 		} else if (ED_IS_SHORTCUT("editor/editor_help", p_event)) {
 			emit_signal(SNAME("request_help_search"), "");
 		} else if (ED_IS_SHORTCUT("editor/editor_assetlib", p_event) && AssetLibraryEditorPlugin::is_available()) {
@@ -6574,6 +6577,7 @@ void EditorNode::_feature_profile_changed() {
 
 		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_3D, !profile->is_feature_disabled(EditorFeatureProfile::FEATURE_3D));
 		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_SCRIPT, !profile->is_feature_disabled(EditorFeatureProfile::FEATURE_SCRIPT));
+		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_GAME, !profile->is_feature_disabled(EditorFeatureProfile::FEATURE_GAME));
 		if (AssetLibraryEditorPlugin::is_available()) {
 			editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_ASSETLIB, !profile->is_feature_disabled(EditorFeatureProfile::FEATURE_ASSET_LIB));
 		}
@@ -6584,6 +6588,7 @@ void EditorNode::_feature_profile_changed() {
 		editor_dock_manager->set_dock_enabled(history_dock, true);
 		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_3D, true);
 		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_SCRIPT, true);
+		editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_GAME, true);
 		if (AssetLibraryEditorPlugin::is_available()) {
 			editor_main_screen->set_button_enabled(EditorMainScreen::EDITOR_ASSETLIB, true);
 		}
@@ -7715,6 +7720,7 @@ EditorNode::EditorNode() {
 	add_editor_plugin(memnew(CanvasItemEditorPlugin));
 	add_editor_plugin(memnew(Node3DEditorPlugin));
 	add_editor_plugin(memnew(ScriptEditorPlugin));
+	add_editor_plugin(memnew(GameEditorPlugin));
 
 	EditorAudioBuses *audio_bus_editor = EditorAudioBuses::register_editor();
 
@@ -7897,12 +7903,14 @@ EditorNode::EditorNode() {
 	ED_SHORTCUT_AND_COMMAND("editor/editor_2d", TTR("Open 2D Editor"), KeyModifierMask::CTRL | Key::F1);
 	ED_SHORTCUT_AND_COMMAND("editor/editor_3d", TTR("Open 3D Editor"), KeyModifierMask::CTRL | Key::F2);
 	ED_SHORTCUT_AND_COMMAND("editor/editor_script", TTR("Open Script Editor"), KeyModifierMask::CTRL | Key::F3);
-	ED_SHORTCUT_AND_COMMAND("editor/editor_assetlib", TTR("Open Asset Library"), KeyModifierMask::CTRL | Key::F4);
+	ED_SHORTCUT_AND_COMMAND("editor/editor_game", TTR("Open Game Editor"), KeyModifierMask::CTRL | Key::F4);
+	ED_SHORTCUT_AND_COMMAND("editor/editor_assetlib", TTR("Open Asset Library"), KeyModifierMask::CTRL | Key::F5);
 
 	ED_SHORTCUT_OVERRIDE("editor/editor_2d", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_1);
 	ED_SHORTCUT_OVERRIDE("editor/editor_3d", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_2);
 	ED_SHORTCUT_OVERRIDE("editor/editor_script", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_3);
-	ED_SHORTCUT_OVERRIDE("editor/editor_assetlib", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_4);
+	ED_SHORTCUT_OVERRIDE("editor/editor_game", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_4);
+	ED_SHORTCUT_OVERRIDE("editor/editor_assetlib", "macos", KeyModifierMask::META | KeyModifierMask::CTRL | Key::KEY_5);
 
 	ED_SHORTCUT_AND_COMMAND("editor/editor_next", TTR("Open the next Editor"));
 	ED_SHORTCUT_AND_COMMAND("editor/editor_prev", TTR("Open the previous Editor"));
diff --git a/editor/icons/2DNodes.svg b/editor/icons/2DNodes.svg
new file mode 100644
index 000000000000..90b92a4bc7b8
--- /dev/null
+++ b/editor/icons/2DNodes.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="16" height="16"><path fill="none" stroke="#8da5f3" stroke-width="2" d="M 8,13 C 5.2385763,13 3,10.761424 3,8 3,5.2385763 5.2385763,3 8,3"/><path fill="none" stroke="#8eef97" stroke-width="2" d="m 8,13 c 2.761424,0 5,-2.238576 5,-5 C 13,5.2385763 10.761424,3 8,3"/></svg>
\ No newline at end of file
diff --git a/editor/icons/Camera.svg b/editor/icons/Camera.svg
new file mode 100644
index 000000000000..8612d458a731
--- /dev/null
+++ b/editor/icons/Camera.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="16" height="16"><path fill="#e0e0e0" d="M9 2a3 3 0 0 0-3 2.777 3 3 0 1 0-3 5.047V12a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1v-1l3 2V7l-3 2V7.23A3 3 0 0 0 9 2z"/></svg>
\ No newline at end of file
diff --git a/editor/icons/Game.svg b/editor/icons/Game.svg
new file mode 100644
index 000000000000..e75e5c53129f
--- /dev/null
+++ b/editor/icons/Game.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path fill="#e0e0e0" d="M 1,15 V 12 C 1,11.5 1.5,11 2,11 H 3 V 10 C 3,9.5 3.5,9 4,9 h 1 c 0.5,0 1,0.5 1,1 v 1 H 8 V 5 h 2 v 6 h 4 c 0.5,0 1,0.5 1,1 v 3 z"/><circle cx="9" cy="4" r="3" fill="#e0e0e0"/></svg>
\ No newline at end of file
diff --git a/editor/icons/NextFrame.svg b/editor/icons/NextFrame.svg
new file mode 100644
index 000000000000..9609b2538b5c
--- /dev/null
+++ b/editor/icons/NextFrame.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path fill="#e0e0e0" d="m 12,3 c -0.552285,0 -1,0.4477153 -1,1 v 8 c 0,0.552285 0.447715,1 1,1 h 1 c 0.552285,0 1,-0.447715 1,-1 V 4 C 14,3.4477153 13.552285,3 13,3 Z M 2.975,3.002 C 2.4332786,3.0155465 2.0009144,3.45811 2,4 v 8 c -3.148e-4,0.838862 0.9701632,1.305289 1.625,0.781 l 5,-4 c 0.4989606,-0.4003069 0.4989606,-1.1596931 0,-1.56 l -5,-4 C 3.4409271,3.0736532 3.2107095,2.9960875 2.975,3.002 Z"/></svg>
\ No newline at end of file
diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp
index e9a796dae723..ea1c1095e9ae 100644
--- a/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/editor/plugins/canvas_item_editor_plugin.cpp
@@ -3975,7 +3975,6 @@ void CanvasItemEditor::_update_editor_settings() {
 	grid_snap_button->set_icon(get_editor_theme_icon(SNAME("SnapGrid")));
 	snap_config_menu->set_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
 	skeleton_menu->set_icon(get_editor_theme_icon(SNAME("Bone")));
-	override_camera_button->set_icon(get_editor_theme_icon(SNAME("Camera2D")));
 	pan_button->set_icon(get_editor_theme_icon(SNAME("ToolPan")));
 	ruler_button->set_icon(get_editor_theme_icon(SNAME("Ruler")));
 	pivot_button->set_icon(get_editor_theme_icon(SNAME("EditPivot")));
@@ -4014,8 +4013,6 @@ void CanvasItemEditor::_notification(int p_what) {
 		case NOTIFICATION_READY: {
 			_update_lock_and_group_button();
 
-			EditorRunBar::get_singleton()->connect("play_pressed", callable_mp(this, &CanvasItemEditor::_update_override_camera_button).bind(true));
-			EditorRunBar::get_singleton()->connect("stop_pressed", callable_mp(this, &CanvasItemEditor::_update_override_camera_button).bind(false));
 			ProjectSettings::get_singleton()->connect("settings_changed", callable_mp(this, &CanvasItemEditor::_project_settings_changed));
 		} break;
 
@@ -4114,15 +4111,6 @@ void CanvasItemEditor::_notification(int p_what) {
 			_update_editor_settings();
 		} break;
 
-		case NOTIFICATION_VISIBILITY_CHANGED: {
-			if (!is_visible() && override_camera_button->is_pressed()) {
-				EditorDebuggerNode *debugger = EditorDebuggerNode::get_singleton();
-
-				debugger->set_camera_override(EditorDebuggerNode::OVERRIDE_NONE);
-				override_camera_button->set_pressed(false);
-			}
-		} break;
-
 		case NOTIFICATION_APPLICATION_FOCUS_OUT:
 		case NOTIFICATION_WM_WINDOW_FOCUS_OUT: {
 			if (drag_type != DRAG_NONE) {
@@ -4280,16 +4268,6 @@ void CanvasItemEditor::_button_toggle_grid_snap(bool p_status) {
 	viewport->queue_redraw();
 }
 
-void CanvasItemEditor::_button_override_camera(bool p_pressed) {
-	EditorDebuggerNode *debugger = EditorDebuggerNode::get_singleton();
-
-	if (p_pressed) {
-		debugger->set_camera_override(EditorDebuggerNode::OVERRIDE_2D);
-	} else {
-		debugger->set_camera_override(EditorDebuggerNode::OVERRIDE_NONE);
-	}
-}
-
 void CanvasItemEditor::_button_tool_select(int p_index) {
 	Button *tb[TOOL_MAX] = { select_button, list_select_button, move_button, scale_button, rotate_button, pivot_button, pan_button, ruler_button };
 	for (int i = 0; i < TOOL_MAX; i++) {
@@ -4396,17 +4374,6 @@ void CanvasItemEditor::_insert_animation_keys(bool p_location, bool p_rotation,
 	te->commit_insert_queue();
 }
 
-void CanvasItemEditor::_update_override_camera_button(bool p_game_running) {
-	if (p_game_running) {
-		override_camera_button->set_disabled(false);
-		override_camera_button->set_tooltip_text(TTR("Project Camera Override\nOverrides the running project's camera with the editor viewport camera."));
-	} else {
-		override_camera_button->set_disabled(true);
-		override_camera_button->set_pressed(false);
-		override_camera_button->set_tooltip_text(TTR("Project Camera Override\nNo project instance running. Run the project from the editor to use this feature."));
-	}
-}
-
 void CanvasItemEditor::_popup_callback(int p_op) {
 	EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
 	last_option = MenuOption(p_op);
@@ -5512,16 +5479,6 @@ CanvasItemEditor::CanvasItemEditor() {
 
 	main_menu_hbox->add_child(memnew(VSeparator));
 
-	override_camera_button = memnew(Button);
-	override_camera_button->set_theme_type_variation("FlatButton");
-	main_menu_hbox->add_child(override_camera_button);
-	override_camera_button->connect(SceneStringName(toggled), callable_mp(this, &CanvasItemEditor::_button_override_camera));
-	override_camera_button->set_toggle_mode(true);
-	override_camera_button->set_disabled(true);
-	_update_override_camera_button(false);
-
-	main_menu_hbox->add_child(memnew(VSeparator));
-
 	view_menu = memnew(MenuButton);
 	view_menu->set_flat(false);
 	view_menu->set_theme_type_variation("FlatMenuButton");
diff --git a/editor/plugins/canvas_item_editor_plugin.h b/editor/plugins/canvas_item_editor_plugin.h
index bae9efebc91e..c5335bf9c19b 100644
--- a/editor/plugins/canvas_item_editor_plugin.h
+++ b/editor/plugins/canvas_item_editor_plugin.h
@@ -335,7 +335,6 @@ class CanvasItemEditor : public VBoxContainer {
 	Button *group_button = nullptr;
 	Button *ungroup_button = nullptr;
 
-	Button *override_camera_button = nullptr;
 	MenuButton *view_menu = nullptr;
 	PopupMenu *grid_menu = nullptr;
 	PopupMenu *theme_menu = nullptr;
@@ -518,11 +517,8 @@ class CanvasItemEditor : public VBoxContainer {
 	void _zoom_on_position(real_t p_zoom, Point2 p_position = Point2());
 	void _button_toggle_smart_snap(bool p_status);
 	void _button_toggle_grid_snap(bool p_status);
-	void _button_override_camera(bool p_pressed);
 	void _button_tool_select(int p_index);
 
-	void _update_override_camera_button(bool p_game_running);
-
 	HSplitContainer *left_panel_split = nullptr;
 	HSplitContainer *right_panel_split = nullptr;
 	VSplitContainer *bottom_split = nullptr;
diff --git a/editor/plugins/game_editor_plugin.cpp b/editor/plugins/game_editor_plugin.cpp
new file mode 100644
index 000000000000..5488ea84f337
--- /dev/null
+++ b/editor/plugins/game_editor_plugin.cpp
@@ -0,0 +1,436 @@
+/**************************************************************************/
+/*  game_editor_plugin.cpp                                                */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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 "game_editor_plugin.h"
+
+#include "editor/editor_main_screen.h"
+#include "editor/editor_node.h"
+#include "editor/editor_settings.h"
+#include "editor/themes/editor_scale.h"
+#include "scene/gui/button.h"
+#include "scene/gui/panel.h"
+#include "scene/gui/separator.h"
+
+void GameEditorDebugger::_session_started(Ref<EditorDebuggerSession> p_session) {
+	p_session->send_message("scene:runtime_node_select_setup", Array());
+
+	Array type;
+	type.append(node_type);
+	p_session->send_message("scene:runtime_node_select_set_type", type);
+	Array visible;
+	visible.append(selection_visible);
+	p_session->send_message("scene:runtime_node_select_set_visible", visible);
+	Array mode;
+	mode.append(select_mode);
+	p_session->send_message("scene:runtime_node_select_set_mode", mode);
+
+	emit_signal(SNAME("session_started"));
+}
+
+void GameEditorDebugger::_session_stopped() {
+	emit_signal(SNAME("session_stopped"));
+}
+
+void GameEditorDebugger::set_suspend(bool p_enabled) {
+	Array message;
+	message.append(p_enabled);
+
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:suspend_changed", message);
+		}
+	}
+}
+
+void GameEditorDebugger::next_frame() {
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:next_frame", Array());
+		}
+	}
+}
+
+void GameEditorDebugger::set_node_type(int p_type) {
+	node_type = p_type;
+
+	Array message;
+	message.append(p_type);
+
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:runtime_node_select_set_type", message);
+		}
+	}
+}
+
+void GameEditorDebugger::set_selection_visible(bool p_visible) {
+	selection_visible = p_visible;
+
+	Array message;
+	message.append(p_visible);
+
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:runtime_node_select_set_visible", message);
+		}
+	}
+}
+
+void GameEditorDebugger::set_select_mode(int p_mode) {
+	select_mode = p_mode;
+
+	Array message;
+	message.append(p_mode);
+
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:runtime_node_select_set_mode", message);
+		}
+	}
+}
+
+void GameEditorDebugger::set_camera_override(bool p_enabled) {
+	EditorDebuggerNode::get_singleton()->set_camera_override(p_enabled ? camera_override_mode : EditorDebuggerNode::OVERRIDE_NONE);
+}
+
+void GameEditorDebugger::set_camera_manipulate_mode(EditorDebuggerNode::CameraOverride p_mode) {
+	camera_override_mode = p_mode;
+
+	if (EditorDebuggerNode::get_singleton()->get_camera_override() != EditorDebuggerNode::OVERRIDE_NONE) {
+		set_camera_override(true);
+	}
+}
+
+void GameEditorDebugger::reset_camera_2d_position() {
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:runtime_node_select_reset_camera_2d", Array());
+		}
+	}
+}
+
+void GameEditorDebugger::reset_camera_3d_position() {
+	for (Ref<EditorDebuggerSession> &I : sessions) {
+		if (I->is_active()) {
+			I->send_message("scene:runtime_node_select_reset_camera_3d", Array());
+		}
+	}
+}
+
+void GameEditorDebugger::setup_session(int p_session_id) {
+	Ref<EditorDebuggerSession> session = get_session(p_session_id);
+	ERR_FAIL_COND(session.is_null());
+
+	sessions.append(session);
+
+	session->connect("started", callable_mp(this, &GameEditorDebugger::_session_started).bind(session));
+	session->connect("stopped", callable_mp(this, &GameEditorDebugger::_session_stopped));
+}
+
+void GameEditorDebugger::_bind_methods() {
+	ADD_SIGNAL(MethodInfo("session_started"));
+	ADD_SIGNAL(MethodInfo("session_stopped"));
+}
+
+///////
+
+void GameEditor::_sessions_changed() {
+	// The debugger session's `session_started/stopped` signal can be unreliable, so count it manually.
+	active_sessions = 0;
+	Array sessions = debugger->get_sessions();
+	for (int i = 0; i < sessions.size(); i++) {
+		if (Object::cast_to<EditorDebuggerSession>(sessions[i])->is_active()) {
+			active_sessions++;
+		}
+	}
+
+	_update_debugger_buttons();
+}
+
+void GameEditor::_update_debugger_buttons() {
+	bool empty = active_sessions == 0;
+
+	suspend_button->set_disabled(empty);
+	camera_override_button->set_disabled(empty);
+
+	PopupMenu *menu = camera_override_menu->get_popup();
+
+	bool disable_camera_reset = empty || !camera_override_button->is_pressed() || !menu->is_item_checked(menu->get_item_index(CAMERA_MODE_INGAME));
+	menu->set_item_disabled(CAMERA_RESET_2D, disable_camera_reset);
+	menu->set_item_disabled(CAMERA_RESET_3D, disable_camera_reset);
+
+	if (empty) {
+		suspend_button->set_pressed(false);
+		camera_override_button->set_pressed(false);
+	}
+	next_frame_button->set_disabled(!suspend_button->is_pressed());
+}
+
+void GameEditor::_suspend_button_toggled(bool p_pressed) {
+	_update_debugger_buttons();
+
+	debugger->set_suspend(p_pressed);
+}
+
+void GameEditor::_node_type_pressed(int p_option) {
+	RuntimeNodeSelect::NodeType type = (RuntimeNodeSelect::NodeType)p_option;
+	for (int i = 0; i < RuntimeNodeSelect::NODE_TYPE_MAX; i++) {
+		node_type_button[i]->set_pressed(i == type);
+	}
+
+	_update_debugger_buttons();
+
+	debugger->set_node_type(type);
+}
+
+void GameEditor::_select_mode_pressed(int p_option) {
+	RuntimeNodeSelect::SelectMode mode = (RuntimeNodeSelect::SelectMode)p_option;
+	for (int i = 0; i < RuntimeNodeSelect::SELECT_MODE_MAX; i++) {
+		select_mode_button[i]->set_pressed(i == mode);
+	}
+
+	debugger->set_select_mode(mode);
+}
+
+void GameEditor::_hide_selection_toggled(bool p_pressed) {
+	hide_selection->set_icon(get_editor_theme_icon(p_pressed ? SNAME("GuiVisibilityHidden") : SNAME("GuiVisibilityVisible")));
+
+	debugger->set_selection_visible(!p_pressed);
+}
+
+void GameEditor::_camera_override_button_toggled(bool p_pressed) {
+	_update_debugger_buttons();
+
+	debugger->set_camera_override(p_pressed);
+}
+
+void GameEditor::_camera_override_menu_id_pressed(int p_id) {
+	PopupMenu *menu = camera_override_menu->get_popup();
+	if (p_id != CAMERA_RESET_2D && p_id != CAMERA_RESET_3D) {
+		for (int i = 0; i < menu->get_item_count(); i++) {
+			menu->set_item_checked(i, false);
+		}
+	}
+
+	switch (p_id) {
+		case CAMERA_RESET_2D: {
+			debugger->reset_camera_2d_position();
+		} break;
+		case CAMERA_RESET_3D: {
+			debugger->reset_camera_3d_position();
+		} break;
+		case CAMERA_MODE_INGAME: {
+			debugger->set_camera_manipulate_mode(EditorDebuggerNode::OVERRIDE_INGAME);
+			menu->set_item_disabled(CAMERA_RESET_2D, false);
+			menu->set_item_disabled(CAMERA_RESET_3D, false);
+			menu->set_item_checked(menu->get_item_index(p_id), true);
+		} break;
+		case CAMERA_MODE_EDITORS: {
+			debugger->set_camera_manipulate_mode(EditorDebuggerNode::OVERRIDE_EDITORS);
+			menu->set_item_disabled(CAMERA_RESET_2D, true);
+			menu->set_item_disabled(CAMERA_RESET_3D, true);
+			menu->set_item_checked(menu->get_item_index(p_id), true);
+		} break;
+	}
+}
+
+void GameEditor::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE:
+		case NOTIFICATION_THEME_CHANGED: {
+			suspend_button->set_icon(get_editor_theme_icon(SNAME("Pause")));
+			next_frame_button->set_icon(get_editor_theme_icon(SNAME("NextFrame")));
+
+			node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_icon(get_editor_theme_icon(SNAME("InputEventJoypadMotion")));
+			node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->set_icon(get_editor_theme_icon(SNAME("2DNodes")));
+#ifndef _3D_DISABLED
+			node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->set_icon(get_editor_theme_icon(SNAME("Node3D")));
+#endif // _3D_DISABLED
+
+			select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_icon(get_editor_theme_icon(SNAME("ToolSelect")));
+			select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]->set_icon(get_editor_theme_icon(SNAME("ListSelect")));
+
+			hide_selection->set_icon(get_editor_theme_icon(hide_selection->is_pressed() ? SNAME("GuiVisibilityHidden") : SNAME("GuiVisibilityVisible")));
+
+			camera_override_button->set_icon(get_editor_theme_icon(SNAME("Camera")));
+			camera_override_menu->set_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
+
+			panel->set_theme_type_variation("GamePanel");
+		} break;
+	}
+}
+
+GameEditor::GameEditor(Ref<GameEditorDebugger> p_debugger) {
+	debugger = p_debugger;
+
+	// Add some margin to the sides for better aesthetics.
+	// This prevents the first button's hover/pressed effect from "touching" the panel's border,
+	// which looks ugly.
+	MarginContainer *toolbar_margin = memnew(MarginContainer);
+	toolbar_margin->add_theme_constant_override("margin_left", 4 * EDSCALE);
+	toolbar_margin->add_theme_constant_override("margin_right", 4 * EDSCALE);
+	add_child(toolbar_margin);
+
+	HBoxContainer *main_menu_hbox = memnew(HBoxContainer);
+	toolbar_margin->add_child(main_menu_hbox);
+
+	suspend_button = memnew(Button);
+	main_menu_hbox->add_child(suspend_button);
+	suspend_button->set_toggle_mode(true);
+	suspend_button->set_theme_type_variation("FlatButton");
+	suspend_button->connect(SceneStringName(toggled), callable_mp(this, &GameEditor::_suspend_button_toggled));
+	suspend_button->set_tooltip_text(TTR("Suspend"));
+
+	next_frame_button = memnew(Button);
+	main_menu_hbox->add_child(next_frame_button);
+	next_frame_button->set_theme_type_variation("FlatButton");
+	next_frame_button->connect(SceneStringName(pressed), callable_mp(*debugger, &GameEditorDebugger::next_frame));
+	next_frame_button->set_tooltip_text(TTR("Next Frame"));
+
+	main_menu_hbox->add_child(memnew(VSeparator));
+
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE] = memnew(Button);
+	main_menu_hbox->add_child(node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_text(TTR("Input"));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_toggle_mode(true);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_pressed(true);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_theme_type_variation("FlatButton");
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->connect(SceneStringName(pressed), callable_mp(this, &GameEditor::_node_type_pressed).bind(RuntimeNodeSelect::NODE_TYPE_NONE));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_NONE]->set_tooltip_text(TTR("Allow game input."));
+
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D] = memnew(Button);
+	main_menu_hbox->add_child(node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->set_text(TTR("2D"));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->set_toggle_mode(true);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->set_theme_type_variation("FlatButton");
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->connect(SceneStringName(pressed), callable_mp(this, &GameEditor::_node_type_pressed).bind(RuntimeNodeSelect::NODE_TYPE_2D));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_2D]->set_tooltip_text(TTR("Disable game input and allow to select Node2Ds, Controls, and manipulate the 2D camera."));
+
+#ifndef _3D_DISABLED
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D] = memnew(Button);
+	main_menu_hbox->add_child(node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->set_text(TTR("3D"));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->set_toggle_mode(true);
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->set_theme_type_variation("FlatButton");
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->connect(SceneStringName(pressed), callable_mp(this, &GameEditor::_node_type_pressed).bind(RuntimeNodeSelect::NODE_TYPE_3D));
+	node_type_button[RuntimeNodeSelect::NODE_TYPE_3D]->set_tooltip_text(TTR("Disable game input and allow to select Node3Ds and manipulate the 3D camera."));
+#endif // _3D_DISABLED
+
+	main_menu_hbox->add_child(memnew(VSeparator));
+
+	hide_selection = memnew(Button);
+	main_menu_hbox->add_child(hide_selection);
+	hide_selection->set_toggle_mode(true);
+	hide_selection->set_theme_type_variation("FlatButton");
+	hide_selection->connect(SceneStringName(toggled), callable_mp(this, &GameEditor::_hide_selection_toggled));
+	hide_selection->set_tooltip_text(TTR("Toggle Selection Visibility"));
+
+	main_menu_hbox->add_child(memnew(VSeparator));
+
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE] = memnew(Button);
+	main_menu_hbox->add_child(select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_toggle_mode(true);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_pressed(true);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_theme_type_variation("FlatButton");
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->connect(SceneStringName(pressed), callable_mp(this, &GameEditor::_select_mode_pressed).bind(RuntimeNodeSelect::SELECT_MODE_SINGLE));
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_select", TTR("Select Mode"), Key::Q));
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_shortcut_context(this);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_SINGLE]->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Alt+RMB: Show list of all nodes at position clicked."));
+
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST] = memnew(Button);
+	main_menu_hbox->add_child(select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]->set_toggle_mode(true);
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]->set_theme_type_variation("FlatButton");
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]->connect(SceneStringName(pressed), callable_mp(this, &GameEditor::_select_mode_pressed).bind(RuntimeNodeSelect::SELECT_MODE_LIST));
+	select_mode_button[RuntimeNodeSelect::SELECT_MODE_LIST]->set_tooltip_text(TTR("Show list of selectable nodes at position clicked."));
+
+	main_menu_hbox->add_child(memnew(VSeparator));
+
+	camera_override_button = memnew(Button);
+	main_menu_hbox->add_child(camera_override_button);
+	camera_override_button->set_toggle_mode(true);
+	camera_override_button->set_theme_type_variation("FlatButton");
+	camera_override_button->connect(SceneStringName(toggled), callable_mp(this, &GameEditor::_camera_override_button_toggled));
+	camera_override_button->set_tooltip_text(TTR("Override the in-game camera."));
+
+	camera_override_menu = memnew(MenuButton);
+	main_menu_hbox->add_child(camera_override_menu);
+	camera_override_menu->set_flat(false);
+	camera_override_menu->set_theme_type_variation("FlatMenuButton");
+	camera_override_menu->set_h_size_flags(SIZE_SHRINK_END);
+	camera_override_menu->set_tooltip_text(TTR("Camera Override Options"));
+
+	PopupMenu *menu = camera_override_menu->get_popup();
+	menu->connect(SceneStringName(id_pressed), callable_mp(this, &GameEditor::_camera_override_menu_id_pressed));
+	menu->add_item(TTR("Reset 2D Position"), CAMERA_RESET_2D);
+	menu->add_item(TTR("Reset 3D Position"), CAMERA_RESET_3D);
+	menu->add_separator();
+	menu->add_radio_check_item(TTR("Manipulate In-Game"), CAMERA_MODE_INGAME);
+	menu->set_item_checked(menu->get_item_index(CAMERA_MODE_INGAME), true);
+	menu->add_radio_check_item(TTR("Manipulate From Editors"), CAMERA_MODE_EDITORS);
+
+	_update_debugger_buttons();
+
+	panel = memnew(Panel);
+	add_child(panel);
+	panel->set_v_size_flags(SIZE_EXPAND_FILL);
+
+	p_debugger->connect("session_started", callable_mp(this, &GameEditor::_sessions_changed));
+	p_debugger->connect("session_stopped", callable_mp(this, &GameEditor::_sessions_changed));
+}
+
+///////
+
+void GameEditorPlugin::make_visible(bool p_visible) {
+	game_editor->set_visible(p_visible);
+}
+
+void GameEditorPlugin::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			add_debugger_plugin(debugger);
+		} break;
+		case NOTIFICATION_EXIT_TREE: {
+			remove_debugger_plugin(debugger);
+		} break;
+	}
+}
+
+GameEditorPlugin::GameEditorPlugin() {
+	debugger.instantiate();
+
+	game_editor = memnew(GameEditor(debugger));
+	game_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
+	EditorNode::get_singleton()->get_editor_main_screen()->get_control()->add_child(game_editor);
+	game_editor->hide();
+}
+
+GameEditorPlugin::~GameEditorPlugin() {
+}
diff --git a/editor/plugins/game_editor_plugin.h b/editor/plugins/game_editor_plugin.h
new file mode 100644
index 000000000000..30ba94e0964f
--- /dev/null
+++ b/editor/plugins/game_editor_plugin.h
@@ -0,0 +1,147 @@
+/**************************************************************************/
+/*  game_editor_plugin.h                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* 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 GAME_EDITOR_PLUGIN_H
+#define GAME_EDITOR_PLUGIN_H
+
+#include "editor/debugger/editor_debugger_node.h"
+#include "editor/plugins/editor_debugger_plugin.h"
+#include "editor/plugins/editor_plugin.h"
+#include "scene/debugger/scene_debugger.h"
+#include "scene/gui/box_container.h"
+#include "scene/gui/menu_button.h"
+
+class GameEditorDebugger : public EditorDebuggerPlugin {
+	GDCLASS(GameEditorDebugger, EditorDebuggerPlugin);
+
+private:
+	Vector<Ref<EditorDebuggerSession>> sessions;
+
+	int node_type = RuntimeNodeSelect::NODE_TYPE_NONE;
+	bool selection_visible = true;
+	int select_mode = RuntimeNodeSelect::SELECT_MODE_SINGLE;
+	EditorDebuggerNode::CameraOverride camera_override_mode = EditorDebuggerNode::OVERRIDE_INGAME;
+
+	void _session_started(Ref<EditorDebuggerSession> p_session);
+	void _session_stopped();
+
+protected:
+	static void _bind_methods();
+
+public:
+	void set_suspend(bool p_enabled);
+	void next_frame();
+
+	void set_node_type(int p_type);
+	void set_select_mode(int p_mode);
+
+	void set_selection_visible(bool p_visible);
+
+	void set_camera_override(bool p_enabled);
+	void set_camera_manipulate_mode(EditorDebuggerNode::CameraOverride p_mode);
+
+	void reset_camera_2d_position();
+	void reset_camera_3d_position();
+
+	virtual void setup_session(int p_session_id) override;
+
+	GameEditorDebugger() {}
+};
+
+class GameEditor : public VBoxContainer {
+	GDCLASS(GameEditor, VBoxContainer);
+
+	enum {
+		CAMERA_RESET_2D,
+		CAMERA_RESET_3D,
+		CAMERA_MODE_INGAME,
+		CAMERA_MODE_EDITORS
+	};
+
+	Ref<GameEditorDebugger> debugger;
+
+	int active_sessions = 0;
+
+	Button *suspend_button = nullptr;
+	Button *next_frame_button = nullptr;
+
+	Button *node_type_button[RuntimeNodeSelect::NODE_TYPE_MAX];
+	Button *select_mode_button[RuntimeNodeSelect::SELECT_MODE_MAX];
+
+	Button *hide_selection = nullptr;
+
+	Button *camera_override_button = nullptr;
+	MenuButton *camera_override_menu = nullptr;
+
+	Panel *panel = nullptr;
+
+	void _sessions_changed();
+
+	void _update_debugger_buttons();
+
+	void _suspend_button_toggled(bool p_pressed);
+
+	void _node_type_pressed(int p_option);
+	void _select_mode_pressed(int p_option);
+
+	void _hide_selection_toggled(bool p_pressed);
+
+	void _camera_override_button_toggled(bool p_pressed);
+	void _camera_override_menu_id_pressed(int p_id);
+
+protected:
+	void _notification(int p_what);
+
+public:
+	GameEditor(Ref<GameEditorDebugger> p_debugger);
+};
+
+class GameEditorPlugin : public EditorPlugin {
+	GDCLASS(GameEditorPlugin, EditorPlugin);
+
+	GameEditor *game_editor = nullptr;
+
+	Ref<GameEditorDebugger> debugger;
+
+protected:
+	void _notification(int p_what);
+
+public:
+	virtual String get_name() const override { return "Game"; }
+	bool has_main_screen() const override { return true; }
+	virtual void edit(Object *p_object) override {}
+	virtual bool handles(Object *p_object) const override { return false; }
+	virtual void make_visible(bool p_visible) override;
+
+	GameEditorPlugin();
+	~GameEditorPlugin();
+};
+
+#endif // GAME_EDITOR_PLUGIN_H
diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp
index dc86acd884d5..44796f4988a5 100644
--- a/editor/plugins/node_3d_editor_plugin.cpp
+++ b/editor/plugins/node_3d_editor_plugin.cpp
@@ -1691,7 +1691,7 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
 	Ref<InputEventMouseButton> b = p_event;
 
 	if (b.is_valid()) {
-		emit_signal(SNAME("clicked"), this);
+		emit_signal(SNAME("clicked"));
 
 		ViewportNavMouseButton orbit_mouse_preference = (ViewportNavMouseButton)EDITOR_GET("editors/3d/navigation/orbit_mouse_button").operator int();
 		ViewportNavMouseButton pan_mouse_preference = (ViewportNavMouseButton)EDITOR_GET("editors/3d/navigation/pan_mouse_button").operator int();
@@ -4184,7 +4184,7 @@ Dictionary Node3DEditorViewport::get_state() const {
 
 void Node3DEditorViewport::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("toggle_maximize_view", PropertyInfo(Variant::OBJECT, "viewport")));
-	ADD_SIGNAL(MethodInfo("clicked", PropertyInfo(Variant::OBJECT, "viewport")));
+	ADD_SIGNAL(MethodInfo("clicked"));
 }
 
 void Node3DEditorViewport::reset() {
@@ -6483,18 +6483,6 @@ void Node3DEditor::_menu_item_toggled(bool pressed, int p_option) {
 			tool_option_button[TOOL_OPT_USE_SNAP]->set_pressed(pressed);
 			snap_enabled = pressed;
 		} break;
-
-		case MENU_TOOL_OVERRIDE_CAMERA: {
-			EditorDebuggerNode *const debugger = EditorDebuggerNode::get_singleton();
-
-			using Override = EditorDebuggerNode::CameraOverride;
-			if (pressed) {
-				debugger->set_camera_override((Override)(Override::OVERRIDE_3D_1 + camera_override_viewport_id));
-			} else {
-				debugger->set_camera_override(Override::OVERRIDE_NONE);
-			}
-
-		} break;
 	}
 }
 
@@ -6521,36 +6509,6 @@ void Node3DEditor::_menu_gizmo_toggled(int p_option) {
 	update_all_gizmos();
 }
 
-void Node3DEditor::_update_camera_override_button(bool p_game_running) {
-	Button *const button = tool_option_button[TOOL_OPT_OVERRIDE_CAMERA];
-
-	if (p_game_running) {
-		button->set_disabled(false);
-		button->set_tooltip_text(TTR("Project Camera Override\nOverrides the running project's camera with the editor viewport camera."));
-	} else {
-		button->set_disabled(true);
-		button->set_pressed(false);
-		button->set_tooltip_text(TTR("Project Camera Override\nNo project instance running. Run the project from the editor to use this feature."));
-	}
-}
-
-void Node3DEditor::_update_camera_override_viewport(Object *p_viewport) {
-	Node3DEditorViewport *current_viewport = Object::cast_to<Node3DEditorViewport>(p_viewport);
-
-	if (!current_viewport) {
-		return;
-	}
-
-	EditorDebuggerNode *const debugger = EditorDebuggerNode::get_singleton();
-
-	camera_override_viewport_id = current_viewport->index;
-	if (debugger->get_camera_override() >= EditorDebuggerNode::OVERRIDE_3D_1) {
-		using Override = EditorDebuggerNode::CameraOverride;
-
-		debugger->set_camera_override((Override)(Override::OVERRIDE_3D_1 + camera_override_viewport_id));
-	}
-}
-
 void Node3DEditor::_menu_item_pressed(int p_option) {
 	EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
 	switch (p_option) {
@@ -6581,6 +6539,9 @@ void Node3DEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_USE_1_VIEWPORT: {
 			viewport_base->set_view(Node3DEditorViewportContainer::VIEW_USE_1_VIEWPORT);
+			if (last_used_viewport > 0) {
+				last_used_viewport = 0;
+			}
 
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), true);
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false);
@@ -6592,6 +6553,9 @@ void Node3DEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_USE_2_VIEWPORTS: {
 			viewport_base->set_view(Node3DEditorViewportContainer::VIEW_USE_2_VIEWPORTS);
+			if (last_used_viewport > 1) {
+				last_used_viewport = 0;
+			}
 
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false);
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), true);
@@ -6603,6 +6567,9 @@ void Node3DEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_USE_2_VIEWPORTS_ALT: {
 			viewport_base->set_view(Node3DEditorViewportContainer::VIEW_USE_2_VIEWPORTS_ALT);
+			if (last_used_viewport > 1) {
+				last_used_viewport = 0;
+			}
 
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false);
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false);
@@ -6614,6 +6581,9 @@ void Node3DEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_USE_3_VIEWPORTS: {
 			viewport_base->set_view(Node3DEditorViewportContainer::VIEW_USE_3_VIEWPORTS);
+			if (last_used_viewport > 2) {
+				last_used_viewport = 0;
+			}
 
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false);
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false);
@@ -6625,6 +6595,9 @@ void Node3DEditor::_menu_item_pressed(int p_option) {
 		} break;
 		case MENU_VIEW_USE_3_VIEWPORTS_ALT: {
 			viewport_base->set_view(Node3DEditorViewportContainer::VIEW_USE_3_VIEWPORTS_ALT);
+			if (last_used_viewport > 2) {
+				last_used_viewport = 0;
+			}
 
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), false);
 			view_menu->get_popup()->set_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), false);
@@ -7944,7 +7917,6 @@ void Node3DEditor::_update_theme() {
 
 	tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_icon(get_editor_theme_icon(SNAME("Object")));
 	tool_option_button[TOOL_OPT_USE_SNAP]->set_icon(get_editor_theme_icon(SNAME("Snap")));
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_icon(get_editor_theme_icon(SNAME("Camera3D")));
 
 	view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_1_VIEWPORT), get_editor_theme_icon(SNAME("Panels1")));
 	view_menu->get_popup()->set_item_icon(view_menu->get_popup()->get_item_index(MENU_VIEW_USE_2_VIEWPORTS), get_editor_theme_icon(SNAME("Panels2")));
@@ -7979,9 +7951,6 @@ void Node3DEditor::_notification(int p_what) {
 			SceneTreeDock::get_singleton()->get_tree_editor()->connect("node_changed", callable_mp(this, &Node3DEditor::_refresh_menu_icons));
 			editor_selection->connect("selection_changed", callable_mp(this, &Node3DEditor::_selection_changed));
 
-			EditorRunBar::get_singleton()->connect("stop_pressed", callable_mp(this, &Node3DEditor::_update_camera_override_button).bind(false));
-			EditorRunBar::get_singleton()->connect("play_pressed", callable_mp(this, &Node3DEditor::_update_camera_override_button).bind(true));
-
 			_update_preview_environment();
 
 			sun_state->set_custom_minimum_size(sun_vb->get_combined_minimum_size());
@@ -8017,15 +7986,6 @@ void Node3DEditor::_notification(int p_what) {
 			}
 		} break;
 
-		case NOTIFICATION_VISIBILITY_CHANGED: {
-			if (!is_visible() && tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->is_pressed()) {
-				EditorDebuggerNode *debugger = EditorDebuggerNode::get_singleton();
-
-				debugger->set_camera_override(EditorDebuggerNode::OVERRIDE_NONE);
-				tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_pressed(false);
-			}
-		} break;
-
 		case NOTIFICATION_PHYSICS_PROCESS: {
 			if (do_snap_selected_nodes_to_floor) {
 				_snap_selected_nodes_to_floor();
@@ -8127,6 +8087,10 @@ VSplitContainer *Node3DEditor::get_shader_split() {
 	return shader_split;
 }
 
+Node3DEditorViewport *Node3DEditor::get_last_used_viewport() {
+	return viewports[last_used_viewport];
+}
+
 void Node3DEditor::add_control_to_left_panel(Control *p_control) {
 	left_panel_split->add_child(p_control);
 	left_panel_split->move_child(p_control, 0);
@@ -8304,6 +8268,10 @@ void Node3DEditor::_toggle_maximize_view(Object *p_viewport) {
 	}
 }
 
+void Node3DEditor::_viewport_clicked(int p_viewport_idx) {
+	last_used_viewport = p_viewport_idx;
+}
+
 void Node3DEditor::_node_added(Node *p_node) {
 	if (EditorNode::get_singleton()->get_scene_root()->is_ancestor_of(p_node)) {
 		if (Object::cast_to<WorldEnvironment>(p_node)) {
@@ -8595,8 +8563,6 @@ Node3DEditor::Node3DEditor() {
 	snap_key_enabled = false;
 	tool_mode = TOOL_MODE_SELECT;
 
-	camera_override_viewport_id = 0;
-
 	// Add some margin to the sides for better aesthetics.
 	// This prevents the first button's hover/pressed effect from "touching" the panel's border,
 	// which looks ugly.
@@ -8713,16 +8679,6 @@ Node3DEditor::Node3DEditor() {
 	tool_option_button[TOOL_OPT_USE_SNAP]->set_shortcut(ED_SHORTCUT("spatial_editor/snap", TTR("Use Snap"), Key::Y));
 	tool_option_button[TOOL_OPT_USE_SNAP]->set_shortcut_context(this);
 
-	main_menu_hbox->add_child(memnew(VSeparator));
-
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA] = memnew(Button);
-	main_menu_hbox->add_child(tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]);
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_toggle_mode(true);
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_theme_type_variation("FlatButton");
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_disabled(true);
-	tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->connect(SceneStringName(toggled), callable_mp(this, &Node3DEditor::_menu_item_toggled).bind(MENU_TOOL_OVERRIDE_CAMERA));
-	_update_camera_override_button(false);
-
 	main_menu_hbox->add_child(memnew(VSeparator));
 	sun_button = memnew(Button);
 	sun_button->set_tooltip_text(TTR("Toggle preview sunlight.\nIf a DirectionalLight3D node is added to the scene, preview sunlight is disabled."));
@@ -8866,7 +8822,7 @@ Node3DEditor::Node3DEditor() {
 	for (uint32_t i = 0; i < VIEWPORTS_COUNT; i++) {
 		viewports[i] = memnew(Node3DEditorViewport(this, i));
 		viewports[i]->connect("toggle_maximize_view", callable_mp(this, &Node3DEditor::_toggle_maximize_view));
-		viewports[i]->connect("clicked", callable_mp(this, &Node3DEditor::_update_camera_override_viewport));
+		viewports[i]->connect("clicked", callable_mp(this, &Node3DEditor::_viewport_clicked).bind(i));
 		viewports[i]->assign_pending_data_pointers(preview_node, &preview_bounds, accept);
 		viewport_base->add_child(viewports[i]);
 	}
diff --git a/editor/plugins/node_3d_editor_plugin.h b/editor/plugins/node_3d_editor_plugin.h
index c7e6420875e0..2e41e43bf180 100644
--- a/editor/plugins/node_3d_editor_plugin.h
+++ b/editor/plugins/node_3d_editor_plugin.h
@@ -622,7 +622,6 @@ class Node3DEditor : public VBoxContainer {
 	enum ToolOptions {
 		TOOL_OPT_LOCAL_COORDS,
 		TOOL_OPT_USE_SNAP,
-		TOOL_OPT_OVERRIDE_CAMERA,
 		TOOL_OPT_MAX
 
 	};
@@ -632,6 +631,7 @@ class Node3DEditor : public VBoxContainer {
 
 	Node3DEditorViewportContainer *viewport_base = nullptr;
 	Node3DEditorViewport *viewports[VIEWPORTS_COUNT];
+	int last_used_viewport = 0;
 	VSplitContainer *shader_split = nullptr;
 	HSplitContainer *left_panel_split = nullptr;
 	HSplitContainer *right_panel_split = nullptr;
@@ -704,7 +704,6 @@ class Node3DEditor : public VBoxContainer {
 		MENU_TOOL_LIST_SELECT,
 		MENU_TOOL_LOCAL_COORDS,
 		MENU_TOOL_USE_SNAP,
-		MENU_TOOL_OVERRIDE_CAMERA,
 		MENU_TRANSFORM_CONFIGURE_SNAP,
 		MENU_TRANSFORM_DIALOG,
 		MENU_VIEW_USE_1_VIEWPORT,
@@ -759,8 +758,6 @@ class Node3DEditor : public VBoxContainer {
 	void _menu_item_pressed(int p_option);
 	void _menu_item_toggled(bool pressed, int p_option);
 	void _menu_gizmo_toggled(int p_option);
-	void _update_camera_override_button(bool p_game_running);
-	void _update_camera_override_viewport(Object *p_viewport);
 	// Used for secondary menu items which are displayed depending on the currently selected node
 	// (such as MeshInstance's "Mesh" menu).
 	PanelContainer *context_toolbar_panel = nullptr;
@@ -771,8 +768,6 @@ class Node3DEditor : public VBoxContainer {
 
 	void _generate_selection_boxes();
 
-	int camera_override_viewport_id;
-
 	void _init_indicators();
 	void _update_gizmos_menu();
 	void _update_gizmos_menu_theme();
@@ -781,6 +776,7 @@ class Node3DEditor : public VBoxContainer {
 	void _finish_grid();
 
 	void _toggle_maximize_view(Object *p_viewport);
+	void _viewport_clicked(int p_viewport_idx);
 
 	Node *custom_camera = nullptr;
 
@@ -967,6 +963,7 @@ class Node3DEditor : public VBoxContainer {
 		ERR_FAIL_INDEX_V(p_idx, static_cast<int>(VIEWPORTS_COUNT), nullptr);
 		return viewports[p_idx];
 	}
+	Node3DEditorViewport *get_last_used_viewport();
 
 	void add_gizmo_plugin(Ref<EditorNode3DGizmoPlugin> p_plugin);
 	void remove_gizmo_plugin(Ref<EditorNode3DGizmoPlugin> p_plugin);
diff --git a/editor/themes/editor_theme_manager.cpp b/editor/themes/editor_theme_manager.cpp
index 17bcbacfc204..42649588c0cd 100644
--- a/editor/themes/editor_theme_manager.cpp
+++ b/editor/themes/editor_theme_manager.cpp
@@ -1846,6 +1846,12 @@ void EditorThemeManager::_populate_editor_styles(const Ref<EditorTheme> &p_theme
 		p_theme->set_stylebox("ScriptEditorPanelFloating", EditorStringName(EditorStyles), make_empty_stylebox(0, 0, 0, 0));
 		p_theme->set_stylebox("ScriptEditor", EditorStringName(EditorStyles), make_empty_stylebox(0, 0, 0, 0));
 
+		// Game editor.
+		p_theme->set_type_variation("GamePanel", "Panel");
+		Ref<StyleBoxFlat> game_panel = p_theme->get_stylebox(SNAME("panel"), SNAME("Panel"))->duplicate();
+		game_panel->set_corner_radius_all(0);
+		p_theme->set_stylebox(SceneStringName(panel), "GamePanel", game_panel);
+
 		// Main menu.
 		Ref<StyleBoxFlat> menu_transparent_style = p_config.button_style->duplicate();
 		menu_transparent_style->set_bg_color(Color(1, 1, 1, 0));
diff --git a/misc/extension_api_validation/4.3-stable.expected b/misc/extension_api_validation/4.3-stable.expected
index 960edd0575e7..fd63208a20de 100644
--- a/misc/extension_api_validation/4.3-stable.expected
+++ b/misc/extension_api_validation/4.3-stable.expected
@@ -7,6 +7,12 @@ should instead be used to justify these changes and describe how users should wo
 Add new entries at the end of the file.
 
 ## Changes between 4.3-stable and 4.4-stable
+GH-97257
+--------
+Validate extension JSON: Error: Field 'classes/EditorFeatureProfile/enums/Feature/values/FEATURE_MAX': value changed value in new API, from 8.0 to 9.
+
+New entry to the `EditorFeatureProfile.Feature` enum added. Those need to go before `FEATURE_MAX`, which will always cause a compatibility break.
+
 
 GH-95374
 --------
diff --git a/scene/2d/camera_2d.cpp b/scene/2d/camera_2d.cpp
index 7020d162feb6..dcc35e29d929 100644
--- a/scene/2d/camera_2d.cpp
+++ b/scene/2d/camera_2d.cpp
@@ -31,6 +31,7 @@
 #include "camera_2d.h"
 
 #include "core/config/project_settings.h"
+#include "scene/main/node.h"
 #include "scene/main/window.h"
 
 bool Camera2D::_is_editing_in_editor() const {
@@ -302,6 +303,7 @@ void Camera2D::_notification(int p_what) {
 			_interpolation_data.xform_prev = _interpolation_data.xform_curr;
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (is_physics_interpolated_and_enabled()) {
 				_update_scroll();
diff --git a/scene/2d/gpu_particles_2d.cpp b/scene/2d/gpu_particles_2d.cpp
index cfdcbee86a79..49857e4a1b48 100644
--- a/scene/2d/gpu_particles_2d.cpp
+++ b/scene/2d/gpu_particles_2d.cpp
@@ -31,6 +31,7 @@
 #include "gpu_particles_2d.h"
 
 #include "scene/2d/cpu_particles_2d.h"
+#include "scene/main/node.h"
 #include "scene/resources/atlas_texture.h"
 #include "scene/resources/curve_texture.h"
 #include "scene/resources/gradient_texture.h"
@@ -696,6 +697,8 @@ void GPUParticles2D::_notification(int p_what) {
 			RS::get_singleton()->particles_set_subemitter(particles, RID());
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
+		case NOTIFICATION_UNSUSPENDED:
 		case NOTIFICATION_PAUSED:
 		case NOTIFICATION_UNPAUSED: {
 			if (is_inside_tree()) {
diff --git a/scene/2d/navigation_agent_2d.cpp b/scene/2d/navigation_agent_2d.cpp
index d0fae611d88a..f00838e759a8 100644
--- a/scene/2d/navigation_agent_2d.cpp
+++ b/scene/2d/navigation_agent_2d.cpp
@@ -32,6 +32,7 @@
 
 #include "core/math/geometry_2d.h"
 #include "scene/2d/navigation_link_2d.h"
+#include "scene/main/node.h"
 #include "scene/resources/world_2d.h"
 #include "servers/navigation_server_2d.h"
 
@@ -253,12 +254,20 @@ void NavigationAgent2D::_notification(int p_what) {
 #endif // DEBUG_ENABLED
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (agent_parent) {
 				NavigationServer2D::get_singleton()->agent_set_paused(get_rid(), !agent_parent->can_process());
 			}
 		} break;
 
+		case NOTIFICATION_UNSUSPENDED: {
+			if (get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case NOTIFICATION_UNPAUSED: {
 			if (agent_parent) {
 				NavigationServer2D::get_singleton()->agent_set_paused(get_rid(), !agent_parent->can_process());
diff --git a/scene/2d/navigation_obstacle_2d.cpp b/scene/2d/navigation_obstacle_2d.cpp
index 3bf90249f8b5..a4247e8f36ac 100644
--- a/scene/2d/navigation_obstacle_2d.cpp
+++ b/scene/2d/navigation_obstacle_2d.cpp
@@ -31,6 +31,7 @@
 #include "navigation_obstacle_2d.h"
 
 #include "core/math/geometry_2d.h"
+#include "scene/main/node.h"
 #include "scene/resources/world_2d.h"
 #include "servers/navigation_server_2d.h"
 #include "servers/navigation_server_3d.h"
@@ -104,6 +105,7 @@ void NavigationObstacle2D::_notification(int p_what) {
 #endif // DEBUG_ENABLED
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (!can_process()) {
 				map_before_pause = map_current;
@@ -115,6 +117,13 @@ void NavigationObstacle2D::_notification(int p_what) {
 			NavigationServer2D::get_singleton()->obstacle_set_paused(obstacle, !can_process());
 		} break;
 
+		case NOTIFICATION_UNSUSPENDED: {
+			if (get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case NOTIFICATION_UNPAUSED: {
 			if (!can_process()) {
 				map_before_pause = map_current;
diff --git a/scene/2d/touch_screen_button.cpp b/scene/2d/touch_screen_button.cpp
index ff409272c549..63a20a562239 100644
--- a/scene/2d/touch_screen_button.cpp
+++ b/scene/2d/touch_screen_button.cpp
@@ -30,6 +30,7 @@
 
 #include "touch_screen_button.h"
 
+#include "scene/main/node.h"
 #include "scene/main/window.h"
 
 void TouchScreenButton::set_texture_normal(const Ref<Texture2D> &p_texture) {
@@ -185,6 +186,7 @@ void TouchScreenButton::_notification(int p_what) {
 			}
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (is_pressed()) {
 				_release();
diff --git a/scene/3d/camera_3d.cpp b/scene/3d/camera_3d.cpp
index c70fa3ca2e7a..4bea34188d78 100644
--- a/scene/3d/camera_3d.cpp
+++ b/scene/3d/camera_3d.cpp
@@ -32,6 +32,7 @@
 
 #include "core/math/projection.h"
 #include "core/math/transform_interpolator.h"
+#include "scene/main/node.h"
 #include "scene/main/viewport.h"
 #include "servers/rendering/rendering_server_constants.h"
 
@@ -234,6 +235,7 @@ void Camera3D::_notification(int p_what) {
 			}
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (is_physics_interpolated_and_enabled() && is_inside_tree() && is_visible_in_tree()) {
 				_physics_interpolation_ensure_transform_calculated(true);
diff --git a/scene/3d/gpu_particles_3d.cpp b/scene/3d/gpu_particles_3d.cpp
index 2cef607d2968..9f7d612e4971 100644
--- a/scene/3d/gpu_particles_3d.cpp
+++ b/scene/3d/gpu_particles_3d.cpp
@@ -31,6 +31,7 @@
 #include "gpu_particles_3d.h"
 
 #include "scene/3d/cpu_particles_3d.h"
+#include "scene/main/node.h"
 #include "scene/resources/curve_texture.h"
 #include "scene/resources/gradient_texture.h"
 #include "scene/resources/particle_process_material.h"
@@ -511,6 +512,8 @@ void GPUParticles3D::_notification(int p_what) {
 			RS::get_singleton()->particles_set_subemitter(particles, RID());
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
+		case NOTIFICATION_UNSUSPENDED:
 		case NOTIFICATION_PAUSED:
 		case NOTIFICATION_UNPAUSED: {
 			if (is_inside_tree()) {
diff --git a/scene/3d/navigation_agent_3d.cpp b/scene/3d/navigation_agent_3d.cpp
index 5bbb724e2fa0..7244f0fea2f5 100644
--- a/scene/3d/navigation_agent_3d.cpp
+++ b/scene/3d/navigation_agent_3d.cpp
@@ -31,6 +31,7 @@
 #include "navigation_agent_3d.h"
 
 #include "scene/3d/navigation_link_3d.h"
+#include "scene/main/node.h"
 #include "servers/navigation_server_3d.h"
 
 void NavigationAgent3D::_bind_methods() {
@@ -272,12 +273,20 @@ void NavigationAgent3D::_notification(int p_what) {
 #endif // DEBUG_ENABLED
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (agent_parent) {
 				NavigationServer3D::get_singleton()->agent_set_paused(get_rid(), !agent_parent->can_process());
 			}
 		} break;
 
+		case NOTIFICATION_UNSUSPENDED: {
+			if (get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case NOTIFICATION_UNPAUSED: {
 			if (agent_parent) {
 				NavigationServer3D::get_singleton()->agent_set_paused(get_rid(), !agent_parent->can_process());
diff --git a/scene/3d/navigation_obstacle_3d.cpp b/scene/3d/navigation_obstacle_3d.cpp
index f2ac8f789c9c..2eb04a0054e8 100644
--- a/scene/3d/navigation_obstacle_3d.cpp
+++ b/scene/3d/navigation_obstacle_3d.cpp
@@ -119,6 +119,7 @@ void NavigationObstacle3D::_notification(int p_what) {
 #endif // DEBUG_ENABLED
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (!can_process()) {
 				map_before_pause = map_current;
@@ -130,6 +131,13 @@ void NavigationObstacle3D::_notification(int p_what) {
 			NavigationServer3D::get_singleton()->obstacle_set_paused(obstacle, !can_process());
 		} break;
 
+		case NOTIFICATION_UNSUSPENDED: {
+			if (get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case NOTIFICATION_UNPAUSED: {
 			if (!can_process()) {
 				map_before_pause = map_current;
diff --git a/scene/audio/audio_stream_player_internal.cpp b/scene/audio/audio_stream_player_internal.cpp
index 7d1ed56ca8e9..621aa31fc61b 100644
--- a/scene/audio/audio_stream_player_internal.cpp
+++ b/scene/audio/audio_stream_player_internal.cpp
@@ -112,6 +112,7 @@ void AudioStreamPlayerInternal::notification(int p_what) {
 			stream_playbacks.clear();
 		} break;
 
+		case Node::NOTIFICATION_SUSPENDED:
 		case Node::NOTIFICATION_PAUSED: {
 			if (!node->can_process()) {
 				// Node can't process so we start fading out to silence
@@ -119,6 +120,13 @@ void AudioStreamPlayerInternal::notification(int p_what) {
 			}
 		} break;
 
+		case Node::NOTIFICATION_UNSUSPENDED: {
+			if (node->get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case Node::NOTIFICATION_UNPAUSED: {
 			set_stream_paused(false);
 		} break;
diff --git a/scene/debugger/scene_debugger.cpp b/scene/debugger/scene_debugger.cpp
index 07c32eef1360..d3ff933d40c7 100644
--- a/scene/debugger/scene_debugger.cpp
+++ b/scene/debugger/scene_debugger.cpp
@@ -35,6 +35,21 @@
 #include "core/io/marshalls.h"
 #include "core/object/script_language.h"
 #include "core/templates/local_vector.h"
+#include "scene/2d/physics/collision_object_2d.h"
+#include "scene/2d/physics/collision_polygon_2d.h"
+#include "scene/2d/physics/collision_shape_2d.h"
+#include "scene/gui/popup_menu.h"
+#ifndef _3D_DISABLED
+#include "core/math/transform_3d.h"
+#include "scene/3d/camera_3d.h"
+#include "scene/3d/label_3d.h"
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/physics/collision_object_3d.h"
+#include "scene/3d/physics/collision_shape_3d.h"
+#include "scene/3d/sprite_3d.h"
+#include "scene/resources/surface_tool.h"
+#endif
+#include "scene/main/canvas_layer.h"
 #include "scene/main/scene_tree.h"
 #include "scene/main/window.h"
 #include "scene/resources/packed_scene.h"
@@ -43,8 +58,11 @@ SceneDebugger *SceneDebugger::singleton = nullptr;
 
 SceneDebugger::SceneDebugger() {
 	singleton = this;
+
 #ifdef DEBUG_ENABLED
 	LiveEditor::singleton = memnew(LiveEditor);
+	RuntimeNodeSelect::singleton = memnew(RuntimeNodeSelect);
+
 	EngineDebugger::register_message_capture("scene", EngineDebugger::Capture(nullptr, SceneDebugger::parse_message));
 #endif
 }
@@ -56,7 +74,13 @@ SceneDebugger::~SceneDebugger() {
 		memdelete(LiveEditor::singleton);
 		LiveEditor::singleton = nullptr;
 	}
+
+	if (RuntimeNodeSelect::singleton) {
+		memdelete(RuntimeNodeSelect::singleton);
+		RuntimeNodeSelect::singleton = nullptr;
+	}
 #endif
+
 	singleton = nullptr;
 }
 
@@ -78,10 +102,15 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 	if (!scene_tree) {
 		return ERR_UNCONFIGURED;
 	}
+
 	LiveEditor *live_editor = LiveEditor::get_singleton();
 	if (!live_editor) {
 		return ERR_UNCONFIGURED;
 	}
+	RuntimeNodeSelect *runtime_node_select = RuntimeNodeSelect::get_singleton();
+	if (!runtime_node_select) {
+		return ERR_UNCONFIGURED;
+	}
 
 	r_captured = true;
 	if (p_msg == "request_scene_tree") { // Scene tree
@@ -99,22 +128,36 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 		ObjectID id = p_args[0];
 		_send_object_id(id);
 
-	} else if (p_msg == "override_camera_2D:set") { // Camera
+	} else if (p_msg == "suspend_changed") {
 		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
-		bool enforce = p_args[0];
-		scene_tree->get_root()->enable_canvas_transform_override(enforce);
+		bool suspended = p_args[0];
+		scene_tree->set_suspend(suspended);
+		runtime_node_select->_update_input_state();
 
-	} else if (p_msg == "override_camera_2D:transform") {
-		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
-		Transform2D transform = p_args[0];
-		scene_tree->get_root()->set_canvas_transform_override(transform);
-#ifndef _3D_DISABLED
-	} else if (p_msg == "override_camera_3D:set") {
+	} else if (p_msg == "next_frame") {
+		_next_frame();
+
+	} else if (p_msg == "override_cameras") { // Camera
 		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
 		bool enable = p_args[0];
+		bool from_editor = p_args[1];
+		scene_tree->get_root()->enable_canvas_transform_override(enable);
+#ifndef _3D_DISABLED
 		scene_tree->get_root()->enable_camera_3d_override(enable);
+#endif // _3D_DISABLED
+		runtime_node_select->_set_camera_override_enabled(enable && !from_editor);
 
-	} else if (p_msg == "override_camera_3D:transform") {
+	} else if (p_msg == "transform_camera_2D") {
+		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+		Transform2D transform = p_args[0];
+		scene_tree->get_root()->set_canvas_transform_override(transform);
+
+		if (runtime_node_select->selection_visible && scene_tree->is_suspended()) {
+			runtime_node_select->_update_selection();
+		}
+
+#ifndef _3D_DISABLED
+	} else if (p_msg == "transform_camera_3D") {
 		ERR_FAIL_COND_V(p_args.size() < 5, ERR_INVALID_DATA);
 		Transform3D transform = p_args[0];
 		bool is_perspective = p_args[1];
@@ -127,95 +170,146 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 			scene_tree->get_root()->set_camera_3d_override_orthogonal(size_or_fov, depth_near, depth_far);
 		}
 		scene_tree->get_root()->set_camera_3d_override_transform(transform);
+
+		if (runtime_node_select->selection_visible && scene_tree->is_suspended()) {
+			runtime_node_select->_update_selection();
+		}
 #endif // _3D_DISABLED
+
 	} else if (p_msg == "set_object_property") {
 		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
 		_set_object_property(p_args[0], p_args[1], p_args[2]);
 
-	} else if (!p_msg.begins_with("live_")) { // Live edits below.
-		return ERR_SKIP;
-	} else if (p_msg == "live_set_root") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		live_editor->_root_func(p_args[0], p_args[1]);
+		if (runtime_node_select->selection_visible && scene_tree->is_suspended()) {
+			runtime_node_select->_update_selection();
+		}
 
-	} else if (p_msg == "live_node_path") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		live_editor->_node_path_func(p_args[0], p_args[1]);
+	} else if (p_msg.begins_with("live_")) { /// Live Edit
+		if (p_msg == "live_set_root") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			live_editor->_root_func(p_args[0], p_args[1]);
+
+		} else if (p_msg == "live_node_path") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			live_editor->_node_path_func(p_args[0], p_args[1]);
+
+		} else if (p_msg == "live_res_path") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			live_editor->_res_path_func(p_args[0], p_args[1]);
+
+		} else if (p_msg == "live_node_prop_res") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_node_set_res_func(p_args[0], p_args[1], p_args[2]);
+
+		} else if (p_msg == "live_node_prop") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_node_set_func(p_args[0], p_args[1], p_args[2]);
+
+		} else if (p_msg == "live_res_prop_res") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_res_set_res_func(p_args[0], p_args[1], p_args[2]);
+
+		} else if (p_msg == "live_res_prop") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_res_set_func(p_args[0], p_args[1], p_args[2]);
+
+		} else if (p_msg == "live_node_call") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			LocalVector<Variant> args;
+			LocalVector<Variant *> argptrs;
+			args.resize(p_args.size() - 2);
+			argptrs.resize(args.size());
+			for (uint32_t i = 0; i < args.size(); i++) {
+				args[i] = p_args[i + 2];
+				argptrs[i] = &args[i];
+			}
+			live_editor->_node_call_func(p_args[0], p_args[1], argptrs.size() ? (const Variant **)argptrs.ptr() : nullptr, argptrs.size());
+
+		} else if (p_msg == "live_res_call") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			LocalVector<Variant> args;
+			LocalVector<Variant *> argptrs;
+			args.resize(p_args.size() - 2);
+			argptrs.resize(args.size());
+			for (uint32_t i = 0; i < args.size(); i++) {
+				args[i] = p_args[i + 2];
+				argptrs[i] = &args[i];
+			}
+			live_editor->_res_call_func(p_args[0], p_args[1], argptrs.size() ? (const Variant **)argptrs.ptr() : nullptr, argptrs.size());
 
-	} else if (p_msg == "live_res_path") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		live_editor->_res_path_func(p_args[0], p_args[1]);
+		} else if (p_msg == "live_create_node") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_create_node_func(p_args[0], p_args[1], p_args[2]);
 
-	} else if (p_msg == "live_node_prop_res") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_node_set_res_func(p_args[0], p_args[1], p_args[2]);
+		} else if (p_msg == "live_instantiate_node") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_instance_node_func(p_args[0], p_args[1], p_args[2]);
 
-	} else if (p_msg == "live_node_prop") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_node_set_func(p_args[0], p_args[1], p_args[2]);
+		} else if (p_msg == "live_remove_node") {
+			ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+			live_editor->_remove_node_func(p_args[0]);
 
-	} else if (p_msg == "live_res_prop_res") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_res_set_res_func(p_args[0], p_args[1], p_args[2]);
+			if (runtime_node_select->selection_visible && scene_tree->is_suspended()) {
+				runtime_node_select->_update_selection();
+			}
 
-	} else if (p_msg == "live_res_prop") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_res_set_func(p_args[0], p_args[1], p_args[2]);
+		} else if (p_msg == "live_remove_and_keep_node") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			live_editor->_remove_and_keep_node_func(p_args[0], p_args[1]);
 
-	} else if (p_msg == "live_node_call") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		LocalVector<Variant> args;
-		LocalVector<Variant *> argptrs;
-		args.resize(p_args.size() - 2);
-		argptrs.resize(args.size());
-		for (uint32_t i = 0; i < args.size(); i++) {
-			args[i] = p_args[i + 2];
-			argptrs[i] = &args[i];
-		}
-		live_editor->_node_call_func(p_args[0], p_args[1], argptrs.size() ? (const Variant **)argptrs.ptr() : nullptr, argptrs.size());
+			if (runtime_node_select->selection_visible && scene_tree->is_suspended()) {
+				runtime_node_select->_update_selection();
+			}
 
-	} else if (p_msg == "live_res_call") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		LocalVector<Variant> args;
-		LocalVector<Variant *> argptrs;
-		args.resize(p_args.size() - 2);
-		argptrs.resize(args.size());
-		for (uint32_t i = 0; i < args.size(); i++) {
-			args[i] = p_args[i + 2];
-			argptrs[i] = &args[i];
+		} else if (p_msg == "live_restore_node") {
+			ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
+			live_editor->_restore_node_func(p_args[0], p_args[1], p_args[2]);
+
+		} else if (p_msg == "live_duplicate_node") {
+			ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
+			live_editor->_duplicate_node_func(p_args[0], p_args[1]);
+
+		} else if (p_msg == "live_reparent_node") {
+			ERR_FAIL_COND_V(p_args.size() < 4, ERR_INVALID_DATA);
+			live_editor->_reparent_node_func(p_args[0], p_args[1], p_args[2], p_args[3]);
+
+		} else {
+			return ERR_SKIP;
 		}
-		live_editor->_res_call_func(p_args[0], p_args[1], argptrs.size() ? (const Variant **)argptrs.ptr() : nullptr, argptrs.size());
 
-	} else if (p_msg == "live_create_node") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_create_node_func(p_args[0], p_args[1], p_args[2]);
+	} else if (p_msg.begins_with("runtime_node_select_")) { /// Runtime Node Selection
+		if (p_msg == "runtime_node_select_setup") {
+			runtime_node_select->_setup();
 
-	} else if (p_msg == "live_instantiate_node") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_instance_node_func(p_args[0], p_args[1], p_args[2]);
+		} else if (p_msg == "runtime_node_select_set_type") {
+			ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+			RuntimeNodeSelect::NodeType type = (RuntimeNodeSelect::NodeType)(int)p_args[0];
+			runtime_node_select->_node_set_type(type);
 
-	} else if (p_msg == "live_remove_node") {
-		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
-		live_editor->_remove_node_func(p_args[0]);
+		} else if (p_msg == "runtime_node_select_set_mode") {
+			ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+			RuntimeNodeSelect::SelectMode mode = (RuntimeNodeSelect::SelectMode)(int)p_args[0];
+			runtime_node_select->_select_set_mode(mode);
 
-	} else if (p_msg == "live_remove_and_keep_node") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		live_editor->_remove_and_keep_node_func(p_args[0], p_args[1]);
+		} else if (p_msg == "runtime_node_select_set_visible") {
+			ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+			bool visible = p_args[0];
+			runtime_node_select->_set_selection_visible(visible);
 
-	} else if (p_msg == "live_restore_node") {
-		ERR_FAIL_COND_V(p_args.size() < 3, ERR_INVALID_DATA);
-		live_editor->_restore_node_func(p_args[0], p_args[1], p_args[2]);
+		} else if (p_msg == "runtime_node_select_reset_camera_2d") {
+			runtime_node_select->_reset_camera_2d_position();
 
-	} else if (p_msg == "live_duplicate_node") {
-		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
-		live_editor->_duplicate_node_func(p_args[0], p_args[1]);
+		} else if (p_msg == "runtime_node_select_reset_camera_3d") {
+			runtime_node_select->_reset_camera_3d_position();
+
+		} else {
+			return ERR_SKIP;
+		}
 
-	} else if (p_msg == "live_reparent_node") {
-		ERR_FAIL_COND_V(p_args.size() < 4, ERR_INVALID_DATA);
-		live_editor->_reparent_node_func(p_args[0], p_args[1], p_args[2], p_args[3]);
 	} else {
 		r_captured = false;
 	}
+
 	return OK;
 }
 
@@ -260,6 +354,9 @@ void SceneDebugger::_send_object_id(ObjectID p_id, int p_max_size) {
 		return;
 	}
 
+	Node *node = Object::cast_to<Node>(ObjectDB::get_instance(p_id));
+	RuntimeNodeSelect::get_singleton()->_select_node(node);
+
 	Array arr;
 	obj.serialize(arr);
 	EngineDebugger::get_singleton()->send_message("scene:inspect_object", arr);
@@ -280,6 +377,16 @@ void SceneDebugger::_set_object_property(ObjectID p_id, const String &p_property
 	obj->set(prop_name, p_value);
 }
 
+void SceneDebugger::_next_frame() {
+	SceneTree *scene_tree = SceneTree::get_singleton();
+	if (!scene_tree->is_suspended()) {
+		return;
+	}
+
+	scene_tree->set_suspend(false);
+	RenderingServer::get_singleton()->connect("frame_post_draw", callable_mp(scene_tree, &SceneTree::set_suspend).bind(true), Object::CONNECT_ONE_SHOT);
+}
+
 void SceneDebugger::add_to_cache(const String &p_filename, Node *p_node) {
 	LiveEditor *debugger = LiveEditor::get_singleton();
 	if (!debugger) {
@@ -1075,4 +1182,712 @@ void LiveEditor::_reparent_node_func(const NodePath &p_at, const NodePath &p_new
 	}
 }
 
+/// RuntimeNodeSelect
+RuntimeNodeSelect *RuntimeNodeSelect::singleton = nullptr;
+RuntimeNodeSelect *RuntimeNodeSelect::get_singleton() {
+	return singleton;
+}
+
+RuntimeNodeSelect::~RuntimeNodeSelect() {
+	if (selection_list) {
+		memdelete(selection_list);
+	}
+
+	if (sbox_2d_canvas.is_valid()) {
+		RS::get_singleton()->free(sbox_2d_canvas);
+		RS::get_singleton()->free(sbox_2d_ci);
+	}
+
+#ifndef _3D_DISABLED
+	if (sbox_3d_instance.is_valid()) {
+		RS::get_singleton()->free(sbox_3d_instance);
+		RS::get_singleton()->free(sbox_3d_instance_ofs);
+		RS::get_singleton()->free(sbox_3d_instance_xray);
+		RS::get_singleton()->free(sbox_3d_instance_xray_ofs);
+	}
+#endif // _3D_DISABLED
+}
+
+void RuntimeNodeSelect::_setup() {
+	Window *root = SceneTree::get_singleton()->get_root();
+	if (root->is_connected("window_input", callable_mp(this, &RuntimeNodeSelect::_root_window_input))) {
+		return;
+	}
+	root->connect("window_input", callable_mp(this, &RuntimeNodeSelect::_root_window_input));
+	root->connect("size_changed", callable_mp(this, &RuntimeNodeSelect::_update_selection), CONNECT_DEFERRED);
+
+	selection_list = memnew(PopupMenu);
+	selection_list->set_force_native(true);
+	selection_list->connect("index_pressed", callable_mp(this, &RuntimeNodeSelect::_items_popup_index_pressed).bind(selection_list));
+	selection_list->connect("popup_hide", callable_mp(Object::cast_to<Node>(root), &Node::remove_child).bind(selection_list));
+
+	panner.instantiate();
+	panner->set_callbacks(callable_mp(this, &RuntimeNodeSelect::_pan_callback), callable_mp(this, &RuntimeNodeSelect::_zoom_callback));
+
+	/// 2D Selection Box Generation
+
+	sbox_2d_canvas = RS::get_singleton()->canvas_create();
+	sbox_2d_ci = RS::get_singleton()->canvas_item_create();
+	RS::get_singleton()->viewport_attach_canvas(root->get_viewport_rid(), sbox_2d_canvas);
+	RS::get_singleton()->canvas_item_set_parent(sbox_2d_ci, sbox_2d_canvas);
+
+#ifndef _3D_DISABLED
+	cursor = Cursor();
+
+	/// 3D Selection Box Generation
+	// Copied from the Node3DEditor implementation.
+
+	// Use two AABBs to create the illusion of a slightly thicker line.
+	AABB aabb(Vector3(), Vector3(1, 1, 1));
+
+	// Create a x-ray (visible through solid surfaces) and standard version of the selection box.
+	// Both will be drawn at the same position, but with different opacity.
+	// This lets the user see where the selection is while still having a sense of depth.
+	Ref<SurfaceTool> st = memnew(SurfaceTool);
+	Ref<SurfaceTool> st_xray = memnew(SurfaceTool);
+
+	st->begin(Mesh::PRIMITIVE_LINES);
+	st_xray->begin(Mesh::PRIMITIVE_LINES);
+	for (int i = 0; i < 12; i++) {
+		Vector3 a, b;
+		aabb.get_edge(i, a, b);
+
+		st->add_vertex(a);
+		st->add_vertex(b);
+		st_xray->add_vertex(a);
+		st_xray->add_vertex(b);
+	}
+
+	Ref<StandardMaterial3D> mat = memnew(StandardMaterial3D);
+	mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+	mat->set_flag(StandardMaterial3D::FLAG_DISABLE_FOG, true);
+	// In the original Node3DEditor, this value would be fetched from the "editors/3d/selection_box_color" editor property,
+	// but since this is not accessible from here, we will just use the default value.
+	const Color selection_color_3d = Color(1, 0.5, 0);
+	mat->set_albedo(selection_color_3d);
+	mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+	st->set_material(mat);
+	sbox_3d_mesh = st->commit();
+
+	Ref<StandardMaterial3D> mat_xray = memnew(StandardMaterial3D);
+	mat_xray->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+	mat_xray->set_flag(StandardMaterial3D::FLAG_DISABLE_FOG, true);
+	mat_xray->set_flag(StandardMaterial3D::FLAG_DISABLE_DEPTH_TEST, true);
+	mat_xray->set_albedo(selection_color_3d * Color(1, 1, 1, 0.15));
+	mat_xray->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+	st_xray->set_material(mat_xray);
+	sbox_3d_mesh_xray = st_xray->commit();
+#endif // _3D_DISABLED
+}
+
+void RuntimeNodeSelect::_node_set_type(NodeType p_type) {
+	node_select_type = p_type;
+	_update_input_state();
+}
+
+void RuntimeNodeSelect::_select_set_mode(SelectMode p_mode) {
+	node_select_mode = p_mode;
+}
+
+void RuntimeNodeSelect::_set_camera_override_enabled(bool p_enabled) {
+	camera_override = p_enabled;
+
+	if (camera_first_override) {
+		_reset_camera_3d_position();
+		camera_first_override = false;
+	}
+
+	_update_view_2d();
+	_update_view_3d();
+}
+
+void RuntimeNodeSelect::_root_window_input(const Ref<InputEvent> &p_event) {
+	Window *root = SceneTree::get_singleton()->get_root();
+
+	if (camera_override) {
+		if (node_select_type == NODE_TYPE_2D) {
+			bool panner_active = panner->gui_input(p_event, Rect2(root->get_position_with_decorations(), root->get_position()));
+			if (panner_active) {
+				return;
+			}
+		} else if (node_select_type == NODE_TYPE_3D) {
+#ifndef _3D_DISABLED
+			if (root->get_camera_3d()) {
+				_handle_3d_input(p_event);
+			}
+#endif // _3D_DISABLED
+		}
+	}
+
+	if (node_select_type == NODE_TYPE_NONE || selection_list->is_visible()) {
+		return;
+	}
+
+	Ref<InputEventMouseButton> b = p_event;
+	if (!b.is_valid() || !b->is_pressed()) {
+		return;
+	}
+
+	bool list_shortcut = node_select_mode == SELECT_MODE_SINGLE && b->get_button_index() == MouseButton::RIGHT && b->is_alt_pressed();
+	if (!list_shortcut && b->get_button_index() != MouseButton::LEFT) {
+		return;
+	}
+
+	Transform2D canvas_override = camera_override ? root->get_canvas_transform_override() : root->get_canvas_transform();
+	Point2 pos = (canvas_override * root->get_screen_transform() * root->get_canvas_transform()).affine_inverse().xform(b->get_position());
+
+	Vector<SelectResult> items;
+	if (node_select_type == NODE_TYPE_2D) {
+		for (int i = 0; i < root->get_child_count(); i++) {
+			_find_canvas_items_at_pos(pos, root->get_child(i), items);
+		}
+
+		// Remove possible duplicates.
+		for (int i = 0; i < items.size(); i++) {
+			Node *item = items[i].item;
+			for (int j = 0; j < i; j++) {
+				if (items[j].item == item) {
+					items.remove_at(i);
+					i--;
+
+					break;
+				}
+			}
+		}
+	} else if (node_select_type == NODE_TYPE_3D) {
+#ifndef _3D_DISABLED
+		_find_3d_items_at_pos(pos, items);
+#endif // _3D_DISABLED
+	}
+
+	if (items.is_empty()) {
+		return;
+	}
+
+	items.sort();
+
+	if ((!list_shortcut && node_select_mode == SELECT_MODE_SINGLE) || items.size() == 1) {
+		Array message;
+		message.append(items[0].item->get_instance_id());
+		EngineDebugger::get_singleton()->send_message("remote_node_clicked", message);
+	} else if (list_shortcut || node_select_mode == SELECT_MODE_LIST) {
+		if (!selection_list->is_inside_tree()) {
+			root->add_child(selection_list);
+		}
+
+		selection_list->clear();
+		for (SelectResult &I : items) {
+			selection_list->add_item(I.item->get_name());
+			selection_list->set_item_metadata(-1, I.item);
+		}
+
+		selection_list->set_position(selection_list->is_embedded() ? pos : pos + root->get_position());
+		selection_list->reset_size();
+		selection_list->popup();
+		// FIXME: Ugly hack that stops the popup from hiding when the button is released.
+		selection_list->call_deferred(SNAME("set_position"), selection_list->get_position() + Point2(1, 0));
+	}
+}
+
+void RuntimeNodeSelect::_items_popup_index_pressed(int p_index, PopupMenu *p_popup) {
+	Array message;
+	message.append(Object::cast_to<Node>(p_popup->get_item_metadata(p_index))->get_instance_id());
+	EngineDebugger::get_singleton()->send_message("remote_node_clicked", message);
+}
+
+void RuntimeNodeSelect::_update_input_state() {
+	SceneTree *scene_tree = SceneTree::get_singleton();
+	if (!scene_tree->get_root()->is_inside_tree()) {
+		// This function will be called before the window enters the tree at first when the Game editor is passing its
+		// settings to the debugger, so delay the update for after it enters.
+		scene_tree->get_root()->connect("tree_entered", callable_mp(this, &RuntimeNodeSelect::_update_input_state), Object::CONNECT_ONE_SHOT);
+		return;
+	}
+
+	bool disable_input = scene_tree->is_suspended() || node_select_type != RuntimeNodeSelect::NODE_TYPE_NONE;
+	Input::get_singleton()->set_active(!disable_input);
+	scene_tree->get_root()->get_viewport()->set_disable_input_internal(disable_input);
+
+	bool process_connected = scene_tree->is_connected("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	if (selection_visible && !scene_tree->is_suspended() && !process_connected) {
+		scene_tree->connect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	} else if ((!selection_visible || scene_tree->is_suspended()) && process_connected) {
+		scene_tree->disconnect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	}
+}
+
+void RuntimeNodeSelect::_select_node(Node *p_node) {
+	if (p_node == selected) {
+		return;
+	}
+
+	_clear_selection();
+
+	CanvasItem *ci = Object::cast_to<CanvasItem>(p_node);
+	if (ci) {
+		selected = p_node;
+	} else {
+#ifndef _3D_DISABLED
+		Node3D *node_3d = Object::cast_to<Node3D>(p_node);
+		if (node_3d) {
+			selected = p_node;
+
+			sbox_3d_instance = RS::get_singleton()->instance_create2(sbox_3d_mesh->get_rid(), node_3d->get_world_3d()->get_scenario());
+			sbox_3d_instance_ofs = RS::get_singleton()->instance_create2(sbox_3d_mesh->get_rid(), node_3d->get_world_3d()->get_scenario());
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sbox_3d_instance, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sbox_3d_instance_ofs, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_ofs, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_ofs, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+
+			sbox_3d_instance_xray = RS::get_singleton()->instance_create2(sbox_3d_mesh_xray->get_rid(), node_3d->get_world_3d()->get_scenario());
+			sbox_3d_instance_xray_ofs = RS::get_singleton()->instance_create2(sbox_3d_mesh_xray->get_rid(), node_3d->get_world_3d()->get_scenario());
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sbox_3d_instance_xray, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sbox_3d_instance_xray_ofs, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_xray, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_xray, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_xray_ofs, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sbox_3d_instance_xray_ofs, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+		}
+#endif // _3D_DISABLED
+	}
+
+	if (selected) {
+		if (selection_visible && !SceneTree::get_singleton()->is_suspended()) {
+			SceneTree::get_singleton()->connect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+		} else {
+			_update_selection();
+		}
+	}
+}
+
+void RuntimeNodeSelect::_update_selection() {
+	if (!selected || !selected->is_inside_tree()) {
+		_clear_selection();
+		return;
+	}
+
+	CanvasItem *ci = Object::cast_to<CanvasItem>(selected);
+	if (ci) {
+		RS::get_singleton()->canvas_item_clear(sbox_2d_ci);
+
+		Window *root = SceneTree::get_singleton()->get_root();
+		if (root->is_canvas_transform_override_enabled()) {
+			RS::get_singleton()->canvas_item_set_transform(sbox_2d_ci, root->get_canvas_transform_override());
+		} else {
+			RS::get_singleton()->canvas_item_set_transform(sbox_2d_ci, root->get_canvas_transform());
+		}
+
+		Transform2D xform = ci->get_global_transform_with_canvas();
+
+		// Fallback.
+		Rect2 rect = Rect2(Vector2(), Vector2(10, 10));
+
+		if (ci->_edit_use_rect()) {
+			rect = ci->_edit_get_rect();
+		} else {
+			CollisionShape2D *collision_shape = Object::cast_to<CollisionShape2D>(ci);
+			if (collision_shape) {
+				Ref<Shape2D> shape = collision_shape->get_shape();
+				if (shape.is_valid()) {
+					rect = shape->get_rect();
+				}
+			}
+		}
+
+		const Vector2 endpoints[4] = {
+			xform.xform(rect.position),
+			xform.xform(rect.position + Vector2(rect.size.x, 0)),
+			xform.xform(rect.position + rect.size),
+			xform.xform(rect.position + Vector2(0, rect.size.y))
+		};
+
+		const Color selection_color_2d = Color(1, 0.6, 0.4, 0.7);
+		for (int i = 0; i < 4; i++) {
+			RS::get_singleton()->canvas_item_add_line(sbox_2d_ci, endpoints[i], endpoints[(i + 1) % 4], selection_color_2d, Math::round(2.f));
+		}
+	} else {
+#ifndef _3D_DISABLED
+		Node3D *node_3d = Object::cast_to<Node3D>(selected);
+
+		// Fallback.
+		AABB bounds(Vector3(-0.5, -0.5, -0.5), Vector3(1, 1, 1));
+
+		VisualInstance3D *visual_instance = Object::cast_to<VisualInstance3D>(node_3d);
+		if (visual_instance) {
+			bounds = visual_instance->get_aabb();
+		} else {
+			CollisionShape3D *collision_shape = Object::cast_to<CollisionShape3D>(node_3d);
+			if (collision_shape) {
+				Ref<Shape3D> shape = collision_shape->get_shape();
+				if (shape.is_valid()) {
+					bounds = shape->get_debug_mesh()->get_aabb();
+				}
+			}
+		}
+
+		Transform3D xform_to_top_level_parent_space = node_3d->get_global_transform().affine_inverse() * node_3d->get_global_transform();
+		bounds = xform_to_top_level_parent_space.xform(bounds);
+
+		Transform3D t = node_3d->get_global_transform();
+		Transform3D t_offset = t;
+
+		// Apply AABB scaling before item's global transform.
+		{
+			const Vector3 offset(0.005, 0.005, 0.005);
+			Basis aabb_s;
+			aabb_s.scale(bounds.size + offset);
+			t.translate_local(bounds.position - offset / 2);
+			t.basis = t.basis * aabb_s;
+		}
+		{
+			const Vector3 offset(0.01, 0.01, 0.01);
+			Basis aabb_s;
+			aabb_s.scale(bounds.size + offset);
+			t_offset.translate_local(bounds.position - offset / 2);
+			t_offset.basis = t_offset.basis * aabb_s;
+		}
+
+		RS::get_singleton()->instance_set_transform(sbox_3d_instance, t);
+		RS::get_singleton()->instance_set_transform(sbox_3d_instance_ofs, t_offset);
+		RS::get_singleton()->instance_set_transform(sbox_3d_instance_xray, t);
+		RS::get_singleton()->instance_set_transform(sbox_3d_instance_xray_ofs, t_offset);
+#endif // _3D_DISABLED
+	}
+}
+
+void RuntimeNodeSelect::_clear_selection() {
+	selected = nullptr;
+
+	if (sbox_2d_canvas.is_valid()) {
+		RS::get_singleton()->canvas_item_clear(sbox_2d_ci);
+	}
+
+#ifndef _3D_DISABLED
+	if (sbox_3d_instance.is_valid()) {
+		RS::get_singleton()->free(sbox_3d_instance);
+		RS::get_singleton()->free(sbox_3d_instance_ofs);
+		RS::get_singleton()->free(sbox_3d_instance_xray);
+		RS::get_singleton()->free(sbox_3d_instance_xray_ofs);
+	}
+#endif // _3D_DISABLED
+
+	if (SceneTree::get_singleton()->is_connected("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection))) {
+		SceneTree::get_singleton()->disconnect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	}
+}
+
+void RuntimeNodeSelect::_set_selection_visible(bool p_visible) {
+	selection_visible = p_visible;
+
+	if (sbox_2d_ci.is_valid()) {
+		RS::get_singleton()->canvas_item_set_visible(sbox_2d_ci, p_visible);
+	}
+
+#ifndef _3D_DISABLED
+	if (sbox_3d_instance.is_valid()) {
+		RS::get_singleton()->instance_set_visible(sbox_3d_instance, p_visible);
+		RS::get_singleton()->instance_set_visible(sbox_3d_instance_ofs, p_visible);
+		RS::get_singleton()->instance_set_visible(sbox_3d_instance_xray, p_visible);
+		RS::get_singleton()->instance_set_visible(sbox_3d_instance_xray_ofs, p_visible);
+	}
+#endif // _3D_DISABLED
+
+	SceneTree *scene_tree = SceneTree::get_singleton();
+	bool process_connected = scene_tree->is_connected("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	if (p_visible) {
+		if (!scene_tree->is_suspended() && !process_connected) {
+			scene_tree->connect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+		} else {
+			_update_selection();
+		}
+	} else if (process_connected) {
+		scene_tree->disconnect("process_frame", callable_mp(this, &RuntimeNodeSelect::_update_selection));
+	}
+}
+
+// Copied and trimmed from the CanvasItemEditor implementation.
+void RuntimeNodeSelect::_find_canvas_items_at_pos(const Point2 &p_pos, Node *p_node, Vector<SelectResult> &r_items, const Transform2D &p_parent_xform, const Transform2D &p_canvas_xform) {
+	if (!p_node || Object::cast_to<Viewport>(p_node)) {
+		return;
+	}
+
+	// In the original CanvasItemEditor, this value would be fetched from the "editors/polygon_editor/point_grab_radius" editor property,
+	// but since this is not accessible from here, we will just use the default value.
+	const real_t grab_distance = 8;
+	CanvasItem *ci = Object::cast_to<CanvasItem>(p_node);
+
+	for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
+		if (ci) {
+			if (!ci->is_set_as_top_level()) {
+				_find_canvas_items_at_pos(p_pos, p_node->get_child(i), r_items, p_parent_xform * ci->get_transform(), p_canvas_xform);
+			} else {
+				_find_canvas_items_at_pos(p_pos, p_node->get_child(i), r_items, ci->get_transform(), p_canvas_xform);
+			}
+		} else {
+			CanvasLayer *cl = Object::cast_to<CanvasLayer>(p_node);
+			_find_canvas_items_at_pos(p_pos, p_node->get_child(i), r_items, Transform2D(), cl ? cl->get_transform() : p_canvas_xform);
+		}
+	}
+
+	if (ci && ci->is_visible_in_tree()) {
+		Transform2D xform = p_canvas_xform;
+		if (!ci->is_set_as_top_level()) {
+			xform *= p_parent_xform;
+		}
+
+		xform = (xform * ci->get_transform()).affine_inverse();
+		const real_t local_grab_distance = xform.basis_xform(Vector2(grab_distance, 0)).length();
+		if (ci->_edit_is_selected_on_click(xform.xform(p_pos), local_grab_distance)) {
+			SelectResult res;
+			res.item = ci;
+			res.order = ci->get_z_index();
+			r_items.push_back(res);
+
+			// If it's a shape, get the collision object it's from.
+			// FIXME: If the collision object has multiple shapes, only the topmost will be above it in the list.
+			if (Object::cast_to<CollisionShape2D>(ci) || Object::cast_to<CollisionPolygon2D>(ci)) {
+				CollisionObject2D *collision_object = Object::cast_to<CollisionObject2D>(ci->get_parent());
+				if (collision_object) {
+					SelectResult res_col;
+					res_col.item = ci->get_parent();
+					res_col.order = collision_object->get_z_index();
+					r_items.push_back(res_col);
+				}
+			}
+		}
+	}
+}
+
+void RuntimeNodeSelect::_pan_callback(Vector2 p_scroll_vec, Ref<InputEvent> p_event) {
+	view_2d_offset.x -= p_scroll_vec.x / view_2d_zoom;
+	view_2d_offset.y -= p_scroll_vec.y / view_2d_zoom;
+
+	_update_view_2d();
+}
+
+// A very shallow copy of the same function inside CanvasItemEditor.
+void RuntimeNodeSelect::_zoom_callback(float p_zoom_factor, Vector2 p_origin, Ref<InputEvent> p_event) {
+	real_t prev_zoom = view_2d_zoom;
+	view_2d_zoom = CLAMP(view_2d_zoom * p_zoom_factor, VIEW_2D_MIN_ZOOM, VIEW_2D_MAX_ZOOM);
+
+	view_2d_offset += p_origin / prev_zoom - p_origin / view_2d_zoom;
+
+	// We want to align in-scene pixels to screen pixels, this prevents blurry rendering
+	// of small details (texts, lines).
+	// This correction adds a jitter movement when zooming, so we correct only when the
+	// zoom factor is an integer. (in the other cases, all pixels won't be aligned anyway)
+	const real_t closest_zoom_factor = Math::round(view_2d_zoom);
+	if (Math::is_zero_approx(view_2d_zoom - closest_zoom_factor)) {
+		// Make sure scene pixel at view_offset is aligned on a screen pixel.
+		Vector2 view_offset_int = view_2d_offset.floor();
+		Vector2 view_offset_frac = view_2d_offset - view_offset_int;
+		view_2d_offset = view_offset_int + (view_offset_frac * closest_zoom_factor).round() / closest_zoom_factor;
+	}
+
+	_update_view_2d();
+}
+
+void RuntimeNodeSelect::_reset_camera_2d_position() {
+	view_2d_offset = Vector2();
+	view_2d_zoom = 1;
+
+	_update_view_2d();
+}
+
+void RuntimeNodeSelect::_update_view_2d() {
+	Transform2D transform = Transform2D();
+	transform.scale_basis(Size2(view_2d_zoom, view_2d_zoom));
+	transform.columns[2] = -view_2d_offset * view_2d_zoom;
+
+	SceneTree::get_singleton()->get_root()->set_canvas_transform_override(transform);
+
+	if (!selection_visible || SceneTree::get_singleton()->is_suspended()) {
+		_update_selection();
+	}
+}
+
+#ifndef _3D_DISABLED
+void RuntimeNodeSelect::_find_3d_items_at_pos(const Point2 &p_pos, Vector<SelectResult> &r_items) {
+	Window *root = SceneTree::get_singleton()->get_root();
+	Camera3D *camera = root->get_viewport()->get_camera_3d();
+	if (!camera) {
+		return;
+	}
+
+	Vector3 ray = camera->project_ray_normal(p_pos);
+	Vector3 pos = camera->project_ray_origin(p_pos);
+	Vector3 to = pos + ray * camera->get_far();
+
+	// Start with physical objects.
+	PhysicsDirectSpaceState3D *ss = root->get_world_3d()->get_direct_space_state();
+	PhysicsDirectSpaceState3D::RayResult result;
+	HashSet<RID> excluded;
+	PhysicsDirectSpaceState3D::RayParameters ray_params;
+	ray_params.from = pos;
+	ray_params.to = to;
+	ray_params.collide_with_areas = true;
+	while (true) {
+		ray_params.exclude = excluded;
+		if (ss->intersect_ray(ray_params, result)) {
+			SelectResult res;
+			res.item = Object::cast_to<Node>(result.collider);
+			res.order = -pos.distance_to(Object::cast_to<Node3D>(res.item)->get_global_transform().xform(result.position));
+
+			// Fetch collision shapes.
+			CollisionObject3D *collision = Object::cast_to<CollisionObject3D>(result.collider);
+			if (collision) {
+				List<uint32_t> owners;
+				collision->get_shape_owners(&owners);
+				for (const uint32_t &I : owners) {
+					SelectResult res_shape;
+					res_shape.item = Object::cast_to<Node>(collision->shape_owner_get_owner(I));
+					res_shape.order = res.order;
+					r_items.push_back(res_shape);
+				}
+			}
+
+			r_items.push_back(res);
+
+			excluded.insert(result.rid);
+		} else {
+			break;
+		}
+	}
+
+	// Then go for the meshes.
+	Vector<ObjectID> items = RS::get_singleton()->instances_cull_ray(pos, to, root->get_world_3d()->get_scenario());
+	for (int i = 0; i < items.size(); i++) {
+		Object *obj = ObjectDB::get_instance(items[i]);
+		GeometryInstance3D *geo_instance = nullptr;
+		Ref<TriangleMesh> mesh_collision;
+
+		MeshInstance3D *mesh_instance = Object::cast_to<MeshInstance3D>(obj);
+		if (mesh_instance) {
+			if (mesh_instance->get_mesh().is_valid()) {
+				geo_instance = mesh_instance;
+				mesh_collision = mesh_instance->get_mesh()->generate_triangle_mesh();
+			}
+		} else {
+			Label3D *label = Object::cast_to<Label3D>(obj);
+			if (label) {
+				geo_instance = label;
+				mesh_collision = label->generate_triangle_mesh();
+			} else {
+				Sprite3D *sprite = Object::cast_to<Sprite3D>(obj);
+				if (sprite) {
+					geo_instance = sprite;
+					mesh_collision = sprite->generate_triangle_mesh();
+				}
+			}
+		}
+
+		if (mesh_collision.is_valid()) {
+			Transform3D gt = geo_instance->get_global_transform();
+			Transform3D ai = gt.affine_inverse();
+			Vector3 point, normal;
+			if (mesh_collision->intersect_ray(ai.xform(pos), ai.basis.xform(ray).normalized(), point, normal)) {
+				SelectResult res;
+				res.item = Object::cast_to<Node>(obj);
+				res.order = -pos.distance_to(gt.xform(point));
+				r_items.push_back(res);
+
+				continue;
+			}
+		}
+
+		items.remove_at(i);
+		i--;
+	}
+}
+
+void RuntimeNodeSelect::_handle_3d_input(const Ref<InputEvent> &p_event) {
+	Ref<InputEventMouseButton> b = p_event;
+
+	if (b.is_valid()) {
+		const real_t zoom_factor = VIEW_3D_FREELOK_MOD * b->get_factor();
+		switch (b->get_button_index()) {
+			case MouseButton::WHEEL_UP: {
+				if (!camera_freelook) {
+					_scale_cursor_distance(1.0 / zoom_factor);
+				}
+			} break;
+			case MouseButton::WHEEL_DOWN: {
+				if (!camera_freelook) {
+					_scale_cursor_distance(zoom_factor);
+				}
+			} break;
+			case MouseButton::RIGHT: {
+				camera_freelook = b->is_pressed();
+			} break;
+			default: {
+			}
+		}
+	}
+
+	Ref<InputEventKey> k = p_event;
+	bool shift_pressed = false;
+
+	if (k.is_valid()) {
+		if (k->get_keycode() == Key::ESCAPE) {
+			// set_freelook_active(false);
+		} else if (k->get_keycode() == Key::SHIFT) {
+			shift_pressed = true;
+		}
+	}
+
+	Ref<InputEventMouseMotion> m = p_event;
+
+	if (m.is_valid()) {
+		if (camera_freelook) {
+			// _nav_look(m, _get_warped_mouse_motion(m));
+		} else if (m->get_button_mask().has_flag(MouseButtonMask::MIDDLE)) {
+			if (shift_pressed) {
+				// _nav_pan(m, _get_warped_mouse_motion(m));
+			} else {
+				// _nav_orbit(m, _get_warped_mouse_motion(m));
+			}
+		}
+	}
+}
+
+void RuntimeNodeSelect::_scale_cursor_distance(real_t p_scale) {
+	real_t min_distance = MAX(VIEW_3D_ZNEAR * 4, VIEW_3D_MIN_ZOOM);
+	real_t max_distance = MIN(VIEW_3D_ZFAR / 4, VIEW_3D_MAX_ZOOM);
+	cursor.distance = CLAMP(cursor.distance * p_scale, min_distance, max_distance);
+
+	_update_view_3d();
+}
+
+void RuntimeNodeSelect::_reset_camera_3d_position() {
+	camera_first_override = true;
+
+	Window *root = SceneTree::get_singleton()->get_root();
+	Camera3D *camera = root->get_camera_3d();
+	if (!camera) {
+		return;
+	}
+
+	cursor = Cursor();
+	Transform3D transform = camera->get_global_transform();
+	transform.translate_local(0, 0, -cursor.distance);
+	cursor.pos = transform.origin;
+
+	cursor.x_rot = -camera->get_global_rotation().x;
+	cursor.y_rot = -camera->get_global_rotation().y;
+
+	_update_view_3d();
+}
+
+void RuntimeNodeSelect::_update_view_3d() {
+	Transform3D camera_transform;
+	camera_transform.translate_local(cursor.pos);
+	camera_transform.basis.rotate(Vector3(1, 0, 0), -cursor.x_rot);
+	camera_transform.basis.rotate(Vector3(0, 1, 0), -cursor.y_rot);
+	camera_transform.translate_local(0, 0, cursor.distance);
+
+	SceneTree::get_singleton()->get_root()->set_camera_3d_override_transform(camera_transform);
+}
+#endif // _3D_DISABLED
 #endif
diff --git a/scene/debugger/scene_debugger.h b/scene/debugger/scene_debugger.h
index 0c28ca2a0cde..65cbf5485329 100644
--- a/scene/debugger/scene_debugger.h
+++ b/scene/debugger/scene_debugger.h
@@ -31,17 +31,19 @@
 #ifndef SCENE_DEBUGGER_H
 #define SCENE_DEBUGGER_H
 
+#include "core/input/input_event.h"
 #include "core/object/class_db.h"
 #include "core/object/ref_counted.h"
 #include "core/string/ustring.h"
 #include "core/templates/pair.h"
 #include "core/variant/array.h"
+#include "scene/gui/popup_menu.h"
+#include "scene/gui/view_panner.h"
 
 class Script;
 class Node;
 
 class SceneDebugger {
-public:
 private:
 	static SceneDebugger *singleton;
 
@@ -59,6 +61,7 @@ class SceneDebugger {
 	static void _set_node_owner_recursive(Node *p_node, Node *p_owner);
 	static void _set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value);
 	static void _send_object_id(ObjectID p_id, int p_max_size = 1 << 20);
+	static void _next_frame();
 
 public:
 	static Error parse_message(void *p_user, const String &p_msg, const Array &p_args, bool &r_captured);
@@ -165,6 +168,130 @@ class LiveEditor {
 public:
 	static LiveEditor *get_singleton();
 };
+
+class RuntimeNodeSelect : public Object {
+	GDCLASS(RuntimeNodeSelect, Object);
+
+public:
+	enum NodeType {
+		NODE_TYPE_NONE,
+		NODE_TYPE_2D,
+		NODE_TYPE_3D,
+		NODE_TYPE_MAX
+	};
+
+	enum SelectMode {
+		SELECT_MODE_SINGLE,
+		SELECT_MODE_LIST,
+		SELECT_MODE_MAX
+	};
+
+private:
+	friend class SceneDebugger;
+
+	struct SelectResult {
+		Node *item = nullptr;
+		real_t order = 0;
+		_FORCE_INLINE_ bool operator<(const SelectResult &p_rr) const { return p_rr.order < order; }
+	};
+
+	Node *selected = nullptr;
+	PopupMenu *selection_list = nullptr;
+	bool selection_visible = true;
+
+	bool camera_override = false;
+
+	// Values taken from EditorZoomWidget.
+	const float VIEW_2D_MIN_ZOOM = 1.0 / 128;
+	const float VIEW_2D_MAX_ZOOM = 128;
+
+	Ref<ViewPanner> panner;
+	Vector2 view_2d_offset;
+	real_t view_2d_zoom = 1.0;
+
+	RID sbox_2d_canvas;
+	RID sbox_2d_ci;
+
+#ifndef _3D_DISABLED
+	struct Cursor {
+		Vector3 pos;
+		real_t x_rot, y_rot, distance, fov_scale;
+		Vector3 eye_pos; // Used in freelook mode.
+
+		Cursor() {
+			// These rotations place the camera in +X +Y +Z, aka south east, facing north west.
+			x_rot = 0.5;
+			y_rot = -0.5;
+			distance = 4;
+			fov_scale = 1.0;
+		}
+	};
+	Cursor cursor;
+
+	// Values taken from Node3DEditor.
+	const float VIEW_3D_MIN_ZOOM = 0.01;
+#ifdef REAL_T_IS_DOUBLE
+	const double VIEW_3D_MAX_ZOOM = 1'000'000'000'000;
+#else
+	const float VIEW_3D_MAX_ZOOM = 10'000;
+#endif
+	const float VIEW_3D_ZNEAR = 0.05;
+	const float VIEW_3D_ZFAR = 4'000;
+	const float VIEW_3D_FREELOK_MOD = 1.08;
+
+	bool camera_first_override = true;
+	bool camera_freelook = false;
+
+	Ref<ArrayMesh> sbox_3d_mesh;
+	Ref<ArrayMesh> sbox_3d_mesh_xray;
+	RID sbox_3d_instance;
+	RID sbox_3d_instance_ofs;
+	RID sbox_3d_instance_xray;
+	RID sbox_3d_instance_xray_ofs;
+#endif
+
+	NodeType node_select_type = NODE_TYPE_2D;
+	SelectMode node_select_mode = SELECT_MODE_SINGLE;
+
+	void _setup();
+
+	void _node_set_type(NodeType p_type);
+	void _select_set_mode(SelectMode p_mode);
+
+	void _set_camera_override_enabled(bool p_enabled);
+
+	void _root_window_input(const Ref<InputEvent> &p_event);
+	void _items_popup_index_pressed(int p_index, PopupMenu *p_popup);
+	void _update_input_state();
+
+	void _select_node(Node *p_node);
+	void _update_selection();
+	void _clear_selection();
+	void _set_selection_visible(bool p_visible);
+
+	void _find_canvas_items_at_pos(const Point2 &p_pos, Node *p_node, Vector<SelectResult> &r_items, const Transform2D &p_parent_xform = Transform2D(), const Transform2D &p_canvas_xform = Transform2D());
+	void _pan_callback(Vector2 p_scroll_vec, Ref<InputEvent> p_event);
+	void _zoom_callback(float p_zoom_factor, Vector2 p_origin, Ref<InputEvent> p_event);
+	void _reset_camera_2d_position();
+	void _update_view_2d();
+
+#ifndef _3D_DISABLED
+	void _find_3d_items_at_pos(const Point2 &p_pos, Vector<SelectResult> &r_items);
+	void _handle_3d_input(const Ref<InputEvent> &p_event);
+	void _scale_cursor_distance(real_t p_scale);
+	void _reset_camera_3d_position();
+	void _update_view_3d();
+#endif
+
+	RuntimeNodeSelect() { singleton = this; }
+
+	static RuntimeNodeSelect *singleton;
+
+public:
+	static RuntimeNodeSelect *get_singleton();
+
+	~RuntimeNodeSelect();
+};
 #endif
 
 #endif // SCENE_DEBUGGER_H
diff --git a/scene/gui/video_stream_player.cpp b/scene/gui/video_stream_player.cpp
index 0b521f926df0..878bceccbceb 100644
--- a/scene/gui/video_stream_player.cpp
+++ b/scene/gui/video_stream_player.cpp
@@ -178,6 +178,7 @@ void VideoStreamPlayer::_notification(int p_notification) {
 			draw_texture_rect(texture, Rect2(Point2(), s), false);
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (is_playing() && !is_paused()) {
 				paused_from_tree = true;
@@ -189,6 +190,13 @@ void VideoStreamPlayer::_notification(int p_notification) {
 			}
 		} break;
 
+		case NOTIFICATION_UNSUSPENDED: {
+			if (get_tree()->is_paused()) {
+				break;
+			}
+			[[fallthrough]];
+		}
+
 		case NOTIFICATION_UNPAUSED: {
 			if (paused_from_tree) {
 				paused_from_tree = false;
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index d921cc5b676d..67415f6e820e 100644
--- a/scene/main/node.cpp
+++ b/scene/main/node.cpp
@@ -184,6 +184,7 @@ void Node::_notification(int p_notification) {
 			}
 		} break;
 
+		case NOTIFICATION_SUSPENDED:
 		case NOTIFICATION_PAUSED: {
 			if (is_physics_interpolated_and_enabled() && is_inside_tree()) {
 				reset_physics_interpolation();
@@ -695,6 +696,16 @@ void Node::_propagate_pause_notification(bool p_enable) {
 	data.blocked--;
 }
 
+void Node::_propagate_suspend_notification(bool p_enable) {
+	notification(p_enable ? NOTIFICATION_SUSPENDED : NOTIFICATION_UNSUSPENDED);
+
+	data.blocked++;
+	for (KeyValue<StringName, Node *> &K : data.children) {
+		K.value->_propagate_suspend_notification(p_enable);
+	}
+	data.blocked--;
+}
+
 Node::ProcessMode Node::get_process_mode() const {
 	return data.process_mode;
 }
@@ -850,7 +861,7 @@ bool Node::can_process_notification(int p_what) const {
 
 bool Node::can_process() const {
 	ERR_FAIL_COND_V(!is_inside_tree(), false);
-	return _can_process(get_tree()->is_paused());
+	return !get_tree()->is_suspended() && _can_process(get_tree()->is_paused());
 }
 
 bool Node::_can_process(bool p_paused) const {
diff --git a/scene/main/node.h b/scene/main/node.h
index 298cbc7e595c..cda657dfbbef 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -300,6 +300,7 @@ class Node : public Object {
 
 	void _set_tree(SceneTree *p_tree);
 	void _propagate_pause_notification(bool p_enable);
+	void _propagate_suspend_notification(bool p_enable);
 
 	_FORCE_INLINE_ bool _can_process(bool p_paused) const;
 	_FORCE_INLINE_ bool _is_enabled() const;
@@ -439,6 +440,8 @@ class Node : public Object {
 		// Editor specific node notifications
 		NOTIFICATION_EDITOR_PRE_SAVE = 9001,
 		NOTIFICATION_EDITOR_POST_SAVE = 9002,
+		NOTIFICATION_SUSPENDED = 9003,
+		NOTIFICATION_UNSUSPENDED = 9004
 	};
 
 	/* NODE/TREE */
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index 106130872db2..ed6402671ad5 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -946,11 +946,14 @@ Ref<ArrayMesh> SceneTree::get_debug_contact_mesh() {
 
 void SceneTree::set_pause(bool p_enabled) {
 	ERR_FAIL_COND_MSG(!Thread::is_main_thread(), "Pause can only be set from the main thread.");
+	ERR_FAIL_COND_MSG(suspended, "Pause state cannot be modified while suspended.");
 
 	if (p_enabled == paused) {
 		return;
 	}
+
 	paused = p_enabled;
+
 #ifndef _3D_DISABLED
 	PhysicsServer3D::get_singleton()->set_active(!p_enabled);
 #endif // _3D_DISABLED
@@ -964,6 +967,30 @@ bool SceneTree::is_paused() const {
 	return paused;
 }
 
+void SceneTree::set_suspend(bool p_enabled) {
+	ERR_FAIL_COND_MSG(!Thread::is_main_thread(), "Suspend can only be set from the main thread.");
+
+	if (p_enabled == suspended) {
+		return;
+	}
+
+	suspended = p_enabled;
+
+	Engine::get_singleton()->set_freeze_time_scale(p_enabled);
+
+#ifndef _3D_DISABLED
+	PhysicsServer3D::get_singleton()->set_active(!p_enabled && !paused);
+#endif // _3D_DISABLED
+	PhysicsServer2D::get_singleton()->set_active(!p_enabled && !paused);
+	if (get_root()) {
+		get_root()->_propagate_suspend_notification(p_enabled);
+	}
+}
+
+bool SceneTree::is_suspended() const {
+	return suspended;
+}
+
 void SceneTree::_process_group(ProcessGroup *p_group, bool p_physics) {
 	// When reading this function, keep in mind that this code must work in a way where
 	// if any node is removed, this needs to continue working.
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index 7e445411050f..291e4a5a0cf0 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -143,6 +143,7 @@ class SceneTree : public MainLoop {
 	bool debug_navigation_hint = false;
 #endif
 	bool paused = false;
+	bool suspended = false;
 
 	HashMap<StringName, Group> group_map;
 	bool _quit = false;
@@ -343,6 +344,8 @@ class SceneTree : public MainLoop {
 
 	void set_pause(bool p_enabled);
 	bool is_paused() const;
+	void set_suspend(bool p_enabled);
+	bool is_suspended() const;
 
 #ifdef DEBUG_ENABLED
 	void set_debug_collisions_hint(bool p_enabled);
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index 169a5dcb0149..81625b9c2093 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -3123,7 +3123,7 @@ void Viewport::push_input(const Ref<InputEvent> &p_event, bool p_local_coords) {
 	ERR_FAIL_COND(!is_inside_tree());
 	ERR_FAIL_COND(p_event.is_null());
 
-	if (disable_input) {
+	if (disable_input || disable_input_internal) {
 		return;
 	}
 
@@ -3195,7 +3195,7 @@ void Viewport::push_unhandled_input(const Ref<InputEvent> &p_event, bool p_local
 
 	local_input_handled = false;
 
-	if (disable_input || !_can_consume_input_events()) {
+	if (disable_input || disable_input_internal || !_can_consume_input_events()) {
 		return;
 	}
 
@@ -3298,7 +3298,7 @@ void Viewport::set_disable_input(bool p_disable) {
 	if (p_disable == disable_input) {
 		return;
 	}
-	if (p_disable) {
+	if (p_disable && !disable_input_internal) {
 		_drop_mouse_focus();
 		_mouse_leave_viewport();
 		_gui_cancel_tooltip();
@@ -3311,6 +3311,19 @@ bool Viewport::is_input_disabled() const {
 	return disable_input;
 }
 
+void Viewport::set_disable_input_internal(bool p_disable) {
+	ERR_MAIN_THREAD_GUARD;
+	if (p_disable == disable_input_internal) {
+		return;
+	}
+	if (p_disable && !disable_input) {
+		_drop_mouse_focus();
+		_mouse_leave_viewport();
+		_gui_cancel_tooltip();
+	}
+	disable_input_internal = p_disable;
+}
+
 Variant Viewport::gui_get_drag_data() const {
 	ERR_READ_THREAD_GUARD_V(Variant());
 	return get_section_root_viewport()->gui.drag_data;
diff --git a/scene/main/viewport.h b/scene/main/viewport.h
index a18dc1f6f0f3..21c3970035af 100644
--- a/scene/main/viewport.h
+++ b/scene/main/viewport.h
@@ -401,6 +401,7 @@ class Viewport : public Node {
 	DefaultCanvasItemTextureRepeat default_canvas_item_texture_repeat = DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED;
 
 	bool disable_input = false;
+	bool disable_input_internal = false;
 
 	void _gui_call_input(Control *p_control, const Ref<InputEvent> &p_input);
 	void _gui_call_notification(Control *p_control, int p_what);
@@ -580,6 +581,8 @@ class Viewport : public Node {
 	void set_disable_input(bool p_disable);
 	bool is_input_disabled() const;
 
+	void set_disable_input_internal(bool p_disable);
+
 	Vector2 get_mouse_position() const;
 	void warp_mouse(const Vector2 &p_position);
 	virtual void update_mouse_cursor_state();