diff --git a/editor/debugger/editor_debugger_inspector.cpp b/editor/debugger/editor_debugger_inspector.cpp
index e085e2e4480b..c3d7a5c16610 100644
--- a/editor/debugger/editor_debugger_inspector.cpp
+++ b/editor/debugger/editor_debugger_inspector.cpp
@@ -33,8 +33,11 @@
 #include "core/debugger/debugger_marshalls.h"
 #include "core/io/marshalls.h"
 #include "editor/editor_node.h"
+#include "editor/inspector_dock.h"
 #include "scene/debugger/scene_debugger.h"
 
+/// EditorDebuggerRemoteObject
+
 bool EditorDebuggerRemoteObject::_set(const StringName &p_name, const Variant &p_value) {
 	if (!prop_values.has(p_name) || String(p_name).begins_with("Constants/")) {
 		return false;
@@ -55,7 +58,7 @@ bool EditorDebuggerRemoteObject::_get(const StringName &p_name, Variant &r_ret)
 }
 
 void EditorDebuggerRemoteObject::_get_property_list(List<PropertyInfo> *p_list) const {
-	p_list->clear(); // Sorry, no want category.
+	p_list->clear(); // Sorry, don't want any categories.
 	for (const PropertyInfo &prop : prop_list) {
 		if (prop.name == "script") {
 			// Skip the script property, it's always added by the non-virtual method.
@@ -84,11 +87,84 @@ void EditorDebuggerRemoteObject::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_title"), &EditorDebuggerRemoteObject::get_title);
 	ClassDB::bind_method(D_METHOD("get_variant"), &EditorDebuggerRemoteObject::get_variant);
 	ClassDB::bind_method(D_METHOD("clear"), &EditorDebuggerRemoteObject::clear);
-	ClassDB::bind_method(D_METHOD("get_remote_object_id"), &EditorDebuggerRemoteObject::get_remote_object_id);
 
 	ADD_SIGNAL(MethodInfo("value_edited", PropertyInfo(Variant::INT, "object_id"), PropertyInfo(Variant::STRING, "property"), PropertyInfo("value")));
 }
 
+/// EditorDebuggerMultiRemoteObject
+
+bool EditorDebuggerMultiRemoteObject::_set(const StringName &p_name, const Variant &p_value) {
+	return _set_impl(p_name, p_value, "");
+}
+
+bool EditorDebuggerMultiRemoteObject::_set_impl(const StringName &p_name, const Variant &p_value, const String &p_field) {
+	String name = p_name;
+
+	if (!prop_values.has(name) || String(name).begins_with("Constants/")) {
+		return false;
+	}
+	if (name.begins_with("Metadata/")) {
+		name = name.replace_first("Metadata/", "metadata/");
+	}
+
+	emit_signal(SNAME("value_edited"), remote_object_ids, name, p_value, p_field);
+	return true;
+}
+
+bool EditorDebuggerMultiRemoteObject::_get(const StringName &p_name, Variant &r_ret) const {
+	String name = p_name;
+
+	if (!prop_values.has(name)) {
+		return false;
+	}
+	if (name.begins_with("Metadata/")) {
+		name = name.replace_first("Metadata/", "metadata/");
+	}
+
+	r_ret = prop_values[name];
+	return true;
+}
+
+void EditorDebuggerMultiRemoteObject::_get_property_list(List<PropertyInfo> *p_list) const {
+	p_list->clear(); // Sorry, don't want any categories.
+	for (const PropertyInfo &prop : prop_list) {
+		if (prop.name == "script") {
+			// Skip the script property, it's always added by the non-virtual method.
+			continue;
+		}
+
+		p_list->push_back(prop);
+	}
+}
+
+void EditorDebuggerMultiRemoteObject::set_property_field(const StringName &p_property, const Variant &p_value, const String &p_field) {
+	_set_impl(p_property, p_value, p_field);
+}
+
+String EditorDebuggerMultiRemoteObject::get_title() {
+	if (remote_object_ids.size() && ((ObjectID)remote_object_ids[0]).is_valid()) {
+		return vformat(TTR("Remote %s (%d Selected)"), type_name, remote_object_ids.size());
+	} else {
+		return "<null>";
+	}
+}
+
+Variant EditorDebuggerMultiRemoteObject::get_variant(const StringName &p_name) {
+	Variant var;
+	_get(p_name, var);
+	return var;
+}
+
+void EditorDebuggerMultiRemoteObject::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_title"), &EditorDebuggerMultiRemoteObject::get_title);
+	ClassDB::bind_method(D_METHOD("get_variant"), &EditorDebuggerMultiRemoteObject::get_variant);
+	ClassDB::bind_method(D_METHOD("clear"), &EditorDebuggerMultiRemoteObject::clear);
+
+	ADD_SIGNAL(MethodInfo("value_edited", PropertyInfo(Variant::PACKED_INT64_ARRAY, "object_ids"), PropertyInfo(Variant::STRING, "property"), PropertyInfo("value"), PropertyInfo(Variant::STRING, "field")));
+}
+
+/// EditorDebuggerInspector
+
 EditorDebuggerInspector::EditorDebuggerInspector() {
 	variables = memnew(EditorDebuggerRemoteObject);
 }
@@ -101,6 +177,7 @@ EditorDebuggerInspector::~EditorDebuggerInspector() {
 void EditorDebuggerInspector::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("object_selected", PropertyInfo(Variant::INT, "id")));
 	ADD_SIGNAL(MethodInfo("object_edited", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::STRING, "property"), PropertyInfo("value")));
+	ADD_SIGNAL(MethodInfo("multi_objects_edited", PropertyInfo(Variant::ARRAY, "ids"), PropertyInfo(Variant::STRING, "property"), PropertyInfo("value"), PropertyInfo(Variant::STRING, "field")));
 	ADD_SIGNAL(MethodInfo("object_property_updated", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::STRING, "property")));
 }
 
@@ -120,17 +197,20 @@ void EditorDebuggerInspector::_object_edited(ObjectID p_id, const String &p_prop
 	emit_signal(SNAME("object_edited"), p_id, p_prop, p_value);
 }
 
+void EditorDebuggerInspector::_multi_objects_edited(const TypedArray<int64_t> &p_ids, const String &p_prop, const Variant &p_value, const String &p_field) {
+	emit_signal(SNAME("multi_objects_edited"), p_ids, p_prop, p_value, p_field);
+}
+
 void EditorDebuggerInspector::_object_selected(ObjectID p_object) {
 	emit_signal(SNAME("object_selected"), p_object);
 }
 
 ObjectID EditorDebuggerInspector::add_object(const Array &p_arr) {
-	EditorDebuggerRemoteObject *debug_obj = nullptr;
-
 	SceneDebuggerObject obj;
 	obj.deserialize(p_arr);
 	ERR_FAIL_COND_V(obj.id.is_null(), ObjectID());
 
+	EditorDebuggerRemoteObject *debug_obj = nullptr;
 	if (remote_objects.has(obj.id)) {
 		debug_obj = remote_objects[obj.id];
 	} else {
@@ -154,7 +234,7 @@ ObjectID EditorDebuggerInspector::add_object(const Array &p_arr) {
 			if (var.is_string()) {
 				String path = var;
 				if (path.contains("::")) {
-					// built-in resource
+					// Built-in resource.
 					String base_path = path.get_slice("::", 0);
 					Ref<Resource> dependency = ResourceLoader::load(base_path);
 					if (dependency.is_valid()) {
@@ -178,40 +258,212 @@ ObjectID EditorDebuggerInspector::add_object(const Array &p_arr) {
 			}
 		}
 
-		//always add the property, since props may have been added or removed
+		// Always add the property, since props may have been added or removed.
 		debug_obj->prop_list.push_back(pinfo);
 
 		if (!debug_obj->prop_values.has(pinfo.name)) {
 			new_props_added++;
 			debug_obj->prop_values[pinfo.name] = var;
-		} else {
-			if (bool(Variant::evaluate(Variant::OP_NOT_EQUAL, debug_obj->prop_values[pinfo.name], var))) {
-				debug_obj->prop_values[pinfo.name] = var;
-				changed.insert(pinfo.name);
-			}
+		} else if (bool(Variant::evaluate(Variant::OP_NOT_EQUAL, debug_obj->prop_values[pinfo.name], var))) {
+			debug_obj->prop_values[pinfo.name] = var;
+			changed.insert(pinfo.name);
 		}
 	}
 
 	if (old_prop_size == debug_obj->prop_list.size() && new_props_added == 0) {
-		//only some may have changed, if so, then update those, if exist
+		// Only some may have changed, if so, then update those, if they exist.
 		for (const String &E : changed) {
 			emit_signal(SNAME("object_property_updated"), debug_obj->remote_object_id, E);
 		}
 	} else {
-		//full update, because props were added or removed
+		// Full update, because props were added or removed.
 		debug_obj->update();
 	}
 	return obj.id;
 }
 
+EditorDebuggerMultiRemoteObject *EditorDebuggerInspector::get_multi_objects(const Array &p_arr) {
+	ERR_FAIL_COND_V(p_arr.is_empty(), nullptr);
+
+	if (!multi_remote_obj) {
+		multi_remote_obj = memnew(EditorDebuggerMultiRemoteObject);
+		multi_remote_obj->connect("value_edited", callable_mp(this, &EditorDebuggerInspector::_multi_objects_edited));
+	} else {
+		multi_remote_obj->remote_object_ids.clear();
+	}
+
+	LocalVector<SceneDebuggerObject> objects;
+	for (const Array arr : p_arr) {
+		SceneDebuggerObject obj;
+		obj.deserialize(arr);
+		if (obj.id.is_valid()) {
+			multi_remote_obj->remote_object_ids.push_front((uint64_t)obj.id);
+			objects.push_back(obj);
+		}
+	}
+	ERR_FAIL_COND_V(multi_remote_obj->remote_object_ids.is_empty(), nullptr);
+
+	StringName class_name = objects[0].class_name;
+	if (class_name != SNAME("Object")) {
+		// Search for the common class between all selected objects.
+		bool check_type_again = true;
+		while (check_type_again) {
+			check_type_again = false;
+
+			if (class_name == SNAME("Object") || class_name == StringName()) {
+				// All objects inherit from Object, so no need to continue checking.
+				class_name = SNAME("Object");
+				break;
+			}
+
+			// Check that all objects inherit from type_name.
+			for (const SceneDebuggerObject &obj : objects) {
+				if (obj.class_name == class_name || ClassDB::is_parent_class(obj.class_name, class_name)) {
+					continue; // class_name is the same or a parent of the object's class.
+				}
+
+				// class_name is not a parent of the node's class, so check again with the parent class.
+				class_name = ClassDB::get_parent_class(class_name);
+				check_type_again = true;
+				break;
+			}
+		}
+	}
+	multi_remote_obj->type_name = class_name;
+
+	// Search for properties that are present in all selected objects.
+	HashMap<String, Pair<int, SceneDebuggerObject::SceneDebuggerProperty>> usage;
+	LocalVector<Pair<int, SceneDebuggerObject::SceneDebuggerProperty> *> data_list;
+	LocalVector<SceneDebuggerObject::SceneDebuggerProperty> matching_props;
+	int nc = 0;
+	for (const SceneDebuggerObject &obj : objects) {
+		for (const SceneDebuggerObject::SceneDebuggerProperty &prop : obj.properties) {
+			PropertyInfo pinfo = prop.first;
+			if (pinfo.name == "script") {
+				continue; // Added later manually, since this is intercepted before being set (check Variant Object::get()).
+			} else if (pinfo.name.begins_with("metadata/")) {
+				pinfo.name = pinfo.name.replace_first("metadata/", "Metadata/"); // Trick to not get actual metadata edited from EditorDebuggerMultiRemoteObject.
+			}
+
+			if (!usage.has(pinfo.name)) {
+				Pair<int, SceneDebuggerObject::SceneDebuggerProperty> pld;
+				pld.first = 0;
+				pld.second = prop;
+				pld.second.first.name = pinfo.name;
+				usage[pinfo.name] = pld;
+				data_list.push_back(usage.getptr(pinfo.name));
+			}
+
+			// Make sure only properties with the same exact PropertyInfo data will appear.
+			if (usage[pinfo.name].second.first == pinfo) {
+				usage[pinfo.name].first++;
+			}
+		}
+
+		nc++;
+	}
+	for (const Pair<int, SceneDebuggerObject::SceneDebuggerProperty> *pld : data_list) {
+		if (nc == pld->first) {
+			matching_props.push_back(pld->second);
+		}
+	}
+
+	int old_prop_size = multi_remote_obj->prop_list.size();
+
+	multi_remote_obj->prop_list.clear();
+	int new_props_added = 0;
+	HashSet<String> changed;
+	for (SceneDebuggerObject::SceneDebuggerProperty &prop : matching_props) {
+		PropertyInfo &pinfo = prop.first;
+		Variant &var = prop.second;
+
+		if (pinfo.type == Variant::OBJECT) {
+			if (var.is_string()) {
+				String path = var;
+				if (path.contains("::")) {
+					// Built-in resource.
+					String base_path = path.get_slice("::", 0);
+					Ref<Resource> dependency = ResourceLoader::load(base_path);
+					if (dependency.is_valid()) {
+						remote_dependencies.insert(dependency);
+					}
+				}
+				var = ResourceLoader::load(path);
+
+				if (pinfo.hint_string == "Script") {
+					if (multi_remote_obj->get_script() != var) {
+						multi_remote_obj->set_script(Ref<RefCounted>());
+						Ref<Script> scr(var);
+						if (!scr.is_null()) {
+							ScriptInstance *scr_instance = scr->placeholder_instance_create(multi_remote_obj);
+							if (scr_instance) {
+								multi_remote_obj->set_script_and_instance(var, scr_instance);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Always add the property, since props may have been added or removed.
+		multi_remote_obj->prop_list.push_back(pinfo);
+
+		if (!multi_remote_obj->prop_values.has(pinfo.name)) {
+			new_props_added++;
+			multi_remote_obj->prop_values[pinfo.name] = var;
+		} else if (bool(Variant::evaluate(Variant::OP_NOT_EQUAL, multi_remote_obj->prop_values[pinfo.name], var))) {
+			multi_remote_obj->prop_values[pinfo.name] = var;
+			changed.insert(pinfo.name);
+		}
+	}
+
+	if (old_prop_size == multi_remote_obj->prop_list.size() && new_props_added == 0) {
+		// Only some may have changed, if so, then update those, if they exist.
+		for (const String &E : changed) {
+			emit_signal(SNAME("object_property_updated"), multi_remote_obj->get_instance_id(), E);
+		}
+	} else {
+		// Full update, because props were added or removed.
+		multi_remote_obj->update();
+	}
+	return multi_remote_obj;
+}
+
+void EditorDebuggerInspector::clear_remote_inspector() {
+	EditorNode *editor = EditorNode::get_singleton();
+	const Object *inspector_obj = InspectorDock::get_inspector_singleton()->get_edited_object();
+
+	// Check if the inspector holds a remote item, and take it out if so.
+	for (const KeyValue<ObjectID, EditorDebuggerRemoteObject *> &E : remote_objects) {
+		if (inspector_obj && inspector_obj->get_instance_id() == E.value->get_instance_id()) {
+			editor->push_item(nullptr);
+			break;
+		}
+	}
+	if (multi_remote_obj && inspector_obj == multi_remote_obj) {
+		editor->push_item(nullptr);
+	}
+}
+
 void EditorDebuggerInspector::clear_cache() {
+	EditorNode *editor = EditorNode::get_singleton();
+	ObjectID editor_current_id = editor->get_editor_selection_history()->get_current();
+
 	for (const KeyValue<ObjectID, EditorDebuggerRemoteObject *> &E : remote_objects) {
-		EditorNode *editor = EditorNode::get_singleton();
-		if (editor->get_editor_selection_history()->get_current() == E.value->get_instance_id()) {
+		if (editor_current_id == E.value->get_instance_id()) {
 			editor->push_item(nullptr);
 		}
 		memdelete(E.value);
 	}
+
+	if (multi_remote_obj) {
+		if (editor_current_id == multi_remote_obj->get_instance_id()) {
+			editor->push_item(nullptr);
+		}
+		memdelete(multi_remote_obj);
+		multi_remote_obj = nullptr;
+	}
+
 	remote_objects.clear();
 	remote_dependencies.clear();
 }
diff --git a/editor/debugger/editor_debugger_inspector.h b/editor/debugger/editor_debugger_inspector.h
index 860c2bf58241..3bb8fa492516 100644
--- a/editor/debugger/editor_debugger_inspector.h
+++ b/editor/debugger/editor_debugger_inspector.h
@@ -63,17 +63,51 @@ class EditorDebuggerRemoteObject : public Object {
 	EditorDebuggerRemoteObject() {}
 };
 
+class EditorDebuggerMultiRemoteObject : public Object {
+	GDCLASS(EditorDebuggerMultiRemoteObject, Object);
+
+private:
+	bool _set_impl(const StringName &p_name, const Variant &p_value, const String &p_field);
+
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
+	static void _bind_methods();
+
+public:
+	TypedArray<uint64_t> remote_object_ids;
+	String type_name;
+	List<PropertyInfo> prop_list;
+	HashMap<StringName, Variant> prop_values;
+
+	void set_property_field(const StringName &p_property, const Variant &p_value, const String &p_field);
+	String get_title();
+	Variant get_variant(const StringName &p_name);
+
+	void clear() {
+		prop_list.clear();
+		prop_values.clear();
+	}
+
+	void update() { notify_property_list_changed(); }
+
+	EditorDebuggerMultiRemoteObject() {}
+};
+
 class EditorDebuggerInspector : public EditorInspector {
 	GDCLASS(EditorDebuggerInspector, EditorInspector);
 
 private:
 	ObjectID inspected_object_id;
 	HashMap<ObjectID, EditorDebuggerRemoteObject *> remote_objects;
+	EditorDebuggerMultiRemoteObject *multi_remote_obj = nullptr;
 	HashSet<Ref<Resource>> remote_dependencies;
 	EditorDebuggerRemoteObject *variables = nullptr;
 
 	void _object_selected(ObjectID p_object);
 	void _object_edited(ObjectID p_id, const String &p_prop, const Variant &p_value);
+	void _multi_objects_edited(const TypedArray<int64_t> &p_ids, const String &p_prop, const Variant &p_value, const String &p_field);
 
 protected:
 	void _notification(int p_what);
@@ -85,7 +119,9 @@ class EditorDebuggerInspector : public EditorInspector {
 
 	// Remote Object cache
 	ObjectID add_object(const Array &p_arr);
+	EditorDebuggerMultiRemoteObject *get_multi_objects(const Array &p_array);
 	Object *get_object(ObjectID p_id);
+	void clear_remote_inspector();
 	void clear_cache();
 
 	// Stack Dump variables
diff --git a/editor/debugger/editor_debugger_node.cpp b/editor/debugger/editor_debugger_node.cpp
index f06d9be78f58..5493c995e488 100644
--- a/editor/debugger/editor_debugger_node.cpp
+++ b/editor/debugger/editor_debugger_node.cpp
@@ -83,6 +83,8 @@ EditorDebuggerNode::EditorDebuggerNode() {
 	// Remote scene tree
 	remote_scene_tree = memnew(EditorDebuggerTree);
 	remote_scene_tree->connect("object_selected", callable_mp(this, &EditorDebuggerNode::_remote_object_requested));
+	remote_scene_tree->connect("multi_objects_selected", callable_mp(this, &EditorDebuggerNode::_multi_remote_object_requested));
+	remote_scene_tree->connect("selection_cleared", callable_mp(this, &EditorDebuggerNode::_remote_selection_cleared));
 	remote_scene_tree->connect("save_node", callable_mp(this, &EditorDebuggerNode::_save_node_requested));
 	remote_scene_tree->connect("button_clicked", callable_mp(this, &EditorDebuggerNode::_remote_tree_button_pressed));
 	SceneTreeDock::get_singleton()->add_remote_tree_editor(remote_scene_tree);
@@ -106,8 +108,11 @@ ScriptEditorDebugger *EditorDebuggerNode::_add_debugger() {
 	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_multi_select_requested", callable_mp(this, &EditorDebuggerNode::_remote_tree_multi_select_requested).bind(id));
+	node->connect("remote_tree_clear_selection_requested", callable_mp(this, &EditorDebuggerNode::_remote_tree_clear_selection_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("multi_remote_object_updated", callable_mp(this, &EditorDebuggerNode::_multi_remote_object_updated).bind(id));
 	node->connect("remote_object_property_updated", callable_mp(this, &EditorDebuggerNode::_remote_object_property_updated).bind(id));
 	node->connect("remote_object_requested", callable_mp(this, &EditorDebuggerNode::_remote_object_requested).bind(id));
 	node->connect("set_breakpoint", callable_mp(this, &EditorDebuggerNode::_breakpoint_set_in_tree).bind(id));
@@ -218,10 +223,6 @@ void EditorDebuggerNode::register_undo_redo(UndoRedo *p_undo_redo) {
 	p_undo_redo->set_property_notify_callback(_properties_changed, this);
 }
 
-EditorDebuggerRemoteObject *EditorDebuggerNode::get_inspected_remote_object() {
-	return Object::cast_to<EditorDebuggerRemoteObject>(ObjectDB::get_instance(EditorNode::get_singleton()->get_editor_selection_history()->get_current()));
-}
-
 ScriptEditorDebugger *EditorDebuggerNode::get_debugger(int p_id) const {
 	return Object::cast_to<ScriptEditorDebugger>(tabs->get_tab_control(p_id));
 }
@@ -356,8 +357,10 @@ void EditorDebuggerNode::_notification(int p_what) {
 			inspect_edited_object_timeout -= get_process_delta_time();
 			if (inspect_edited_object_timeout < 0) {
 				inspect_edited_object_timeout = EDITOR_GET("debugger/remote_inspect_refresh_interval");
-				if (EditorDebuggerRemoteObject *obj = get_inspected_remote_object()) {
+				if (EditorDebuggerRemoteObject *obj = Object::cast_to<EditorDebuggerRemoteObject>(InspectorDock::get_inspector_singleton()->get_edited_object())) {
 					get_current_debugger()->request_remote_object(obj->remote_object_id);
+				} else if (EditorDebuggerMultiRemoteObject *mobj = Object::cast_to<EditorDebuggerMultiRemoteObject>(InspectorDock::get_inspector_singleton()->get_edited_object())) {
+					get_current_debugger()->request_multi_remote_objects(mobj->remote_object_ids);
 				}
 			}
 
@@ -466,14 +469,15 @@ void EditorDebuggerNode::_debugger_wants_stop(int p_id) {
 }
 
 void EditorDebuggerNode::_debugger_changed(int p_tab) {
-	if (get_inspected_remote_object()) {
+	if (InspectorDock::get_inspector_singleton()->get_edited_object()) {
 		// Clear inspected object, you can only inspect objects in selected debugger.
 		// Hopefully, in the future, we will have one inspector per debugger.
 		EditorNode::get_singleton()->push_item(nullptr);
 	}
 
-	if (get_previous_debugger()) {
-		_text_editor_stack_clear(get_previous_debugger());
+	if (ScriptEditorDebugger *prev_debug = get_previous_debugger()) {
+		prev_debug->clear_inspector();
+		_text_editor_stack_clear(prev_debug);
 	}
 	if (remote_scene_tree->is_visible_in_tree()) {
 		get_current_debugger()->request_remote_tree();
@@ -638,13 +642,31 @@ void EditorDebuggerNode::request_remote_tree() {
 	get_current_debugger()->request_remote_tree();
 }
 
-void EditorDebuggerNode::_remote_tree_select_requested(ObjectID p_id, int p_debugger) {
+void EditorDebuggerNode::clear_remote_tree_selection() {
+	remote_scene_tree->clear_selection();
+}
+
+void EditorDebuggerNode::_remote_tree_select_requested(const 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_multi_select_requested(const TypedArray<int64_t> &p_ids, int p_debugger) {
+	if (p_debugger != tabs->get_current_tab()) {
+		return;
+	}
+	remote_scene_tree->select_multi_nodes(p_ids);
+}
+
+void EditorDebuggerNode::_remote_tree_clear_selection_requested(int p_debugger) {
+	if (p_debugger != tabs->get_current_tab()) {
+		return;
+	}
+	remote_scene_tree->clear_selection();
+}
+
 void EditorDebuggerNode::_remote_tree_updated(int p_debugger) {
 	if (p_debugger != tabs->get_current_tab()) {
 		return;
@@ -675,25 +697,40 @@ void EditorDebuggerNode::_remote_object_updated(ObjectID p_id, int p_debugger) {
 	if (p_debugger != tabs->get_current_tab()) {
 		return;
 	}
-	if (EditorDebuggerRemoteObject *obj = get_inspected_remote_object()) {
+	if (EditorDebuggerRemoteObject *obj = Object::cast_to<EditorDebuggerRemoteObject>(InspectorDock::get_inspector_singleton()->get_edited_object())) {
 		if (obj->remote_object_id == p_id) {
-			return; // Already being edited
+			return; // Already being edited.
 		}
 	}
 
 	EditorNode::get_singleton()->push_item(get_current_debugger()->get_remote_object(p_id));
 }
 
+void EditorDebuggerNode::_multi_remote_object_updated(EditorDebuggerMultiRemoteObject *p_multi, int p_debugger) {
+	if (p_debugger == tabs->get_current_tab()) {
+		EditorNode::get_singleton()->push_item(p_multi);
+	}
+}
+
 void EditorDebuggerNode::_remote_object_property_updated(ObjectID p_id, const String &p_property, int p_debugger) {
 	if (p_debugger != tabs->get_current_tab()) {
 		return;
 	}
-	if (EditorDebuggerRemoteObject *obj = get_inspected_remote_object()) {
-		if (obj->remote_object_id != p_id) {
+
+	Object *obj = InspectorDock::get_inspector_singleton()->get_edited_object();
+	if (!obj) {
+		return;
+	}
+
+	if (EditorDebuggerRemoteObject *robj = Object::cast_to<EditorDebuggerRemoteObject>(obj)) {
+		if (robj->remote_object_id != p_id) {
 			return;
 		}
-		InspectorDock::get_inspector_singleton()->update_property(p_property);
+	} else if (obj->get_instance_id() != p_id) {
+		return; // Most likely an EditorDebuggerMultiRemoteObject.
 	}
+
+	InspectorDock::get_inspector_singleton()->update_property(p_property);
 }
 
 void EditorDebuggerNode::_remote_object_requested(ObjectID p_id, int p_debugger) {
@@ -704,6 +741,22 @@ void EditorDebuggerNode::_remote_object_requested(ObjectID p_id, int p_debugger)
 	get_current_debugger()->request_remote_object(p_id);
 }
 
+void EditorDebuggerNode::_multi_remote_object_requested(const TypedArray<uint64_t> &p_ids, int p_debugger) {
+	if (p_debugger != tabs->get_current_tab()) {
+		return;
+	}
+	inspect_edited_object_timeout = 0.7; // Temporarily disable timeout to avoid multiple requests.
+	get_current_debugger()->request_multi_remote_objects(p_ids);
+}
+
+void EditorDebuggerNode::_remote_selection_cleared(int p_debugger) {
+	if (p_debugger != tabs->get_current_tab()) {
+		return;
+	}
+	inspect_edited_object_timeout = 0.7; // Temporarily disable timeout to avoid multiple requests.
+	get_current_debugger()->clear_inspector();
+}
+
 void EditorDebuggerNode::_save_node_requested(ObjectID p_id, const String &p_file, 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 12c0d30c4261..2aea540fedb5 100644
--- a/editor/debugger/editor_debugger_node.h
+++ b/editor/debugger/editor_debugger_node.h
@@ -39,6 +39,7 @@ class Button;
 class DebugAdapterParser;
 class EditorDebuggerPlugin;
 class EditorDebuggerTree;
+class EditorDebuggerMultiRemoteObject;
 class EditorDebuggerRemoteObject;
 class MenuButton;
 class ScriptEditorDebugger;
@@ -117,7 +118,6 @@ class EditorDebuggerNode : public MarginContainer {
 	HashSet<Ref<EditorDebuggerPlugin>> debugger_plugins;
 
 	ScriptEditorDebugger *_add_debugger();
-	EditorDebuggerRemoteObject *get_inspected_remote_object();
 	void _update_errors();
 
 	friend class DebuggerEditorPlugin;
@@ -129,12 +129,17 @@ 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_select_requested(const ObjectID &p_id, int p_debugger);
+	void _remote_tree_multi_select_requested(const TypedArray<int64_t> &p_ids, int p_debugger);
+	void _remote_tree_clear_selection_requested(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);
+	void _multi_remote_object_updated(EditorDebuggerMultiRemoteObject *p_multi, int p_debugger);
 	void _remote_object_property_updated(ObjectID p_id, const String &p_property, int p_debugger);
 	void _remote_object_requested(ObjectID p_id, int p_debugger);
+	void _multi_remote_object_requested(const TypedArray<uint64_t> &p_id, int p_debugger);
+	void _remote_selection_cleared(int p_debugger);
 	void _save_node_requested(ObjectID p_id, const String &p_file, int p_debugger);
 
 	void _breakpoint_set_in_tree(Ref<RefCounted> p_script, int p_line, bool p_enabled, int p_debugger);
@@ -191,6 +196,7 @@ class EditorDebuggerNode : public MarginContainer {
 
 	// Remote inspector/edit.
 	void request_remote_tree();
+	void clear_remote_tree_selection();
 	static void _methods_changed(void *p_ud, Object *p_base, const StringName &p_name, const Variant **p_args, int p_argcount);
 	static void _properties_changed(void *p_ud, Object *p_base, const StringName &p_property, const Variant &p_value);
 
diff --git a/editor/debugger/editor_debugger_tree.cpp b/editor/debugger/editor_debugger_tree.cpp
index a9e4adf674c2..3124758f39ea 100644
--- a/editor/debugger/editor_debugger_tree.cpp
+++ b/editor/debugger/editor_debugger_tree.cpp
@@ -43,6 +43,7 @@
 EditorDebuggerTree::EditorDebuggerTree() {
 	set_v_size_flags(SIZE_EXPAND_FILL);
 	set_allow_rmb_select(true);
+	set_select_mode(SELECT_MULTI);
 
 	// Popup
 	item_menu = memnew(PopupMenu);
@@ -53,6 +54,9 @@ EditorDebuggerTree::EditorDebuggerTree() {
 	file_dialog = memnew(EditorFileDialog);
 	file_dialog->connect("file_selected", callable_mp(this, &EditorDebuggerTree::_file_selected));
 	add_child(file_dialog);
+
+	accept = memnew(AcceptDialog);
+	add_child(accept);
 }
 
 void EditorDebuggerTree::_notification(int p_what) {
@@ -60,7 +64,8 @@ void EditorDebuggerTree::_notification(int p_what) {
 		case NOTIFICATION_POSTINITIALIZE: {
 			set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED);
 
-			connect("cell_selected", callable_mp(this, &EditorDebuggerTree::_scene_tree_selected));
+			connect("multi_selected", callable_mp(this, &EditorDebuggerTree::_scene_tree_selection_changed));
+			connect("nothing_selected", callable_mp(this, &EditorDebuggerTree::_scene_tree_nothing_selected));
 			connect("item_collapsed", callable_mp(this, &EditorDebuggerTree::_scene_tree_folded));
 			connect("item_mouse_selected", callable_mp(this, &EditorDebuggerTree::_scene_tree_rmb_selected));
 		} break;
@@ -73,23 +78,44 @@ void EditorDebuggerTree::_notification(int p_what) {
 
 void EditorDebuggerTree::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("object_selected", PropertyInfo(Variant::INT, "object_id"), PropertyInfo(Variant::INT, "debugger")));
+	ADD_SIGNAL(MethodInfo("multi_objects_selected", PropertyInfo(Variant::ARRAY, "object_ids"), PropertyInfo(Variant::INT, "debugger")));
+	ADD_SIGNAL(MethodInfo("selection_cleared", PropertyInfo(Variant::INT, "debugger")));
 	ADD_SIGNAL(MethodInfo("save_node", PropertyInfo(Variant::INT, "object_id"), PropertyInfo(Variant::STRING, "filename"), PropertyInfo(Variant::INT, "debugger")));
 	ADD_SIGNAL(MethodInfo("open"));
 }
 
-void EditorDebuggerTree::_scene_tree_selected() {
-	if (updating_scene_tree) {
+void EditorDebuggerTree::_scene_tree_selection_changed(TreeItem *p_item, int p_column, bool p_selected) {
+	if (updating_scene_tree || !p_item) {
 		return;
 	}
 
-	TreeItem *item = get_selected();
-	if (!item) {
-		return;
+	uint64_t id = uint64_t(p_item->get_metadata(0));
+	if (p_selected) {
+		if (!inspected_object_ids.has(id)) {
+			inspected_object_ids.append(id);
+		}
+	} else if (inspected_object_ids.has(id)) {
+		inspected_object_ids.erase(id);
 	}
 
-	inspected_object_id = uint64_t(item->get_metadata(0));
+	// Delay signal emission, so the ID list is up to date.
+	callable_mp(this, &EditorDebuggerTree::_notify_selection_changed).call_deferred();
+}
+
+void EditorDebuggerTree::_scene_tree_nothing_selected() {
+	deselect_all();
+	inspected_object_ids.clear();
+	emit_signal(SNAME("selection_cleared"), debugger_id);
+}
 
-	emit_signal(SNAME("object_selected"), inspected_object_id, debugger_id);
+void EditorDebuggerTree::_notify_selection_changed() {
+	if (inspected_object_ids.is_empty()) {
+		emit_signal(SNAME("selection_cleared"), debugger_id);
+	} else if (inspected_object_ids.size() == 1) {
+		emit_signal(SNAME("object_selected"), inspected_object_ids[0], debugger_id);
+	} else {
+		emit_signal(SNAME("multi_objects_selected"), inspected_object_ids, debugger_id);
+	}
 }
 
 void EditorDebuggerTree::_scene_tree_folded(Object *p_obj) {
@@ -102,7 +128,7 @@ void EditorDebuggerTree::_scene_tree_folded(Object *p_obj) {
 		return;
 	}
 
-	ObjectID id = ObjectID(uint64_t(item->get_metadata(0)));
+	ObjectID id = ObjectID(item->get_metadata(0));
 	if (unfold_cache.has(id)) {
 		unfold_cache.erase(id);
 	} else {
@@ -123,7 +149,7 @@ void EditorDebuggerTree::_scene_tree_rmb_selected(const Vector2 &p_position, Mou
 	item->select(0);
 
 	item_menu->clear();
-	item_menu->add_icon_item(get_editor_theme_icon(SNAME("CreateNewSceneFrom")), TTR("Save Branch as Scene"), ITEM_MENU_SAVE_REMOTE_NODE);
+	item_menu->add_icon_item(get_editor_theme_icon(SNAME("CreateNewSceneFrom")), TTR("Save Branch as Scene..."), ITEM_MENU_SAVE_REMOTE_NODE);
 	item_menu->add_icon_item(get_editor_theme_icon(SNAME("CopyNodePath")), TTR("Copy Node Path"), ITEM_MENU_COPY_NODE_PATH);
 	item_menu->add_icon_item(get_editor_theme_icon(SNAME("Collapse")), TTR("Expand/Collapse Branch"), ITEM_MENU_EXPAND_COLLAPSE);
 	item_menu->set_position(get_screen_position() + get_local_mouse_position());
@@ -152,6 +178,7 @@ void EditorDebuggerTree::update_scene_tree(const SceneDebuggerTree *p_tree, int
 	bool should_scroll = scrolling_to_item || filter != last_filter;
 	scrolling_to_item = false;
 	TreeItem *scroll_item = nullptr;
+	TypedArray<uint64_t> ids_present;
 
 	// Nodes are in a flatten list, depth first. Use a stack of parents, avoid recursion.
 	List<Pair<TreeItem *, int>> parents;
@@ -186,7 +213,9 @@ 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 (inspected_object_ids.has(uint64_t(node.id))) {
+				ids_present.append(node.id);
+
 				if (selection_uncollapse_all) {
 					selection_uncollapse_all = false;
 
@@ -271,20 +300,51 @@ void EditorDebuggerTree::update_scene_tree(const SceneDebuggerTree *p_tree, int
 		}
 	}
 
+	inspected_object_ids = ids_present;
+
 	debugger_id = p_debugger; // Needed by hook, could be avoided if every debugger had its own tree.
 	if (scroll_item) {
 		scroll_to_item(scroll_item, false);
 	}
+
 	last_filter = filter;
 	updating_scene_tree = false;
 }
 
-void EditorDebuggerTree::select_node(ObjectID p_id) {
+void EditorDebuggerTree::select_node(const 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);
+	inspected_object_ids.clear();
+	inspected_object_ids.append(uint64_t(p_id));
 	scrolling_to_item = true;
-	emit_signal(SNAME("object_selected"), inspected_object_id, debugger_id);
+	emit_signal(SNAME("object_selected"), inspected_object_ids[0], debugger_id);
+
+	if (!updating_scene_tree) {
+		// Request a tree refresh.
+		EditorDebuggerNode::get_singleton()->request_remote_tree();
+	}
+	// Set the value immediately, so no update flooding happens and causes a crash.
+	updating_scene_tree = true;
+}
+
+void EditorDebuggerTree::select_multi_nodes(const TypedArray<int64_t> &p_ids) {
+	// 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_ids = p_ids;
+	scrolling_to_item = true;
+	emit_signal(SNAME("multi_objects_selected"), inspected_object_ids, debugger_id);
+
+	if (!updating_scene_tree) {
+		// Request a tree refresh.
+		EditorDebuggerNode::get_singleton()->request_remote_tree();
+	}
+	// Set the value immediately, so no update flooding happens and causes a crash.
+	updating_scene_tree = true;
+}
+
+void EditorDebuggerTree::clear_selection() {
+	inspected_object_ids.clear();
+	emit_signal(SNAME("selection_cleared"), debugger_id);
 
 	if (!updating_scene_tree) {
 		// Request a tree refresh.
@@ -410,8 +470,11 @@ void EditorDebuggerTree::_item_menu_id_pressed(int p_option) {
 }
 
 void EditorDebuggerTree::_file_selected(const String &p_file) {
-	if (inspected_object_id.is_null()) {
+	if (inspected_object_ids.size() != 1) {
+		accept->set_text(vformat(TTR("Saving the branch as a scene requires selecting only one node, but you have selected %d nodes."), inspected_object_ids.size()));
+		accept->popup_centered();
 		return;
 	}
-	emit_signal(SNAME("save_node"), inspected_object_id, p_file, debugger_id);
+
+	emit_signal(SNAME("save_node"), inspected_object_ids[0], p_file, debugger_id);
 }
diff --git a/editor/debugger/editor_debugger_tree.h b/editor/debugger/editor_debugger_tree.h
index d048688cad24..dec5d23b3526 100644
--- a/editor/debugger/editor_debugger_tree.h
+++ b/editor/debugger/editor_debugger_tree.h
@@ -33,6 +33,7 @@
 
 #include "scene/gui/tree.h"
 
+class AcceptDialog;
 class SceneDebuggerTree;
 class EditorFileDialog;
 
@@ -46,7 +47,7 @@ class EditorDebuggerTree : public Tree {
 		ITEM_MENU_EXPAND_COLLAPSE,
 	};
 
-	ObjectID inspected_object_id;
+	TypedArray<uint64_t> inspected_object_ids;
 	int debugger_id = 0;
 	bool updating_scene_tree = false;
 	bool scrolling_to_item = false;
@@ -54,11 +55,14 @@ class EditorDebuggerTree : public Tree {
 	HashSet<ObjectID> unfold_cache;
 	PopupMenu *item_menu = nullptr;
 	EditorFileDialog *file_dialog = nullptr;
+	AcceptDialog *accept;
 	String last_filter;
 
 	String _get_path(TreeItem *p_item);
 	void _scene_tree_folded(Object *p_obj);
-	void _scene_tree_selected();
+	void _scene_tree_selection_changed(TreeItem *p_item, int p_column, bool p_selected);
+	void _scene_tree_nothing_selected();
+	void _notify_selection_changed();
 	void _scene_tree_rmb_selected(const Vector2 &p_position, MouseButton p_button);
 	void _item_menu_id_pressed(int p_option);
 	void _file_selected(const String &p_file);
@@ -80,7 +84,10 @@ 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);
+	void select_node(const ObjectID &p_id);
+	void select_multi_nodes(const TypedArray<int64_t> &p_ids);
+	void clear_selection();
+
 	EditorDebuggerTree();
 };
 
diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
index da59450dd0a5..5ed8eef6dedd 100644
--- a/editor/debugger/script_editor_debugger.cpp
+++ b/editor/debugger/script_editor_debugger.cpp
@@ -260,12 +260,17 @@ void ScriptEditorDebugger::request_remote_evaluate(const String &p_expression, i
 	_put_msg("evaluate", msg);
 }
 
-void ScriptEditorDebugger::update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value) {
+void ScriptEditorDebugger::update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value, const String &p_field) {
 	Array msg;
 	msg.push_back(p_obj_id);
 	msg.push_back(p_prop);
 	msg.push_back(p_value);
-	_put_msg("scene:set_object_property", msg);
+	if (p_field.is_empty()) {
+		_put_msg("scene:set_object_property", msg);
+	} else {
+		msg.push_back(p_field);
+		_put_msg("scene:set_object_property_field", msg);
+	}
 }
 
 void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) {
@@ -275,6 +280,16 @@ void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) {
 	_put_msg("scene:inspect_object", msg);
 }
 
+void ScriptEditorDebugger::request_multi_remote_objects(const TypedArray<uint64_t> &p_obj_ids) {
+	ERR_FAIL_COND(p_obj_ids.is_empty());
+	_put_msg("scene:inspect_multi_objects", p_obj_ids);
+}
+
+void ScriptEditorDebugger::clear_inspector() {
+	inspector->clear_remote_inspector();
+	_put_msg("scene:clear_selection", Array());
+}
+
 Object *ScriptEditorDebugger::get_remote_object(ObjectID p_id) {
 	return inspector->get_object(p_id);
 }
@@ -288,6 +303,13 @@ void ScriptEditorDebugger::_remote_object_edited(ObjectID p_id, const String &p_
 	request_remote_object(p_id);
 }
 
+void ScriptEditorDebugger::_multi_remote_objects_edited(const TypedArray<int64_t> &p_ids, const String &p_prop, const Variant &p_value, const String &p_field) {
+	for (const Variant &id : p_ids) {
+		update_remote_object((ObjectID)id, p_prop, p_value, p_field);
+	}
+	request_multi_remote_objects(p_ids);
+}
+
 void ScriptEditorDebugger::_remote_object_property_updated(ObjectID p_id, const String &p_property) {
 	emit_signal(SNAME("remote_object_property_updated"), p_id, p_property);
 }
@@ -411,6 +433,12 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, uint64_t p_thread
 		if (id.is_valid()) {
 			emit_signal(SNAME("remote_object_updated"), id);
 		}
+	} else if (p_msg == "scene:inspect_multi_objects") {
+		ERR_FAIL_COND(p_data.is_empty());
+		EditorDebuggerMultiRemoteObject *multi = inspector->get_multi_objects(p_data);
+		if (multi) {
+			emit_signal(SNAME("multi_remote_object_updated"), multi);
+		}
 	} else if (p_msg == "servers:memory_usage") {
 		vmem_tree->clear();
 		TreeItem *root = vmem_tree->create_item();
@@ -810,6 +838,12 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, uint64_t p_thread
 		if (!p_data.is_empty()) {
 			emit_signal(SNAME("remote_tree_select_requested"), p_data[0]);
 		}
+	} else if (p_msg == "multi_remote_nodes_clicked") {
+		if (!p_data.is_empty()) {
+			emit_signal(SNAME("remote_tree_multi_select_requested"), p_data[0]);
+		}
+	} else if (p_msg == "remote_nothing_clicked") {
+		emit_signal(SNAME("remote_tree_clear_selection_requested"));
 	} else if (p_msg == "performance:profile_names") {
 		Vector<StringName> monitors;
 		monitors.resize(p_data.size());
@@ -1766,7 +1800,7 @@ void ScriptEditorDebugger::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("live_debug_duplicate_node"), &ScriptEditorDebugger::live_debug_duplicate_node);
 	ClassDB::bind_method(D_METHOD("live_debug_reparent_node"), &ScriptEditorDebugger::live_debug_reparent_node);
 	ClassDB::bind_method(D_METHOD("request_remote_object", "id"), &ScriptEditorDebugger::request_remote_object);
-	ClassDB::bind_method(D_METHOD("update_remote_object", "id", "property", "value"), &ScriptEditorDebugger::update_remote_object);
+	ClassDB::bind_method(D_METHOD("update_remote_object", "id", "property", "value", "field"), &ScriptEditorDebugger::update_remote_object);
 
 	ADD_SIGNAL(MethodInfo("started"));
 	ADD_SIGNAL(MethodInfo("stopped"));
@@ -1779,9 +1813,12 @@ void ScriptEditorDebugger::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("breaked", PropertyInfo(Variant::BOOL, "reallydid"), PropertyInfo(Variant::BOOL, "can_debug"), PropertyInfo(Variant::STRING, "reason"), PropertyInfo(Variant::BOOL, "has_stackdump")));
 	ADD_SIGNAL(MethodInfo("remote_object_requested", PropertyInfo(Variant::INT, "id")));
 	ADD_SIGNAL(MethodInfo("remote_object_updated", PropertyInfo(Variant::INT, "id")));
+	ADD_SIGNAL(MethodInfo("multi_remote_object_updated", PropertyInfo(Variant::OBJECT, "multi_object")));
 	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("remote_tree_select_requested", PropertyInfo(Variant::INT, "id")));
+	ADD_SIGNAL(MethodInfo("remote_tree_multi_select_requested", PropertyInfo(Variant::ARRAY, "ids")));
+	ADD_SIGNAL(MethodInfo("remote_tree_clear_selection_requested"));
 	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")));
@@ -1944,6 +1981,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() {
 		inspector->set_read_only(true);
 		inspector->connect("object_selected", callable_mp(this, &ScriptEditorDebugger::_remote_object_selected));
 		inspector->connect("object_edited", callable_mp(this, &ScriptEditorDebugger::_remote_object_edited));
+		inspector->connect("multi_objects_edited", callable_mp(this, &ScriptEditorDebugger::_multi_remote_objects_edited));
 		inspector->connect("object_property_updated", callable_mp(this, &ScriptEditorDebugger::_remote_object_property_updated));
 		inspector->register_text_enter(search);
 		inspector->set_use_filter(true);
diff --git a/editor/debugger/script_editor_debugger.h b/editor/debugger/script_editor_debugger.h
index 06a968e14100..8f5688689ad6 100644
--- a/editor/debugger/script_editor_debugger.h
+++ b/editor/debugger/script_editor_debugger.h
@@ -193,6 +193,7 @@ class ScriptEditorDebugger : public MarginContainer {
 	void _update_buttons_state();
 	void _remote_object_selected(ObjectID p_object);
 	void _remote_object_edited(ObjectID, const String &p_prop, const Variant &p_value);
+	void _multi_remote_objects_edited(const TypedArray<int64_t> &p_ids, const String &p_prop, const Variant &p_value, const String &p_field);
 	void _remote_object_property_updated(ObjectID p_id, const String &p_property);
 
 	void _video_mem_request();
@@ -247,9 +248,12 @@ class ScriptEditorDebugger : public MarginContainer {
 
 public:
 	void request_remote_object(ObjectID p_obj_id);
-	void update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value);
+	void request_multi_remote_objects(const TypedArray<uint64_t> &p_obj_ids);
+	void update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value, const String &p_field = "");
 	Object *get_remote_object(ObjectID p_id);
 
+	void clear_inspector();
+
 	// Needed by _live_edit_set, buttons state.
 	void set_editor_remote_tree(const Tree *p_tree) { editor_remote_tree = p_tree; }
 
diff --git a/editor/editor_inspector.cpp b/editor/editor_inspector.cpp
index 6e837560f6bb..868d1114fedc 100644
--- a/editor/editor_inspector.cpp
+++ b/editor/editor_inspector.cpp
@@ -33,6 +33,7 @@
 
 #include "core/os/keyboard.h"
 #include "editor/add_metadata_dialog.h"
+#include "editor/debugger/editor_debugger_inspector.h"
 #include "editor/doc_tools.h"
 #include "editor/editor_feature_profile.h"
 #include "editor/editor_main_screen.h"
@@ -4001,6 +4002,10 @@ void EditorInspector::_edit_set(const String &p_name, const Variant &p_value, bo
 		Object::cast_to<MultiNodeEdit>(object)->set_property_field(p_name, p_value, p_changed_field);
 		_edit_request_change(object, p_name);
 		emit_signal(_prop_edited, p_name);
+	} else if (Object::cast_to<EditorDebuggerMultiRemoteObject>(object)) {
+		Object::cast_to<EditorDebuggerMultiRemoteObject>(object)->set_property_field(p_name, p_value, p_changed_field);
+		_edit_request_change(object, p_name);
+		emit_signal(_prop_edited, p_name);
 	} else {
 		undo_redo->create_action(vformat(TTR("Set %s"), p_name), UndoRedo::MERGE_ENDS);
 		undo_redo->add_do_property(object, p_name, p_value);
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index f056a477c41b..fb69cc4d8ad0 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -2366,6 +2366,7 @@ void EditorNode::push_item(Object *p_object, const String &p_property, bool p_in
 		NodeDock::get_singleton()->set_node(nullptr);
 		SceneTreeDock::get_singleton()->set_selected(nullptr);
 		InspectorDock::get_singleton()->update(nullptr);
+		EditorDebuggerNode::get_singleton()->clear_remote_tree_selection();
 		hide_unused_editors();
 		return;
 	}
@@ -2487,12 +2488,13 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update
 		InspectorDock::get_inspector_singleton()->edit(nullptr);
 		NodeDock::get_singleton()->set_node(nullptr);
 		InspectorDock::get_singleton()->update(nullptr);
+		EditorDebuggerNode::get_singleton()->clear_remote_tree_selection();
 		hide_unused_editors();
 		return;
 	}
 
 	// Update the use folding setting and state.
-	bool disable_folding = bool(EDITOR_GET("interface/inspector/disable_folding")) || current_obj->is_class("EditorDebuggerRemoteObject");
+	bool disable_folding = bool(EDITOR_GET("interface/inspector/disable_folding")) || current_obj->is_class("EditorDebuggerRemoteObject") || current_obj->is_class("EditorDebuggerMultiRemoteObject");
 	if (InspectorDock::get_inspector_singleton()->is_using_folding() == disable_folding) {
 		InspectorDock::get_inspector_singleton()->set_use_folding(!disable_folding, false);
 	}
@@ -2520,6 +2522,7 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update
 			SceneTreeDock::get_singleton()->set_selected(nullptr);
 			NodeDock::get_singleton()->set_node(nullptr);
 			InspectorDock::get_singleton()->update(nullptr);
+			EditorDebuggerNode::get_singleton()->clear_remote_tree_selection();
 			ImportDock::get_singleton()->set_edit_path(current_res->get_path());
 		}
 
@@ -2559,6 +2562,7 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update
 			SceneTreeDock::get_singleton()->set_selected(nullptr);
 			InspectorDock::get_singleton()->update(nullptr);
 		}
+		EditorDebuggerNode::get_singleton()->clear_remote_tree_selection();
 
 		if (get_edited_scene() && !get_edited_scene()->get_scene_file_path().is_empty()) {
 			String source_scene = get_edited_scene()->get_scene_file_path();
@@ -2567,7 +2571,6 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update
 				info_is_warning = true;
 			}
 		}
-
 	} else {
 		Node *selected_node = nullptr;
 
@@ -2593,6 +2596,10 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update
 			}
 		}
 
+		if (!current_obj->is_class("EditorDebuggerRemoteObject") && !current_obj->is_class("EditorDebuggerMultiRemoteObject")) {
+			EditorDebuggerNode::get_singleton()->clear_remote_tree_selection();
+		}
+
 		InspectorDock::get_inspector_singleton()->edit(current_obj);
 		NodeDock::get_singleton()->set_node(nullptr);
 		SceneTreeDock::get_singleton()->set_selected(selected_node);
diff --git a/editor/editor_undo_redo_manager.cpp b/editor/editor_undo_redo_manager.cpp
index 57e55e7bacb0..bb5956f224a0 100644
--- a/editor/editor_undo_redo_manager.cpp
+++ b/editor/editor_undo_redo_manager.cpp
@@ -62,7 +62,7 @@ UndoRedo *EditorUndoRedoManager::get_history_undo_redo(int p_idx) const {
 int EditorUndoRedoManager::get_history_id_for_object(Object *p_object) const {
 	int history_id = INVALID_HISTORY;
 
-	if (Object::cast_to<EditorDebuggerRemoteObject>(p_object)) {
+	if (Object::cast_to<EditorDebuggerRemoteObject>(p_object) || Object::cast_to<EditorDebuggerMultiRemoteObject>(p_object)) {
 		return REMOTE_HISTORY;
 	}
 
diff --git a/editor/gui/editor_object_selector.cpp b/editor/gui/editor_object_selector.cpp
index ec5caa8c2a54..c901a688da84 100644
--- a/editor/gui/editor_object_selector.cpp
+++ b/editor/gui/editor_object_selector.cpp
@@ -132,7 +132,7 @@ void EditorObjectSelector::update_path() {
 		Ref<Texture2D> obj_icon;
 		if (Object::cast_to<MultiNodeEdit>(obj)) {
 			obj_icon = EditorNode::get_singleton()->get_class_icon(Object::cast_to<MultiNodeEdit>(obj)->get_edited_class_name());
-		} else if (Object::cast_to<EditorDebuggerRemoteObject>(obj)) {
+		} else if (Object::cast_to<EditorDebuggerRemoteObject>(obj) || Object::cast_to<EditorDebuggerMultiRemoteObject>(obj)) {
 			String class_name;
 			Ref<Script> base_script = obj->get_script();
 			if (base_script.is_valid()) {
@@ -144,7 +144,15 @@ void EditorObjectSelector::update_path() {
 				}
 			}
 
-			obj_icon = EditorNode::get_singleton()->get_class_icon(class_name.is_empty() ? Object::cast_to<EditorDebuggerRemoteObject>(obj)->type_name : class_name);
+			if (class_name.is_empty()) {
+				if (EditorDebuggerRemoteObject *robj = Object::cast_to<EditorDebuggerRemoteObject>(obj)) {
+					class_name = robj->type_name;
+				} else {
+					class_name = Object::cast_to<EditorDebuggerMultiRemoteObject>(obj)->type_name;
+				}
+			}
+
+			obj_icon = EditorNode::get_singleton()->get_class_icon(class_name);
 		} else {
 			obj_icon = EditorNode::get_singleton()->get_object_icon(obj);
 		}
@@ -168,7 +176,7 @@ void EditorObjectSelector::update_path() {
 				if (name.is_empty()) {
 					name = r->get_class();
 				}
-			} else if (obj->is_class("EditorDebuggerRemoteObject")) {
+			} else if (obj->is_class("EditorDebuggerRemoteObject") || obj->is_class("EditorDebuggerMultiRemoteObject")) {
 				name = obj->call("get_title");
 			} else if (Object::cast_to<Node>(obj)) {
 				name = Object::cast_to<Node>(obj)->get_name();
diff --git a/editor/inspector_dock.cpp b/editor/inspector_dock.cpp
index 46876644fb56..8ba2b7ffb00a 100644
--- a/editor/inspector_dock.cpp
+++ b/editor/inspector_dock.cpp
@@ -347,7 +347,7 @@ void InspectorDock::_prepare_history() {
 			}
 		} else if (Object::cast_to<Node>(obj)) {
 			text = Object::cast_to<Node>(obj)->get_name();
-		} else if (obj->is_class("EditorDebuggerRemoteObject")) {
+		} else if (obj->is_class("EditorDebuggerRemoteObject") || obj->is_class("EditorDebuggerMultiRemoteObject")) {
 			text = obj->call("get_title");
 		} else {
 			text = obj->get_class();
diff --git a/editor/plugins/game_view_plugin.cpp b/editor/plugins/game_view_plugin.cpp
index 5c1f81ee94e3..6e42b5421c6f 100644
--- a/editor/plugins/game_view_plugin.cpp
+++ b/editor/plugins/game_view_plugin.cpp
@@ -34,6 +34,7 @@
 #include "editor/editor_main_screen.h"
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
+#include "editor/editor_string_names.h"
 #include "editor/themes/editor_scale.h"
 #include "scene/gui/button.h"
 #include "scene/gui/menu_button.h"
@@ -47,7 +48,13 @@ void GameViewDebugger::_session_started(Ref<EditorDebuggerSession> p_session) {
 	settings["editors/panning/simple_panning"] = EDITOR_GET("editors/panning/simple_panning");
 	settings["editors/panning/warped_mouse_panning"] = EDITOR_GET("editors/panning/warped_mouse_panning");
 	settings["editors/panning/2d_editor_pan_speed"] = EDITOR_GET("editors/panning/2d_editor_pan_speed");
+	settings["editors/polygon_editor/point_grab_radius"] = EDITOR_GET("editors/polygon_editor/point_grab_radius");
 	settings["canvas_item_editor/pan_view"] = DebuggerMarshalls::serialize_key_shortcut(ED_GET_SHORTCUT("canvas_item_editor/pan_view"));
+	settings["box_selection_fill_color"] = EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("box_selection_fill_color"), EditorStringName(Editor));
+	settings["box_selection_stroke_color"] = EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("box_selection_stroke_color"), EditorStringName(Editor));
+#ifndef _3D_DISABLED
+	settings["editors/3d/selection_box_color"] = EDITOR_GET("editors/3d/selection_box_color");
+#endif // _3D_DISABLED
 	setup_data.append(settings);
 	p_session->send_message("scene:runtime_node_select_setup", setup_data);
 
diff --git a/scene/debugger/scene_debugger.cpp b/scene/debugger/scene_debugger.cpp
index 377bc0eefe91..51d05051e8ff 100644
--- a/scene/debugger/scene_debugger.cpp
+++ b/scene/debugger/scene_debugger.cpp
@@ -33,6 +33,7 @@
 #include "core/debugger/debugger_marshalls.h"
 #include "core/debugger/engine_debugger.h"
 #include "core/io/marshalls.h"
+#include "core/math/math_fieldwise.h"
 #include "core/object/script_language.h"
 #include "core/templates/local_vector.h"
 #include "scene/2d/physics/collision_object_2d.h"
@@ -44,6 +45,7 @@
 #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/3d/convex_polygon_shape_3d.h"
 #include "scene/resources/surface_tool.h"
 #endif // _3D_DISABLED
 #include "scene/gui/popup_menu.h"
@@ -120,21 +122,35 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 	if (p_msg == "setup_scene") {
 		SceneTree::get_singleton()->get_root()->connect(SceneStringName(window_input), callable_mp_static(SceneDebugger::_handle_input).bind(DebuggerMarshalls::deserialize_key_shortcut(p_args)));
 
-	} else if (p_msg == "request_scene_tree") { // Scene tree
+	} else if (p_msg == "request_scene_tree") { /// Scene Tree
 		live_editor->_send_tree();
 
-	} else if (p_msg == "save_node") { // Save node.
+	} else if (p_msg == "save_node") {
 		ERR_FAIL_COND_V(p_args.size() < 2, ERR_INVALID_DATA);
 		_save_node(p_args[0], p_args[1]);
 		Array arr;
 		arr.append(p_args[1]);
 		EngineDebugger::get_singleton()->send_message("filesystem:update_file", { arr });
 
-	} else if (p_msg == "inspect_object") { // Object Inspect
+	} else if (p_msg == "inspect_object") { /// Object Inspect
 		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
 		ObjectID id = p_args[0];
 		_send_object_id(id);
 
+	} else if (p_msg == "inspect_multi_objects") {
+		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
+		Vector<ObjectID> ids;
+		for (const ObjectID id : p_args) {
+			ids.append(id);
+		}
+		// Sorting is necessary to avoid the values constantly changing in the inspector.
+		// The downside is that it's ordered by index instead of selection order.
+		ids.sort();
+		_send_multi_object_ids(ids);
+
+	} else if (p_msg == "clear_selection") {
+		runtime_node_select->_clear_selection();
+
 	} else if (p_msg == "suspend_changed") {
 		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
 		bool suspended = p_args[0];
@@ -144,7 +160,7 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 	} else if (p_msg == "next_frame") {
 		_next_frame();
 
-	} else if (p_msg == "override_cameras") { // Camera
+	} 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];
@@ -182,6 +198,11 @@ Error SceneDebugger::parse_message(void *p_user, const String &p_msg, const Arra
 		_set_object_property(p_args[0], p_args[1], p_args[2]);
 		runtime_node_select->_queue_selection_update();
 
+	} else if (p_msg == "set_object_property_field") {
+		ERR_FAIL_COND_V(p_args.size() < 4, ERR_INVALID_DATA);
+		_set_object_property(p_args[0], p_args[1], p_args[2], p_args[3]);
+		runtime_node_select->_queue_selection_update();
+
 	} else if (p_msg == "reload_cached_files") {
 		ERR_FAIL_COND_V(p_args.is_empty(), ERR_INVALID_DATA);
 		PackedStringArray files = p_args[0];
@@ -354,21 +375,46 @@ void SceneDebugger::_set_node_owner_recursive(Node *p_node, Node *p_owner) {
 	}
 }
 
-void SceneDebugger::_send_object_id(ObjectID p_id, int p_max_size) {
+void SceneDebugger::_send_object_id(ObjectID p_id) {
 	SceneDebuggerObject obj(p_id);
 	if (obj.id.is_null()) {
 		return;
 	}
 
-	Node *node = Object::cast_to<Node>(ObjectDB::get_instance(p_id));
-	RuntimeNodeSelect::get_singleton()->_select_node(node);
+	LocalVector<Node *> vec;
+	if (Node *node = Object::cast_to<Node>(ObjectDB::get_instance(p_id))) {
+		vec.push_back(node);
+	}
+	RuntimeNodeSelect::get_singleton()->_set_selected_nodes(vec);
 
 	Array arr;
 	obj.serialize(arr);
 	EngineDebugger::get_singleton()->send_message("scene:inspect_object", arr);
 }
 
-void SceneDebugger::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value) {
+void SceneDebugger::_send_multi_object_ids(Vector<ObjectID> p_ids) {
+	LocalVector<Node *> nodes;
+	Array objs;
+	for (const ObjectID &id : p_ids) {
+		SceneDebuggerObject obj(id);
+		if (obj.id.is_null()) {
+			continue;
+		}
+
+		if (Node *node = Object::cast_to<Node>(ObjectDB::get_instance(id))) {
+			nodes.push_back(node);
+		}
+
+		Array arr;
+		obj.serialize(arr);
+		objs.append(arr);
+	}
+
+	RuntimeNodeSelect::get_singleton()->_set_selected_nodes(nodes);
+	EngineDebugger::get_singleton()->send_message("scene:inspect_multi_objects", objs);
+}
+
+void SceneDebugger::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value, const String &p_field) {
 	Object *obj = ObjectDB::get_instance(p_id);
 	if (!obj) {
 		return;
@@ -380,7 +426,16 @@ void SceneDebugger::_set_object_property(ObjectID p_id, const String &p_property
 		prop_name = ss[ss.size() - 1];
 	}
 
-	obj->set(prop_name, p_value);
+	Variant value;
+	if (p_field.is_empty()) {
+		// Whole value.
+		value = p_value;
+	} else {
+		// Only one field.
+		value = fieldwise_assign(obj->get(prop_name), p_value, p_field);
+	}
+
+	obj->set(prop_name, value);
 }
 
 void SceneDebugger::_next_frame() {
@@ -1220,19 +1275,11 @@ RuntimeNodeSelect::~RuntimeNodeSelect() {
 		memdelete(selection_list);
 	}
 
-	if (sbox_2d_canvas.is_valid()) {
-		RS::get_singleton()->free(sbox_2d_canvas);
+	if (draw_canvas.is_valid()) {
+		RS::get_singleton()->free(sel_drag_ci);
 		RS::get_singleton()->free(sbox_2d_ci);
+		RS::get_singleton()->free(draw_canvas);
 	}
-
-#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(const Dictionary &p_settings) {
@@ -1260,12 +1307,20 @@ void RuntimeNodeSelect::_setup(const Dictionary &p_settings) {
 	panner->set_scroll_speed(pan_speed);
 	warped_panning = p_settings.get("editors/panning/warped_mouse_panning", false);
 
+	sel_2d_grab_dist = p_settings.get("editors/polygon_editor/point_grab_radius", 0);
+
+	selection_area_fill = p_settings.get("box_selection_fill_color", Color());
+	selection_area_outline = p_settings.get("box_selection_stroke_color", Color());
+
+	draw_canvas = RS::get_singleton()->canvas_create();
+	sel_drag_ci = RS::get_singleton()->canvas_item_create();
+
 	/// 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);
+	RS::get_singleton()->viewport_attach_canvas(root->get_viewport_rid(), draw_canvas);
+	RS::get_singleton()->canvas_item_set_parent(sel_drag_ci, draw_canvas);
+	RS::get_singleton()->canvas_item_set_parent(sbox_2d_ci, draw_canvas);
 
 #ifndef _3D_DISABLED
 	cursor = Cursor();
@@ -1273,6 +1328,8 @@ void RuntimeNodeSelect::_setup(const Dictionary &p_settings) {
 	/// 3D Selection Box Generation
 	// Copied from the Node3DEditor implementation.
 
+	sbox_3d_color = p_settings.get("editors/3d/selection_box_color", Color());
+
 	// Use two AABBs to create the illusion of a slightly thicker line.
 	AABB aabb(Vector3(), Vector3(1, 1, 1));
 
@@ -1297,10 +1354,7 @@ void RuntimeNodeSelect::_setup(const Dictionary &p_settings) {
 	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_albedo(sbox_3d_color);
 	mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
 	st->set_material(mat);
 	sbox_3d_mesh = st->commit();
@@ -1309,7 +1363,7 @@ void RuntimeNodeSelect::_setup(const Dictionary &p_settings) {
 	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_albedo(sbox_3d_color * 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();
@@ -1367,12 +1421,11 @@ void RuntimeNodeSelect::_root_window_input(const Ref<InputEvent> &p_event) {
 		return;
 	}
 
+	bool is_dragging_camera = false;
 	if (camera_override) {
 		if (node_select_type == NODE_TYPE_2D) {
-			if (panner->gui_input(p_event, warped_panning ? Rect2(Vector2(), root->get_size()) : Rect2())) {
-				return;
-			}
-		} else if (node_select_type == NODE_TYPE_3D) {
+			is_dragging_camera = panner->gui_input(p_event, warped_panning ? Rect2(Vector2(), root->get_size()) : Rect2());
+		} else if (node_select_type == NODE_TYPE_3D && selection_drag_state == SELECTION_DRAG_NONE) {
 #ifndef _3D_DISABLED
 			if (root->get_camera_3d() && _handle_3d_input(p_event)) {
 				return;
@@ -1382,25 +1435,54 @@ void RuntimeNodeSelect::_root_window_input(const Ref<InputEvent> &p_event) {
 	}
 
 	Ref<InputEventMouseButton> b = p_event;
-	if (!b.is_valid() || !b->is_pressed()) {
+
+	if (selection_drag_state == SELECTION_DRAG_MOVE) {
+		Ref<InputEventMouseMotion> m = p_event;
+		if (m.is_valid()) {
+			_update_selection_drag(m->get_position());
+			return;
+		} else if (b.is_valid()) {
+			// Account for actions like zooming.
+			_update_selection_drag(b->get_position());
+		}
+	}
+
+	if (!b.is_valid()) {
 		return;
 	}
 
-	list_shortcut_pressed = node_select_mode == SELECT_MODE_SINGLE && b->get_button_index() == MouseButton::RIGHT && b->is_alt_pressed();
-	if (list_shortcut_pressed || b->get_button_index() == MouseButton::LEFT) {
-		selection_position = b->get_position();
+	// Ignore mouse wheel inputs.
+	if (b->get_button_index() != MouseButton::LEFT && b->get_button_index() != MouseButton::RIGHT) {
+		return;
+	}
+
+	if (selection_drag_state == SELECTION_DRAG_MOVE && !b->is_pressed() && b->get_button_index() == MouseButton::LEFT) {
+		selection_drag_state = SELECTION_DRAG_END;
+		selection_drag_area = selection_drag_area.abs();
+		_update_selection_drag();
+
+		// Trigger a selection in the position on release.
+		if (multi_shortcut_pressed) {
+			selection_position = b->get_position();
+		}
+	}
+
+	if (!is_dragging_camera && b->is_pressed()) {
+		multi_shortcut_pressed = b->is_shift_pressed();
+		list_shortcut_pressed = node_select_mode == SELECT_MODE_SINGLE && b->get_button_index() == MouseButton::RIGHT && b->is_alt_pressed();
+		if (list_shortcut_pressed || b->get_button_index() == MouseButton::LEFT) {
+			selection_position = b->get_position();
+		}
 	}
 }
 
 void RuntimeNodeSelect::_items_popup_index_pressed(int p_index, PopupMenu *p_popup) {
 	Object *obj = p_popup->get_item_metadata(p_index).get_validated_object();
-	if (!obj) {
-		return;
+	if (obj) {
+		Vector<Node *> node;
+		node.append(Object::cast_to<Node>(obj));
+		_send_ids(node);
 	}
-
-	Array message;
-	message.append(obj->get_instance_id());
-	EngineDebugger::get_singleton()->send_message("remote_node_clicked", message);
 }
 
 void RuntimeNodeSelect::_update_input_state() {
@@ -1485,20 +1567,24 @@ void RuntimeNodeSelect::_process_frame() {
 }
 
 void RuntimeNodeSelect::_physics_frame() {
-	if (!Math::is_inf(selection_position.x) || !Math::is_inf(selection_position.y)) {
-		_click_point();
-		selection_position = Point2(INFINITY, INFINITY);
+	if (selection_drag_state != SELECTION_DRAG_END && (selection_drag_state == SELECTION_DRAG_MOVE || Math::is_inf(selection_position.x))) {
+		return;
 	}
-}
 
-void RuntimeNodeSelect::_click_point() {
 	Window *root = SceneTree::get_singleton()->get_root();
 	Point2 pos = root->get_screen_transform().affine_inverse().xform(selection_position);
+	bool selection_drag_valid = selection_drag_state == SELECTION_DRAG_END && selection_drag_area.get_area() > SELECTION_MIN_AREA;
 	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);
+		if (selection_drag_valid) {
+			for (int i = 0; i < root->get_child_count(); i++) {
+				_find_canvas_items_at_rect(selection_drag_area, root->get_child(i), items);
+			}
+		} else if (!Math::is_inf(selection_position.x)) {
+			for (int i = 0; i < root->get_child_count(); i++) {
+				_find_canvas_items_at_pos(pos, root->get_child(i), items);
+			}
 		}
 
 		// Remove possible duplicates.
@@ -1515,21 +1601,87 @@ void RuntimeNodeSelect::_click_point() {
 		}
 	} else if (node_select_type == NODE_TYPE_3D) {
 #ifndef _3D_DISABLED
-		_find_3d_items_at_pos(pos, items);
+		if (selection_drag_valid) {
+			_find_3d_items_at_rect(selection_drag_area, items);
+		} else {
+			_find_3d_items_at_pos(pos, items);
+		}
 #endif // _3D_DISABLED
 	}
 
+	items.sort();
+
+	switch (selection_drag_state) {
+		case SELECTION_DRAG_END: {
+			selection_position = Point2(INFINITY, INFINITY);
+			selection_drag_state = SELECTION_DRAG_NONE;
+
+			if (selection_drag_area.get_area() > SELECTION_MIN_AREA) {
+				if (!items.is_empty()) {
+					Vector<Node *> nodes;
+					for (const SelectResult item : items) {
+						nodes.append(item.item);
+					}
+					_send_ids(nodes, false);
+				}
+
+				_update_selection_drag();
+				return;
+			}
+
+			_update_selection_drag();
+		} break;
+
+		case SELECTION_DRAG_NONE: {
+			if (node_select_mode == SELECT_MODE_LIST) {
+				break;
+			}
+
+			if (multi_shortcut_pressed) {
+				// Allow forcing box selection when an item was clicked.
+				selection_drag_state = SELECTION_DRAG_MOVE;
+				[[fallthrough]];
+			} else if (items.is_empty()) {
+				if (!selected_ci_nodes.is_empty() || !selected_3d_nodes.is_empty()) {
+					EngineDebugger::get_singleton()->send_message("remote_nothing_clicked", Array());
+				}
+
+				selection_drag_state = SELECTION_DRAG_MOVE;
+				[[fallthrough]];
+			} else {
+				break;
+			}
+		}
+
+		case SELECTION_DRAG_MOVE: {
+			if (root->is_canvas_transform_override_enabled()) {
+				selection_drag_area.position = root->get_canvas_transform_override().affine_inverse().xform(selection_position);
+			} else {
+				selection_drag_area.position = selection_position;
+			}
+
+			// Stop selection on click, so it can happen on release if the selection area doesn't pass the threshold.
+			if (multi_shortcut_pressed) {
+				return;
+			}
+		}
+	}
+
 	if (items.is_empty()) {
+		selection_position = Point2(INFINITY, INFINITY);
 		return;
 	}
+	if ((!list_shortcut_pressed && node_select_mode == SELECT_MODE_SINGLE) || items.size() == 1) {
+		selection_position = Point2(INFINITY, INFINITY);
 
-	items.sort();
+		Vector<Node *> node;
+		node.append(items[0].item);
+		_send_ids(node);
 
-	if ((!list_shortcut_pressed && 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_pressed || node_select_mode == SELECT_MODE_LIST) {
+		return;
+	}
+
+	if (list_shortcut_pressed || node_select_mode == SELECT_MODE_LIST) {
 		if (!selection_list->is_inside_tree()) {
 			root->add_child(selection_list);
 		}
@@ -1546,50 +1698,150 @@ void RuntimeNodeSelect::_click_point() {
 		// 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));
 	}
+
+	selection_position = Point2(INFINITY, INFINITY);
 }
 
-void RuntimeNodeSelect::_select_node(Node *p_node) {
-	if (p_node == selected_node) {
+void RuntimeNodeSelect::_send_ids(Vector<Node *> &p_picked_nodes, bool p_invert_new_selections) {
+	ERR_FAIL_COND(p_picked_nodes.is_empty());
+
+	Array message;
+	if (!multi_shortcut_pressed) {
+		if (p_picked_nodes.size() == 1) {
+			message.append(p_picked_nodes[0]->get_instance_id());
+			EngineDebugger::get_singleton()->send_message("remote_node_clicked", message);
+		} else {
+			TypedArray<int64_t> ids;
+			for (const Node *node : p_picked_nodes) {
+				ids.append(node->get_instance_id());
+			}
+
+			message.append(ids);
+			EngineDebugger::get_singleton()->send_message("multi_remote_nodes_clicked", message);
+		}
+
 		return;
 	}
 
-	_clear_selection();
+	TypedArray<int64_t> ids;
+	for (Node *node : p_picked_nodes) {
+		if (CanvasItem *ci = Object::cast_to<CanvasItem>(node)) {
+			if (selected_ci_nodes.has(ci)) {
+				if (p_invert_new_selections) {
+					selected_ci_nodes.erase(ci);
+				}
+			} else {
+				ids.append(ci->get_instance_id());
+			}
+		} else {
+#ifndef _3D_DISABLED
+			if (Node3D *node3d = Object::cast_to<Node3D>(node)) {
+				if (selected_3d_nodes.has(node3d)) {
+					if (p_invert_new_selections) {
+						selected_3d_nodes.erase(node3d);
+					}
+				} else {
+					ids.append(node3d->get_instance_id());
+				}
+			}
+#endif // _3D_DISABLED
+		}
+	}
 
-	CanvasItem *ci = Object::cast_to<CanvasItem>(p_node);
-	if (ci) {
-		selected_node = p_node;
+	for (const CanvasItem *ci : selected_ci_nodes) {
+		ids.append(ci->get_instance_id());
+	}
+#ifndef _3D_DISABLED
+	for (const KeyValue<Node3D *, Ref<SelectionBox3D>> &KV : selected_3d_nodes) {
+		ids.append(KV.key->get_instance_id());
+	}
+#endif // _3D_DISABLED
+
+	if (ids.is_empty()) {
+		EngineDebugger::get_singleton()->send_message("remote_nothing_clicked", message);
+	} else if (ids.size() == 1) {
+		message.append(ids[0]);
+		EngineDebugger::get_singleton()->send_message("remote_node_clicked", message);
 	} else {
+		message.append(ids);
+		EngineDebugger::get_singleton()->send_message("multi_remote_nodes_clicked", message);
+	}
+}
+
+void RuntimeNodeSelect::_set_selected_nodes(const Vector<Node *> &p_nodes) {
+	bool changed = false;
+	LocalVector<CanvasItem *> nodes_ci;
 #ifndef _3D_DISABLED
-		Node3D *node_3d = Object::cast_to<Node3D>(p_node);
-		if (node_3d) {
-			if (!node_3d->is_inside_world()) {
-				return;
+	HashMap<Node3D *, Ref<SelectionBox3D>> nodes_3d;
+#endif // _3D_DISABLED
+
+	for (Node *node : p_nodes) {
+		CanvasItem *ci = Object::cast_to<CanvasItem>(node);
+		if (ci) {
+			if (!changed || !selected_ci_nodes.has(ci)) {
+				changed = true;
 			}
 
-			selected_node = 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);
-		}
+			nodes_ci.push_back(ci);
+		} else {
+#ifndef _3D_DISABLED
+			Node3D *node_3d = Object::cast_to<Node3D>(node);
+			if (!node_3d || !node_3d->is_inside_world()) {
+				continue;
+			}
+
+			if (!changed || !selected_3d_nodes.has(node_3d)) {
+				changed = true;
+			}
+
+			if (selected_3d_nodes.has(node_3d)) {
+				// Assign an already available visual instance.
+				nodes_3d[node_3d] = selected_3d_nodes.get(node_3d);
+				continue;
+			}
+
+			Ref<SelectionBox3D> sb = Ref<SelectionBox3D>();
+			sb.instantiate();
+			nodes_3d[node_3d] = sb;
+
+			RID scenario = node_3d->get_world_3d()->get_scenario();
+
+			sb->instance = RS::get_singleton()->instance_create2(sbox_3d_mesh->get_rid(), scenario);
+			sb->instance_ofs = RS::get_singleton()->instance_create2(sbox_3d_mesh->get_rid(), scenario);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sb->instance, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sb->instance_ofs, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_ofs, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_ofs, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+
+			sb->instance_xray = RS::get_singleton()->instance_create2(sbox_3d_mesh_xray->get_rid(), scenario);
+			sb->instance_xray_ofs = RS::get_singleton()->instance_create2(sbox_3d_mesh_xray->get_rid(), scenario);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sb->instance_xray, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_cast_shadows_setting(sb->instance_xray_ofs, RS::SHADOW_CASTING_SETTING_OFF);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_xray, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_xray, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_xray_ofs, RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, true);
+			RS::get_singleton()->instance_geometry_set_flag(sb->instance_xray_ofs, RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
 #endif // _3D_DISABLED
+		}
 	}
 
-	has_selection = selected_node;
+	if (!changed && nodes_ci.size() == selected_ci_nodes.size() && nodes_3d.size() == selected_3d_nodes.size()) {
+		return;
+	}
+
+	_clear_selection();
+	selected_ci_nodes = nodes_ci;
+	has_selection = !nodes_ci.is_empty();
+
+#ifndef _3D_DISABLED
+	if (!nodes_3d.is_empty()) {
+		selected_3d_nodes = nodes_3d;
+		has_selection = true;
+	}
+#endif // _3D_DISABLED
+
 	_queue_selection_update();
 }
 
@@ -1604,17 +1856,21 @@ void RuntimeNodeSelect::_queue_selection_update() {
 }
 
 void RuntimeNodeSelect::_update_selection() {
-	if (has_selection && (!selected_node || !selected_node->is_inside_tree())) {
-		_clear_selection();
-		return;
-	}
+	Window *root = SceneTree::get_singleton()->get_root();
+
+	RS::get_singleton()->canvas_item_clear(sbox_2d_ci);
+	RS::get_singleton()->canvas_item_set_visible(sbox_2d_ci, selection_visible);
+
+	for (LocalVector<CanvasItem *>::Iterator E = selected_ci_nodes.begin(); E != selected_ci_nodes.end(); ++E) {
+		CanvasItem *ci = *E;
+		if (!ci) {
+			selected_ci_nodes.erase(ci);
+			continue;
+		}
 
-	CanvasItem *ci = Object::cast_to<CanvasItem>(selected_node);
-	if (ci) {
-		Window *root = SceneTree::get_singleton()->get_root();
 		Transform2D xform;
 		if (root->is_canvas_transform_override_enabled() && !ci->get_canvas_layer_node()) {
-			RS::get_singleton()->canvas_item_set_transform(sbox_2d_ci, (root->get_canvas_transform_override()));
+			RS::get_singleton()->canvas_item_set_transform(sbox_2d_ci, root->get_canvas_transform_override());
 			xform = ci->get_global_transform();
 		} else {
 			RS::get_singleton()->canvas_item_set_transform(sbox_2d_ci, Transform2D());
@@ -1636,30 +1892,27 @@ void RuntimeNodeSelect::_update_selection() {
 			}
 		}
 
-		RS::get_singleton()->canvas_item_set_visible(sbox_2d_ci, selection_visible);
-
-		if (xform == sbox_2d_xform && rect == sbox_2d_rect) {
-			return; // Nothing changed.
-		}
-		sbox_2d_xform = xform;
-		sbox_2d_rect = rect;
-
-		RS::get_singleton()->canvas_item_clear(sbox_2d_ci);
-
 		const Vector2 endpoints[4] = {
 			xform.xform(rect.position),
-			xform.xform(rect.position + Vector2(rect.size.x, 0)),
+			xform.xform(rect.position + Point2(rect.size.x, 0)),
 			xform.xform(rect.position + rect.size),
-			xform.xform(rect.position + Vector2(0, rect.size.y))
+			xform.xform(rect.position + Point2(0, rect.size.y))
 		};
 
 		const Color selection_color_2d = Color(1, 0.6, 0.4, 0.7);
+		int thickness = MAX(1, Math::ceil(2 / view_2d_zoom));
 		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));
+			RS::get_singleton()->canvas_item_add_line(sbox_2d_ci, endpoints[i], endpoints[(i + 1) % 4], selection_color_2d, thickness);
 		}
-	} else {
+	}
+
 #ifndef _3D_DISABLED
-		Node3D *node_3d = Object::cast_to<Node3D>(selected_node);
+	for (HashMap<Node3D *, Ref<SelectionBox3D>>::ConstIterator KV = selected_3d_nodes.begin(); KV != selected_3d_nodes.end(); ++KV) {
+		Node3D *node_3d = KV->key;
+		if (!node_3d) {
+			selected_3d_nodes.erase(node_3d);
+			continue;
+		}
 
 		// Fallback.
 		AABB bounds(Vector3(-0.5, -0.5, -0.5), Vector3(1, 1, 1));
@@ -1677,20 +1930,16 @@ void RuntimeNodeSelect::_update_selection() {
 			}
 		}
 
-		RS::get_singleton()->instance_set_visible(sbox_3d_instance, selection_visible);
-		RS::get_singleton()->instance_set_visible(sbox_3d_instance_ofs, selection_visible);
-		RS::get_singleton()->instance_set_visible(sbox_3d_instance_xray, selection_visible);
-		RS::get_singleton()->instance_set_visible(sbox_3d_instance_xray_ofs, selection_visible);
-
 		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();
 
-		if (t == sbox_3d_xform && bounds == sbox_3d_bounds) {
-			return; // Nothing changed.
+		Ref<SelectionBox3D> sb = KV->value;
+		if (t == sb->transform && bounds == sb->bounds) {
+			continue; // Nothing changed.
 		}
-		sbox_3d_xform = t;
-		sbox_3d_bounds = bounds;
+		sb->transform = t;
+		sb->bounds = bounds;
 
 		Transform3D t_offset = t;
 
@@ -1710,30 +1959,68 @@ void RuntimeNodeSelect::_update_selection() {
 			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
+		RS::get_singleton()->instance_set_visible(sb->instance, selection_visible);
+		RS::get_singleton()->instance_set_visible(sb->instance_ofs, selection_visible);
+		RS::get_singleton()->instance_set_visible(sb->instance_xray, selection_visible);
+		RS::get_singleton()->instance_set_visible(sb->instance_xray_ofs, selection_visible);
+
+		RS::get_singleton()->instance_set_transform(sb->instance, t);
+		RS::get_singleton()->instance_set_transform(sb->instance_ofs, t_offset);
+		RS::get_singleton()->instance_set_transform(sb->instance_xray, t);
+		RS::get_singleton()->instance_set_transform(sb->instance_xray_ofs, t_offset);
 	}
+#endif // _3D_DISABLED
 }
 
 void RuntimeNodeSelect::_clear_selection() {
-	selected_node = nullptr;
-	has_selection = false;
-
-	if (sbox_2d_canvas.is_valid()) {
+	selected_ci_nodes.clear();
+	if (draw_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);
-	}
+	selected_3d_nodes.clear();
 #endif // _3D_DISABLED
+
+	has_selection = false;
+}
+
+void RuntimeNodeSelect::_update_selection_drag(const Point2 p_end_pos) {
+	RS::get_singleton()->canvas_item_clear(sel_drag_ci);
+
+	if (selection_drag_state != SELECTION_DRAG_MOVE) {
+		return;
+	}
+
+	Window *root = SceneTree::get_singleton()->get_root();
+	if (root->is_canvas_transform_override_enabled()) {
+		Transform2D xform = root->get_canvas_transform_override();
+		RS::get_singleton()->canvas_item_set_transform(sel_drag_ci, xform);
+		selection_drag_area.size = xform.affine_inverse().xform(p_end_pos);
+	} else {
+		RS::get_singleton()->canvas_item_set_transform(sel_drag_ci, Transform2D());
+		selection_drag_area.size = p_end_pos;
+	}
+	selection_drag_area.size -= selection_drag_area.position;
+
+	if (selection_drag_state == SELECTION_DRAG_END) {
+		return;
+	}
+
+	const Vector2 endpoints[4] = {
+		selection_drag_area.position,
+		selection_drag_area.position + Point2(selection_drag_area.size.x, 0),
+		selection_drag_area.position + selection_drag_area.size,
+		selection_drag_area.position + Point2(0, selection_drag_area.size.y)
+	};
+
+	// Draw fill.
+	RS::get_singleton()->canvas_item_add_rect(sel_drag_ci, selection_drag_area.abs(), selection_area_fill);
+	// Draw outline.
+	int thickness = MAX(1, Math::ceil(1 / view_2d_zoom));
+	for (int i = 0; i < 4; i++) {
+		RS::get_singleton()->canvas_item_add_line(sel_drag_ci, endpoints[i], endpoints[(i + 1) % 4], selection_area_outline, thickness);
+	}
 }
 
 void RuntimeNodeSelect::_set_selection_visible(bool p_visible) {
@@ -1750,11 +2037,7 @@ void RuntimeNodeSelect::_find_canvas_items_at_pos(const Point2 &p_pos, Node *p_n
 		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()) {
@@ -1768,41 +2051,94 @@ void RuntimeNodeSelect::_find_canvas_items_at_pos(const Point2 &p_pos, Node *p_n
 		}
 	}
 
-	if (ci && ci->is_visible_in_tree()) {
-		Transform2D xform = p_canvas_xform;
-		if (!ci->is_set_as_top_level()) {
-			xform *= p_parent_xform;
+	if (!ci || !ci->is_visible_in_tree()) {
+		return;
+	}
+
+	Transform2D xform = p_canvas_xform;
+	if (!ci->is_set_as_top_level()) {
+		xform *= p_parent_xform;
+	}
+
+	Point2 pos;
+	// Cameras (overridden or not) don't affect `CanvasLayer`s.
+	if (!ci->get_canvas_layer_node()) {
+		Window *root = SceneTree::get_singleton()->get_root();
+		pos = (root->is_canvas_transform_override_enabled() ? root->get_canvas_transform_override() : root->get_canvas_transform()).affine_inverse().xform(p_pos);
+	} else {
+		pos = p_pos;
+	}
+
+	xform = (xform * ci->get_transform()).affine_inverse();
+	const real_t local_grab_distance = xform.basis_xform(Vector2(sel_2d_grab_dist, 0)).length() / view_2d_zoom;
+	if (ci->_edit_is_selected_on_click(xform.xform(pos), local_grab_distance)) {
+		SelectResult res;
+		res.item = ci;
+		res.order = ci->get_effective_z_index() + ci->get_canvas_layer();
+		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() + ci->get_canvas_layer();
+				r_items.push_back(res_col);
+			}
 		}
+	}
+}
 
-		Vector2 pos;
-		// Cameras (overridden or not) don't affect `CanvasLayer`s.
-		if (!ci->get_canvas_layer_node()) {
-			Window *root = SceneTree::get_singleton()->get_root();
-			pos = (root->is_canvas_transform_override_enabled() ? root->get_canvas_transform_override() : root->get_canvas_transform()).affine_inverse().xform(p_pos);
+// Copied and trimmed from the CanvasItemEditor implementation.
+void RuntimeNodeSelect::_find_canvas_items_at_rect(const Rect2 &p_rect, 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;
+	}
+
+	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_rect(p_rect, p_node->get_child(i), r_items, p_parent_xform * ci->get_transform(), p_canvas_xform);
+			} else {
+				_find_canvas_items_at_rect(p_rect, p_node->get_child(i), r_items, ci->get_transform(), p_canvas_xform);
+			}
 		} else {
-			pos = p_pos;
+			CanvasLayer *cl = Object::cast_to<CanvasLayer>(p_node);
+			_find_canvas_items_at_rect(p_rect, p_node->get_child(i), r_items, Transform2D(), cl ? cl->get_transform() : p_canvas_xform);
 		}
+	}
 
-		xform = (xform * ci->get_transform()).affine_inverse();
-		const real_t local_grab_distance = xform.basis_xform(Vector2(grab_distance, 0)).length() / view_2d_zoom;
-		if (ci->_edit_is_selected_on_click(xform.xform(pos), local_grab_distance)) {
-			SelectResult res;
-			res.item = ci;
-			res.order = ci->get_effective_z_index() + ci->get_canvas_layer();
-			r_items.push_back(res);
+	if (!ci || !ci->is_visible_in_tree()) {
+		return;
+	}
 
-			// 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() + ci->get_canvas_layer();
-					r_items.push_back(res_col);
-				}
-			}
+	Transform2D xform = p_canvas_xform;
+	if (!ci->is_set_as_top_level()) {
+		xform *= p_parent_xform;
+	}
+	Rect2 rect = (xform * ci->get_transform()).affine_inverse().xform(p_rect);
+
+	bool selected = false;
+	if (ci->_edit_use_rect()) {
+		Rect2 ci_rect = ci->_edit_get_rect();
+		if (rect.has_point(ci_rect.position) &&
+				rect.has_point(ci_rect.position + Vector2(ci_rect.size.x, 0)) &&
+				rect.has_point(ci_rect.position + Vector2(ci_rect.size.x, ci_rect.size.y)) &&
+				rect.has_point(ci_rect.position + Vector2(0, ci_rect.size.y))) {
+			selected = true;
 		}
+	} else if (rect.has_point(Point2())) {
+		selected = true;
+	}
+
+	if (selected) {
+		SelectResult res;
+		res.item = ci;
+		res.order = ci->get_effective_z_index() + ci->get_canvas_layer();
+		r_items.push_back(res);
 	}
 }
 
@@ -1856,17 +2192,16 @@ void RuntimeNodeSelect::_update_view_2d() {
 #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();
+	Camera3D *camera = root->get_camera_3d();
 	if (!camera) {
 		return;
 	}
 
 	Vector3 ray, pos, to;
-	if (root->get_viewport()->is_camera_3d_override_enabled()) {
-		Viewport *vp = root->get_viewport();
-		ray = vp->camera_3d_override_project_ray_normal(p_pos);
-		pos = vp->camera_3d_override_project_ray_origin(p_pos);
-		to = pos + ray * vp->get_camera_3d_override_properties()["z_far"];
+	if (root->is_camera_3d_override_enabled()) {
+		ray = root->camera_3d_override_project_ray_normal(p_pos);
+		pos = root->camera_3d_override_project_ray_origin(p_pos);
+		to = pos + ray * root->get_camera_3d_override_properties()["z_far"];
 	} else {
 		ray = camera->project_ray_normal(p_pos);
 		pos = camera->project_ray_origin(p_pos);
@@ -1955,9 +2290,184 @@ void RuntimeNodeSelect::_find_3d_items_at_pos(const Point2 &p_pos, Vector<Select
 	}
 }
 
+void RuntimeNodeSelect::_find_3d_items_at_rect(const Rect2 &p_rect, Vector<SelectResult> &r_items) {
+	Window *root = SceneTree::get_singleton()->get_root();
+	Camera3D *camera = root->get_camera_3d();
+	if (!camera) {
+		return;
+	}
+
+	bool cam_override = root->is_camera_3d_override_enabled();
+	Vector3 cam_pos;
+	Vector3 dist_pos;
+	if (cam_override) {
+		cam_pos = root->get_camera_3d_override_transform().origin;
+		dist_pos = root->camera_3d_override_project_ray_origin(p_rect.position + p_rect.size / 2);
+	} else {
+		cam_pos = camera->get_global_position();
+		dist_pos = camera->project_ray_origin(p_rect.position + p_rect.size / 2);
+	}
+
+	real_t znear, zfar = 0;
+	real_t zofs = 5.0;
+	if (cam_override) {
+		HashMap<StringName, real_t> override_props = root->get_camera_3d_override_properties();
+		znear = override_props["z_near"];
+		zfar = override_props["z_far"];
+		zofs -= znear;
+	} else {
+		znear = camera->get_near();
+		zfar = camera->get_far();
+		zofs -= znear;
+	}
+	zofs = MAX(0.0, zofs);
+
+	const Point2 pos_end = p_rect.position + p_rect.size;
+	Vector3 box[4] = {
+		Vector3(
+				MIN(p_rect.position.x, pos_end.x),
+				MIN(p_rect.position.y, pos_end.y),
+				zofs),
+		Vector3(
+				MAX(p_rect.position.x, pos_end.x),
+				MIN(p_rect.position.y, pos_end.y),
+				zofs),
+		Vector3(
+				MAX(p_rect.position.x, pos_end.x),
+				MAX(p_rect.position.y, pos_end.y),
+				zofs),
+		Vector3(
+				MIN(p_rect.position.x, pos_end.x),
+				MAX(p_rect.position.y, pos_end.y),
+				zofs)
+	};
+
+	Vector<Plane> frustum;
+	for (int i = 0; i < 4; i++) {
+		Vector3 a = _get_screen_to_space(box[i]);
+		Vector3 b = _get_screen_to_space(box[(i + 1) % 4]);
+		frustum.push_back(Plane(a, b, cam_pos));
+	}
+
+	Plane near_plane;
+	// Get the camera normal.
+	if (cam_override) {
+		near_plane = Plane(root->get_camera_3d_override_transform().basis.get_column(2), cam_pos);
+	} else {
+		near_plane = Plane(camera->get_global_transform().basis.get_column(2), cam_pos);
+	}
+	near_plane.d -= znear;
+	frustum.push_back(near_plane);
+
+	Plane far_plane = -near_plane;
+	far_plane.d += zfar;
+	frustum.push_back(far_plane);
+
+	Vector<Vector3> points = Geometry3D::compute_convex_mesh_points(&frustum[0], frustum.size());
+	Ref<ConvexPolygonShape3D> shape;
+	shape.instantiate();
+	shape->set_points(points);
+
+	// Start with physical objects.
+	PhysicsDirectSpaceState3D *ss = root->get_world_3d()->get_direct_space_state();
+	PhysicsDirectSpaceState3D::ShapeResult result;
+	PhysicsDirectSpaceState3D::ShapeParameters shape_params;
+	shape_params.shape_rid = shape->get_rid();
+	shape_params.collide_with_areas = true;
+	if (ss->intersect_shape(shape_params, &result, 32)) {
+		SelectResult res;
+		res.item = Object::cast_to<Node>(result.collider);
+		res.order = -dist_pos.distance_to(Object::cast_to<Node3D>(res.item)->get_global_transform().origin);
+
+		// 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);
+	}
+
+	// Then go for the meshes.
+	Vector<ObjectID> items = RS::get_singleton()->instances_cull_convex(frustum, 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();
+			if (mesh_collision->inside_convex_shape(frustum.ptr(), frustum.size(), points.ptr(), points.size(), gt.get_basis().get_scale())) {
+				SelectResult res;
+				res.item = Object::cast_to<Node>(obj);
+				res.order = -dist_pos.distance_to(gt.origin);
+				r_items.push_back(res);
+
+				continue;
+			}
+		}
+
+		items.remove_at(i);
+		i--;
+	}
+}
+
+Vector3 RuntimeNodeSelect::_get_screen_to_space(const Vector3 &p_vector3) {
+	Window *root = SceneTree::get_singleton()->get_root();
+	Camera3D *camera = root->get_camera_3d();
+
+	Size2 size = root->get_size();
+	real_t znear = 0;
+
+	Projection cm;
+	if (root->is_camera_3d_override_enabled()) {
+		HashMap<StringName, real_t> override_props = root->get_camera_3d_override_properties();
+		znear = override_props["z_near"];
+		cm.set_perspective(override_props["fov"], size.aspect(), znear + p_vector3.z, override_props["z_far"]);
+	} else {
+		znear = camera->get_near();
+		cm.set_perspective(camera->get_fov() * cursor.fov_scale, size.aspect(), znear + p_vector3.z, camera->get_far());
+	}
+
+	Vector2 screen_he = cm.get_viewport_half_extents();
+	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);
+
+	return camera_transform.xform(Vector3(((p_vector3.x / size.width) * 2.0 - 1.0) * screen_he.x, ((1.0 - (p_vector3.y / size.height)) * 2.0 - 1.0) * screen_he.y, -(znear + p_vector3.z)));
+}
+
 bool RuntimeNodeSelect::_handle_3d_input(const Ref<InputEvent> &p_event) {
 	Ref<InputEventMouseButton> b = p_event;
-
 	if (b.is_valid()) {
 		const real_t zoom_factor = 1.08 * b->get_factor();
 		switch (b->get_button_index()) {
@@ -1985,7 +2495,6 @@ bool RuntimeNodeSelect::_handle_3d_input(const Ref<InputEvent> &p_event) {
 	}
 
 	Ref<InputEventMouseMotion> m = p_event;
-
 	if (m.is_valid()) {
 		if (camera_freelook) {
 			_cursor_look(m);
@@ -2001,7 +2510,6 @@ bool RuntimeNodeSelect::_handle_3d_input(const Ref<InputEvent> &p_event) {
 	}
 
 	Ref<InputEventKey> k = p_event;
-
 	if (k.is_valid()) {
 		if (k->get_physical_keycode() == Key::ESCAPE) {
 			_set_camera_freelook_enabled(false);
diff --git a/scene/debugger/scene_debugger.h b/scene/debugger/scene_debugger.h
index 90c8000eb4de..c3ad18748628 100644
--- a/scene/debugger/scene_debugger.h
+++ b/scene/debugger/scene_debugger.h
@@ -34,14 +34,20 @@
 #include "core/input/shortcut.h"
 #include "core/object/ref_counted.h"
 #include "core/string/ustring.h"
+#include "core/templates/local_vector.h"
 #include "core/templates/pair.h"
 #include "core/variant/array.h"
 #include "scene/gui/view_panner.h"
+#ifndef _3D_DISABLED
 #include "scene/resources/mesh.h"
+#endif // _3D_DISABLED
 
+class CanvasItem;
 class PopupMenu;
 class Script;
-class Node;
+#ifndef _3D_DISABLED
+class Node3D;
+#endif // _3D_DISABLED
 
 class SceneDebugger {
 private:
@@ -61,8 +67,9 @@ class SceneDebugger {
 
 	static void _save_node(ObjectID id, const String &p_path);
 	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 _set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value, const String &p_field = "");
+	static void _send_object_id(ObjectID p_id);
+	static void _send_multi_object_ids(Vector<ObjectID> p_ids);
 	static void _next_frame();
 
 public:
@@ -192,18 +199,35 @@ class RuntimeNodeSelect : public Object {
 private:
 	friend class SceneDebugger;
 
+	NodeType node_select_type = NODE_TYPE_2D;
+	SelectMode node_select_mode = SELECT_MODE_SINGLE;
+
 	struct SelectResult {
 		Node *item = nullptr;
 		real_t order = 0;
 		_FORCE_INLINE_ bool operator<(const SelectResult &p_rr) const { return p_rr.order < order; }
 	};
 
+	const int SELECTION_MIN_AREA = 8 * 8;
+	enum SelectionDragState {
+		SELECTION_DRAG_NONE,
+		SELECTION_DRAG_MOVE,
+		SELECTION_DRAG_END
+	};
+	SelectionDragState selection_drag_state = SELECTION_DRAG_NONE;
+
 	bool has_selection = false;
-	Node *selected_node = nullptr;
+	Point2 selection_position = Point2(INFINITY, INFINITY);
+	Rect2 selection_drag_area;
 	PopupMenu *selection_list = nullptr;
+	Color selection_area_fill, selection_area_outline;
 	bool selection_visible = true;
 	bool selection_update_queued = false;
-	bool warped_panning = false;
+
+	bool multi_shortcut_pressed = false;
+	bool list_shortcut_pressed = false;
+	RID draw_canvas;
+	RID sel_drag_ci;
 
 	bool camera_override = false;
 
@@ -214,11 +238,12 @@ class RuntimeNodeSelect : public Object {
 	Ref<ViewPanner> panner;
 	Vector2 view_2d_offset;
 	real_t view_2d_zoom = 1.0;
+	bool warped_panning = false;
+
+	LocalVector<CanvasItem *> selected_ci_nodes;
+	real_t sel_2d_grab_dist = 0;
 
-	RID sbox_2d_canvas;
 	RID sbox_2d_ci;
-	Transform2D sbox_2d_xform;
-	Rect2 sbox_2d_rect;
 
 #ifndef _3D_DISABLED
 	struct Cursor {
@@ -242,7 +267,7 @@ class RuntimeNodeSelect : public Object {
 	const double VIEW_3D_MAX_ZOOM = 1'000'000'000'000;
 #else
 	const float VIEW_3D_MAX_ZOOM = 10'000;
-#endif
+#endif // REAL_T_IS_DOUBLE
 	const float CAMERA_ZNEAR = 0.05;
 	const float CAMERA_ZFAR = 4'000;
 
@@ -258,21 +283,34 @@ class RuntimeNodeSelect : public Object {
 
 	Vector2 previous_mouse_position;
 
+	struct SelectionBox3D : public RefCounted {
+		RID instance;
+		RID instance_ofs;
+		RID instance_xray;
+		RID instance_xray_ofs;
+
+		Transform3D transform;
+		AABB bounds;
+
+		~SelectionBox3D() {
+			if (instance.is_valid()) {
+				RS::get_singleton()->free(instance);
+				RS::get_singleton()->free(instance_ofs);
+				RS::get_singleton()->free(instance_xray);
+				RS::get_singleton()->free(instance_xray_ofs);
+			}
+		}
+	};
+	HashMap<Node3D *, Ref<SelectionBox3D>> selected_3d_nodes;
+
+	Color sbox_3d_color;
 	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;
-	Transform3D sbox_3d_xform;
-	AABB sbox_3d_bounds;
-#endif
-
-	Point2 selection_position = Point2(INFINITY, INFINITY);
-	bool list_shortcut_pressed = false;
-
-	NodeType node_select_type = NODE_TYPE_2D;
-	SelectMode node_select_mode = SELECT_MODE_SINGLE;
+	RID sbox_3d;
+	RID sbox_3d_ofs;
+	RID sbox_3d_xray;
+	RID sbox_3d_xray_ofs;
+#endif // _3D_DISABLED
 
 	void _setup(const Dictionary &p_settings);
 
@@ -288,14 +326,16 @@ class RuntimeNodeSelect : public Object {
 	void _process_frame();
 	void _physics_frame();
 
-	void _click_point();
-	void _select_node(Node *p_node);
+	void _send_ids(Vector<Node *> &p_picked_nodes, bool p_invert_new_selections = true);
+	void _set_selected_nodes(const Vector<Node *> &p_nodes);
 	void _queue_selection_update();
 	void _update_selection();
 	void _clear_selection();
+	void _update_selection_drag(const Point2 p_end_pos = Point2());
 	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 _find_canvas_items_at_rect(const Rect2 &p_rect, 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();
@@ -303,6 +343,9 @@ class RuntimeNodeSelect : public Object {
 
 #ifndef _3D_DISABLED
 	void _find_3d_items_at_pos(const Point2 &p_pos, Vector<SelectResult> &r_items);
+	void _find_3d_items_at_rect(const Rect2 &p_rect, Vector<SelectResult> &r_items);
+	Vector3 _get_screen_to_space(const Vector3 &p_vector3);
+
 	bool _handle_3d_input(const Ref<InputEvent> &p_event);
 	void _set_camera_freelook_enabled(bool p_enabled);
 	void _cursor_scale_distance(real_t p_scale);
@@ -311,7 +354,7 @@ class RuntimeNodeSelect : public Object {
 	void _cursor_orbit(Ref<InputEventWithModifiers> p_event);
 	Transform3D _get_cursor_transform();
 	void _reset_camera_3d();
-#endif
+#endif // _3D_DISABLED
 
 	RuntimeNodeSelect() { singleton = this; }
 
@@ -322,6 +365,5 @@ class RuntimeNodeSelect : public Object {
 
 	~RuntimeNodeSelect();
 };
-#endif
-
+#endif // DEBUG_ENABLED
 #endif // SCENE_DEBUGGER_H