Replace most uses of Map by HashMap

* Map is unnecessary and inefficient in almost every case.
* Replaced by the new HashMap.
* Renamed Map to RBMap and Set to RBSet for cases that still make sense
  (order matters) but use is discouraged.

There were very few cases where replacing by HashMap was undesired because
keeping the key order was intended.
I tried to keep those (as RBMap) as much as possible, but might have missed
some. Review appreciated!

110 files changed, 893 insertions, 831 deletions

diff --git a/scene/2d/area_2d.cpp b/scene/2d/area_2d.cpp
index 70b9b769cd..9699f784a2 100644
--- a/scene/2d/area_2d.cpp
+++ b/scene/2d/area_2d.cpp
@@ -137,14 +137,14 @@ void Area2D::_body_enter_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 
-	Map<ObjectID, BodyState>::Element *E = body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_tree);
+	ERR_FAIL_COND(E->value.in_tree);
 
-	E->get().in_tree = true;
+	E->value.in_tree = true;
 	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].area_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
 	}
 }
 
@@ -152,13 +152,13 @@ void Area2D::_body_exit_tree(ObjectID p_id) {
 	Object *obj = ObjectDB::get_instance(p_id);
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
-	Map<ObjectID, BodyState>::Element *E = body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_tree);
-	E->get().in_tree = false;
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
 	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].area_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
 	}
 }
 
@@ -169,7 +169,7 @@ void Area2D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, i
 	Object *obj = ObjectDB::get_instance(objid);
 	Node *node = Object::cast_to<Node>(obj);
 
-	Map<ObjectID, BodyState>::Element *E = body_map.find(objid);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(objid);
 
 	if (!body_in && !E) {
 		return; //does not exist because it was likely removed from the tree
@@ -180,36 +180,36 @@ void Area2D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, i
 	if (body_in) {
 		if (!E) {
 			E = body_map.insert(objid, BodyState());
-			E->get().rid = p_body;
-			E->get().rc = 0;
-			E->get().in_tree = node && node->is_inside_tree();
+			E->value.rid = p_body;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area2D::_body_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area2D::_body_exit_tree), make_binds(objid));
-				if (E->get().in_tree) {
+				if (E->value.in_tree) {
 					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 				}
 			}
 		}
-		E->get().rc++;
+		E->value.rc++;
 		if (node) {
-			E->get().shapes.insert(ShapePair(p_body_shape, p_area_shape));
+			E->value.shapes.insert(ShapePair(p_body_shape, p_area_shape));
 		}
 
-		if (!node || E->get().in_tree) {
+		if (!node || E->value.in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_area_shape);
 		}
 
 	} else {
-		E->get().rc--;
+		E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(ShapePair(p_body_shape, p_area_shape));
+			E->value.shapes.erase(ShapePair(p_body_shape, p_area_shape));
 		}
 
-		bool in_tree = E->get().in_tree;
-		if (E->get().rc == 0) {
-			body_map.erase(E);
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			body_map.remove(E);
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area2D::_body_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area2D::_body_exit_tree));
@@ -231,14 +231,14 @@ void Area2D::_area_enter_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 
-	Map<ObjectID, AreaState>::Element *E = area_map.find(p_id);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_tree);
+	ERR_FAIL_COND(E->value.in_tree);
 
-	E->get().in_tree = true;
+	E->value.in_tree = true;
 	emit_signal(SceneStringNames::get_singleton()->area_entered, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->area_shape_entered, E->get().rid, node, E->get().shapes[i].area_shape, E->get().shapes[i].self_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_entered, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
 	}
 }
 
@@ -246,13 +246,13 @@ void Area2D::_area_exit_tree(ObjectID p_id) {
 	Object *obj = ObjectDB::get_instance(p_id);
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
-	Map<ObjectID, AreaState>::Element *E = area_map.find(p_id);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_tree);
-	E->get().in_tree = false;
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
 	emit_signal(SceneStringNames::get_singleton()->area_exited, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E->get().rid, node, E->get().shapes[i].area_shape, E->get().shapes[i].self_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
 	}
 }
 
@@ -263,7 +263,7 @@ void Area2D::_area_inout(int p_status, const RID &p_area, ObjectID p_instance, i
 	Object *obj = ObjectDB::get_instance(objid);
 	Node *node = Object::cast_to<Node>(obj);
 
-	Map<ObjectID, AreaState>::Element *E = area_map.find(objid);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(objid);
 
 	if (!area_in && !E) {
 		return; //likely removed from the tree
@@ -273,36 +273,36 @@ void Area2D::_area_inout(int p_status, const RID &p_area, ObjectID p_instance, i
 	if (area_in) {
 		if (!E) {
 			E = area_map.insert(objid, AreaState());
-			E->get().rid = p_area;
-			E->get().rc = 0;
-			E->get().in_tree = node && node->is_inside_tree();
+			E->value.rid = p_area;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area2D::_area_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area2D::_area_exit_tree), make_binds(objid));
-				if (E->get().in_tree) {
+				if (E->value.in_tree) {
 					emit_signal(SceneStringNames::get_singleton()->area_entered, node);
 				}
 			}
 		}
-		E->get().rc++;
+		E->value.rc++;
 		if (node) {
-			E->get().shapes.insert(AreaShapePair(p_area_shape, p_self_shape));
+			E->value.shapes.insert(AreaShapePair(p_area_shape, p_self_shape));
 		}
 
-		if (!node || E->get().in_tree) {
+		if (!node || E->value.in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->area_shape_entered, p_area, node, p_area_shape, p_self_shape);
 		}
 
 	} else {
-		E->get().rc--;
+		E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(AreaShapePair(p_area_shape, p_self_shape));
+			E->value.shapes.erase(AreaShapePair(p_area_shape, p_self_shape));
 		}
 
-		bool in_tree = E->get().in_tree;
-		if (E->get().rc == 0) {
-			area_map.erase(E);
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			area_map.remove(E);
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area2D::_area_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area2D::_area_exit_tree));
@@ -323,7 +323,7 @@ void Area2D::_clear_monitoring() {
 	ERR_FAIL_COND_MSG(locked, "This function can't be used during the in/out signal.");
 
 	{
-		Map<ObjectID, BodyState> bmcopy = body_map;
+		HashMap<ObjectID, BodyState> bmcopy = body_map;
 		body_map.clear();
 		//disconnect all monitored stuff
 
@@ -351,7 +351,7 @@ void Area2D::_clear_monitoring() {
 	}
 
 	{
-		Map<ObjectID, AreaState> bmcopy = area_map;
+		HashMap<ObjectID, AreaState> bmcopy = area_map;
 		area_map.clear();
 		//disconnect all monitored stuff
 
@@ -461,20 +461,20 @@ TypedArray<Area2D> Area2D::get_overlapping_areas() const {
 
 bool Area2D::overlaps_area(Node *p_area) const {
 	ERR_FAIL_NULL_V(p_area, false);
-	const Map<ObjectID, AreaState>::Element *E = area_map.find(p_area->get_instance_id());
+	HashMap<ObjectID, AreaState>::ConstIterator E = area_map.find(p_area->get_instance_id());
 	if (!E) {
 		return false;
 	}
-	return E->get().in_tree;
+	return E->value.in_tree;
 }
 
 bool Area2D::overlaps_body(Node *p_body) const {
 	ERR_FAIL_NULL_V(p_body, false);
-	const Map<ObjectID, BodyState>::Element *E = body_map.find(p_body->get_instance_id());
+	HashMap<ObjectID, BodyState>::ConstIterator E = body_map.find(p_body->get_instance_id());
 	if (!E) {
 		return false;
 	}
-	return E->get().in_tree;
+	return E->value.in_tree;
 }
 
 void Area2D::set_audio_bus_override(bool p_override) {
diff --git a/scene/2d/area_2d.h b/scene/2d/area_2d.h
index a42e7722b0..a584420ced 100644
--- a/scene/2d/area_2d.h
+++ b/scene/2d/area_2d.h
@@ -94,7 +94,7 @@ private:
 		VSet<ShapePair> shapes;
 	};
 
-	Map<ObjectID, BodyState> body_map;
+	HashMap<ObjectID, BodyState> body_map;
 
 	void _area_inout(int p_status, const RID &p_area, ObjectID p_instance, int p_area_shape, int p_self_shape);
 
@@ -126,7 +126,7 @@ private:
 		VSet<AreaShapePair> shapes;
 	};
 
-	Map<ObjectID, AreaState> area_map;
+	HashMap<ObjectID, AreaState> area_map;
 	void _clear_monitoring();
 
 	bool audio_bus_override = false;
diff --git a/scene/2d/audio_stream_player_2d.cpp b/scene/2d/audio_stream_player_2d.cpp
index c1328badfb..624ef70468 100644
--- a/scene/2d/audio_stream_player_2d.cpp
+++ b/scene/2d/audio_stream_player_2d.cpp
@@ -148,7 +148,7 @@ void AudioStreamPlayer2D::_update_panning() {
 
 	Vector2 global_pos = get_global_position();
 
-	Set<Viewport *> viewports = world_2d->get_viewports();
+	RBSet<Viewport *> viewports = world_2d->get_viewports();
 	viewports.insert(get_viewport()); // TODO: This is a mediocre workaround for #50958. Remove when that bug is fixed!
 
 	volume_vector.resize(4);
diff --git a/scene/2d/collision_object_2d.h b/scene/2d/collision_object_2d.h
index f2b7eecc7b..997afee6c4 100644
--- a/scene/2d/collision_object_2d.h
+++ b/scene/2d/collision_object_2d.h
@@ -75,7 +75,7 @@ private:
 
 	int total_subshapes = 0;
 
-	Map<uint32_t, ShapeData> shapes;
+	RBMap<uint32_t, ShapeData> shapes;
 	bool only_update_transform_changes = false; // This is used for sync to physics.
 
 	void _apply_disabled();
diff --git a/scene/2d/navigation_region_2d.cpp b/scene/2d/navigation_region_2d.cpp
index 3cc9f3f2c4..f46453283c 100644
--- a/scene/2d/navigation_region_2d.cpp
+++ b/scene/2d/navigation_region_2d.cpp
@@ -302,19 +302,19 @@ void NavigationPolygon::make_polygons_from_outlines() {
 	polygons.clear();
 	vertices.clear();
 
-	Map<Vector2, int> points;
+	HashMap<Vector2, int> points;
 	for (List<TPPLPoly>::Element *I = out_poly.front(); I; I = I->next()) {
 		TPPLPoly &tp = I->get();
 
 		struct Polygon p;
 
 		for (int64_t i = 0; i < tp.GetNumPoints(); i++) {
-			Map<Vector2, int>::Element *E = points.find(tp[i]);
+			HashMap<Vector2, int>::Iterator E = points.find(tp[i]);
 			if (!E) {
 				E = points.insert(tp[i], vertices.size());
 				vertices.push_back(tp[i]);
 			}
-			p.indices.push_back(E->get());
+			p.indices.push_back(E->value);
 		}
 
 		polygons.push_back(p);
diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index 88f68e4142..f345d8c3c9 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -339,17 +339,17 @@ void RigidDynamicBody2D::_body_enter_tree(ObjectID p_id) {
 	ERR_FAIL_COND(!node);
 
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_scene);
+	ERR_FAIL_COND(E->value.in_scene);
 
 	contact_monitor->locked = true;
 
-	E->get().in_scene = true;
+	E->value.in_scene = true;
 	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
 	}
 
 	contact_monitor->locked = false;
@@ -360,17 +360,17 @@ void RigidDynamicBody2D::_body_exit_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_scene);
-	E->get().in_scene = false;
+	ERR_FAIL_COND(!E->value.in_scene);
+	E->value.in_scene = false;
 
 	contact_monitor->locked = true;
 
 	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
 
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
 	}
 
 	contact_monitor->locked = false;
@@ -384,45 +384,45 @@ void RigidDynamicBody2D::_body_inout(int p_status, const RID &p_body, ObjectID p
 	Node *node = Object::cast_to<Node>(obj);
 
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(objid);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(objid);
 
 	ERR_FAIL_COND(!body_in && !E);
 
 	if (body_in) {
 		if (!E) {
 			E = contact_monitor->body_map.insert(objid, BodyState());
-			E->get().rid = p_body;
-			//E->get().rc=0;
-			E->get().in_scene = node && node->is_inside_tree();
+			E->value.rid = p_body;
+			//E->value.rc=0;
+			E->value.in_scene = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody2D::_body_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody2D::_body_exit_tree), make_binds(objid));
-				if (E->get().in_scene) {
+				if (E->value.in_scene) {
 					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 				}
 			}
 
-			//E->get().rc++;
+			//E->value.rc++;
 		}
 
 		if (node) {
-			E->get().shapes.insert(ShapePair(p_body_shape, p_local_shape));
+			E->value.shapes.insert(ShapePair(p_body_shape, p_local_shape));
 		}
 
-		if (E->get().in_scene) {
+		if (E->value.in_scene) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_local_shape);
 		}
 
 	} else {
-		//E->get().rc--;
+		//E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(ShapePair(p_body_shape, p_local_shape));
+			E->value.shapes.erase(ShapePair(p_body_shape, p_local_shape));
 		}
 
-		bool in_scene = E->get().in_scene;
+		bool in_scene = E->value.in_scene;
 
-		if (E->get().shapes.is_empty()) {
+		if (E->value.shapes.is_empty()) {
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody2D::_body_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody2D::_body_exit_tree));
@@ -431,7 +431,7 @@ void RigidDynamicBody2D::_body_inout(int p_status, const RID &p_body, ObjectID p
 				}
 			}
 
-			contact_monitor->body_map.erase(E);
+			contact_monitor->body_map.remove(E);
 		}
 		if (node && in_scene) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, node, p_body_shape, p_local_shape);
@@ -494,7 +494,7 @@ void RigidDynamicBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state)
 			int local_shape = p_state->get_contact_local_shape(i);
 			int shape = p_state->get_contact_collider_shape(i);
 
-			Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(obj);
+			HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(obj);
 			if (!E) {
 				toadd[toadd_count].rid = rid;
 				toadd[toadd_count].local_shape = local_shape;
@@ -505,7 +505,7 @@ void RigidDynamicBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state)
 			}
 
 			ShapePair sp(shape, local_shape);
-			int idx = E->get().shapes.find(sp);
+			int idx = E->value.shapes.find(sp);
 			if (idx == -1) {
 				toadd[toadd_count].rid = rid;
 				toadd[toadd_count].local_shape = local_shape;
@@ -515,7 +515,7 @@ void RigidDynamicBody2D::_body_state_changed(PhysicsDirectBodyState2D *p_state)
 				continue;
 			}
 
-			E->get().shapes[idx].tagged = true;
+			E->value.shapes[idx].tagged = true;
 		}
 
 		//put the ones to remove
diff --git a/scene/2d/physics_body_2d.h b/scene/2d/physics_body_2d.h
index 1e4483b4d0..7401fc7578 100644
--- a/scene/2d/physics_body_2d.h
+++ b/scene/2d/physics_body_2d.h
@@ -200,7 +200,7 @@ private:
 
 	struct ContactMonitor {
 		bool locked = false;
-		Map<ObjectID, BodyState> body_map;
+		HashMap<ObjectID, BodyState> body_map;
 	};
 
 	ContactMonitor *contact_monitor = nullptr;
diff --git a/scene/2d/ray_cast_2d.h b/scene/2d/ray_cast_2d.h
index 2c6f2d5c00..b809bc4b8e 100644
--- a/scene/2d/ray_cast_2d.h
+++ b/scene/2d/ray_cast_2d.h
@@ -44,7 +44,7 @@ class RayCast2D : public Node2D {
 	int against_shape = 0;
 	Vector2 collision_point;
 	Vector2 collision_normal;
-	Set<RID> exclude;
+	RBSet<RID> exclude;
 	uint32_t collision_mask = 1;
 	bool exclude_parent_body = true;
 
diff --git a/scene/2d/shape_cast_2d.h b/scene/2d/shape_cast_2d.h
index 15436d6e3d..78125b08bd 100644
--- a/scene/2d/shape_cast_2d.h
+++ b/scene/2d/shape_cast_2d.h
@@ -46,7 +46,7 @@ class ShapeCast2D : public Node2D {
 	RID shape_rid;
 	Vector2 target_position = Vector2(0, 50);
 
-	Set<RID> exclude;
+	RBSet<RID> exclude;
 	real_t margin = 0.0;
 	uint32_t collision_mask = 1;
 	bool exclude_parent_body = true;
diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index cab57146b1..19c341c1e1 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -34,8 +34,8 @@
 #include "scene/resources/world_2d.h"
 #include "servers/navigation_server_2d.h"
 
-Map<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlapping_coords_and_peering_bits() const {
-	Map<Vector2i, TileSet::CellNeighbor> output;
+HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlapping_coords_and_peering_bits() const {
+	HashMap<Vector2i, TileSet::CellNeighbor> output;
 	Ref<TileSet> tile_set = tile_map->get_tileset();
 	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
 
@@ -742,7 +742,7 @@ Vector2i TileMap::_coords_to_quadrant_coords(int p_layer, const Vector2i &p_coor
 			p_coords.y > 0 ? p_coords.y / quadrant_size : (p_coords.y - (quadrant_size - 1)) / quadrant_size);
 }
 
-Map<Vector2i, TileMapQuadrant>::Element *TileMap::_create_quadrant(int p_layer, const Vector2i &p_qk) {
+HashMap<Vector2i, TileMapQuadrant>::Iterator TileMap::_create_quadrant(int p_layer, const Vector2i &p_qk) {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
 
 	TileMapQuadrant q;
@@ -765,9 +765,9 @@ Map<Vector2i, TileMapQuadrant>::Element *TileMap::_create_quadrant(int p_layer,
 	return layers[p_layer].quadrant_map.insert(p_qk, q);
 }
 
-void TileMap::_make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q) {
+void TileMap::_make_quadrant_dirty(HashMap<Vector2i, TileMapQuadrant>::Iterator Q) {
 	// Make the given quadrant dirty, then trigger an update later.
-	TileMapQuadrant &q = Q->get();
+	TileMapQuadrant &q = Q->value;
 	if (!q.dirty_list_element.in_list()) {
 		layers[q.layer].dirty_quadrant_list.add(&q.dirty_list_element);
 	}
@@ -810,7 +810,7 @@ void TileMap::_update_dirty_quadrants() {
 		for (SelfList<TileMapQuadrant> *q = dirty_quadrant_list.first(); q; q = q->next()) {
 			q->self()->map_to_world.clear();
 			q->self()->world_to_map.clear();
-			for (Set<Vector2i>::Element *E = q->self()->cells.front(); E; E = E->next()) {
+			for (RBSet<Vector2i>::Element *E = q->self()->cells.front(); E; E = E->next()) {
 				Vector2i pk = E->get();
 				Vector2i pk_world_coords = map_to_world(pk);
 				q->self()->map_to_world[pk] = pk_world_coords;
@@ -871,18 +871,18 @@ void TileMap::_recreate_layer_internals(int p_layer) {
 	_rendering_update_layer(p_layer);
 
 	// Recreate the quadrants.
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	for (const KeyValue<Vector2i, TileMapCell> &E : tile_map) {
 		Vector2i qk = _coords_to_quadrant_coords(p_layer, Vector2i(E.key.x, E.key.y));
 
-		Map<Vector2i, TileMapQuadrant>::Element *Q = layers[p_layer].quadrant_map.find(qk);
+		HashMap<Vector2i, TileMapQuadrant>::Iterator Q = layers[p_layer].quadrant_map.find(qk);
 		if (!Q) {
 			Q = _create_quadrant(p_layer, qk);
-			layers[p_layer].dirty_quadrant_list.add(&Q->get().dirty_list_element);
+			layers[p_layer].dirty_quadrant_list.add(&Q->value.dirty_list_element);
 		}
 
 		Vector2i pk = E.key;
-		Q->get().cells.insert(pk);
+		Q->value.cells.insert(pk);
 
 		_make_quadrant_dirty(Q);
 	}
@@ -896,9 +896,9 @@ void TileMap::_recreate_internals() {
 	}
 }
 
-void TileMap::_erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q) {
+void TileMap::_erase_quadrant(HashMap<Vector2i, TileMapQuadrant>::Iterator Q) {
 	// Remove a quadrant.
-	TileMapQuadrant *q = &(Q->get());
+	TileMapQuadrant *q = &(Q->value);
 
 	// Call the cleanup_quadrant method on plugins.
 	if (tile_set.is_valid()) {
@@ -917,7 +917,7 @@ void TileMap::_erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q) {
 	RenderingServer *rs = RenderingServer::get_singleton();
 	rs->free(q->debug_canvas_item);
 
-	layers[q->layer].quadrant_map.erase(Q);
+	layers[q->layer].quadrant_map.remove(Q);
 	rect_cache_dirty = true;
 }
 
@@ -926,7 +926,7 @@ void TileMap::_clear_layer_internals(int p_layer) {
 
 	// Clear quadrants.
 	while (layers[p_layer].quadrant_map.size()) {
-		_erase_quadrant(layers[p_layer].quadrant_map.front());
+		_erase_quadrant(layers[p_layer].quadrant_map.begin());
 	}
 
 	// Clear the layers internals.
@@ -954,15 +954,17 @@ void TileMap::_recompute_rect_cache() {
 	}
 
 	Rect2 r_total;
+	bool first = true;
 	for (unsigned int layer = 0; layer < layers.size(); layer++) {
-		for (const Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+		for (const KeyValue<Vector2i, TileMapQuadrant> &E : layers[layer].quadrant_map) {
 			Rect2 r;
-			r.position = map_to_world(E->key() * get_effective_quadrant_size(layer));
-			r.expand_to(map_to_world((E->key() + Vector2i(1, 0)) * get_effective_quadrant_size(layer)));
-			r.expand_to(map_to_world((E->key() + Vector2i(1, 1)) * get_effective_quadrant_size(layer)));
-			r.expand_to(map_to_world((E->key() + Vector2i(0, 1)) * get_effective_quadrant_size(layer)));
-			if (E == layers[layer].quadrant_map.front()) {
+			r.position = map_to_world(E.key * get_effective_quadrant_size(layer));
+			r.expand_to(map_to_world((E.key + Vector2i(1, 0)) * get_effective_quadrant_size(layer)));
+			r.expand_to(map_to_world((E.key + Vector2i(1, 1)) * get_effective_quadrant_size(layer)));
+			r.expand_to(map_to_world((E.key + Vector2i(0, 1)) * get_effective_quadrant_size(layer)));
+			if (first) {
 				r_total = r;
+				first = false;
 			} else {
 				r_total = r_total.merge(r);
 			}
@@ -1201,7 +1203,7 @@ void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 
 		for (int layer = 0; layer < (int)layers.size(); layer++) {
 			// Sort the quadrants coords per world coordinates
-			Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator> world_to_map;
+			RBMap<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator> world_to_map;
 			for (const KeyValue<Vector2i, TileMapQuadrant> &E : layers[layer].quadrant_map) {
 				world_to_map[map_to_world(E.key)] = E.key;
 			}
@@ -1248,7 +1250,7 @@ void TileMap::_rendering_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
 	// Draw a placeholder for scenes needing one.
 	RenderingServer *rs = RenderingServer::get_singleton();
 	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
-	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+	for (RBSet<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
 		const TileMapCell &c = get_cell(p_quadrant->layer, E_cell->get(), true);
 
 		TileSetSource *source;
@@ -1462,7 +1464,7 @@ void TileMap::_physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r
 		q.bodies.clear();
 
 		// Recreate bodies and shapes.
-		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+		for (RBSet<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
 			TileMapCell c = get_cell(q.layer, E_cell->get(), true);
 
 			TileSetSource *source;
@@ -1659,7 +1661,7 @@ void TileMap::_navigation_update_dirty_quadrants(SelfList<TileMapQuadrant>::List
 		q.navigation_regions.clear();
 
 		// Get the navigation polygons and create regions.
-		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+		for (RBSet<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
 			TileMapCell c = get_cell(q.layer, E_cell->get(), true);
 
 			TileSetSource *source;
@@ -1748,7 +1750,7 @@ void TileMap::_navigation_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
 
 	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
 
-	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+	for (RBSet<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
 		TileMapCell c = get_cell(p_quadrant->layer, E_cell->get(), true);
 
 		TileSetSource *source;
@@ -1823,7 +1825,7 @@ void TileMap::_scenes_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_
 		q.scenes.clear();
 
 		// Recreate the scenes.
-		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+		for (RBSet<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
 			const TileMapCell &c = get_cell(q.layer, E_cell->get(), true);
 
 			TileSetSource *source;
@@ -1881,7 +1883,7 @@ void TileMap::_scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
 	// Draw a placeholder for scenes needing one.
 	RenderingServer *rs = RenderingServer::get_singleton();
 	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
-	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+	for (RBSet<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
 		const TileMapCell &c = get_cell(p_quadrant->layer, E_cell->get(), true);
 
 		TileSetSource *source;
@@ -1923,9 +1925,9 @@ void TileMap::set_cell(int p_layer, const Vector2i &p_coords, int p_source_id, c
 	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 
 	// Set the current cell tile (using integer position).
-	Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	Vector2i pk(p_coords);
-	Map<Vector2i, TileMapCell>::Element *E = tile_map.find(pk);
+	HashMap<Vector2i, TileMapCell>::Iterator E = tile_map.find(pk);
 
 	int source_id = p_source_id;
 	Vector2i atlas_coords = p_atlas_coords;
@@ -1946,7 +1948,7 @@ void TileMap::set_cell(int p_layer, const Vector2i &p_coords, int p_source_id, c
 	// Get the quadrant
 	Vector2i qk = _coords_to_quadrant_coords(p_layer, pk);
 
-	Map<Vector2i, TileMapQuadrant>::Element *Q = layers[p_layer].quadrant_map.find(qk);
+	HashMap<Vector2i, TileMapQuadrant>::Iterator Q = layers[p_layer].quadrant_map.find(qk);
 
 	if (source_id == TileSet::INVALID_SOURCE) {
 		// Erase existing cell in the tile map.
@@ -1954,7 +1956,7 @@ void TileMap::set_cell(int p_layer, const Vector2i &p_coords, int p_source_id, c
 
 		// Erase existing cell in the quadrant.
 		ERR_FAIL_COND(!Q);
-		TileMapQuadrant &q = Q->get();
+		TileMapQuadrant &q = Q->value;
 
 		q.cells.erase(pk);
 
@@ -1975,18 +1977,18 @@ void TileMap::set_cell(int p_layer, const Vector2i &p_coords, int p_source_id, c
 			if (!Q) {
 				Q = _create_quadrant(p_layer, qk);
 			}
-			TileMapQuadrant &q = Q->get();
+			TileMapQuadrant &q = Q->value;
 			q.cells.insert(pk);
 
 		} else {
 			ERR_FAIL_COND(!Q); // TileMapQuadrant should exist...
 
-			if (E->get().source_id == source_id && E->get().get_atlas_coords() == atlas_coords && E->get().alternative_tile == alternative_tile) {
+			if (E->value.source_id == source_id && E->value.get_atlas_coords() == atlas_coords && E->value.alternative_tile == alternative_tile) {
 				return; // Nothing changed.
 			}
 		}
 
-		TileMapCell &c = E->get();
+		TileMapCell &c = E->value;
 
 		c.source_id = source_id;
 		c.set_atlas_coords(atlas_coords);
@@ -2005,57 +2007,57 @@ int TileMap::get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_us
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSet::INVALID_SOURCE);
 
 	// Get a cell source id from position
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
-	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	HashMap<Vector2i, TileMapCell>::ConstIterator E = tile_map.find(p_coords);
 
 	if (!E) {
 		return TileSet::INVALID_SOURCE;
 	}
 
 	if (p_use_proxies && tile_set.is_valid()) {
-		Array proxyed = tile_set->map_tile_proxy(E->get().source_id, E->get().get_atlas_coords(), E->get().alternative_tile);
+		Array proxyed = tile_set->map_tile_proxy(E->value.source_id, E->value.get_atlas_coords(), E->value.alternative_tile);
 		return proxyed[0];
 	}
 
-	return E->get().source_id;
+	return E->value.source_id;
 }
 
 Vector2i TileMap::get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetSource::INVALID_ATLAS_COORDS);
 
 	// Get a cell source id from position
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
-	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	HashMap<Vector2i, TileMapCell>::ConstIterator E = tile_map.find(p_coords);
 
 	if (!E) {
 		return TileSetSource::INVALID_ATLAS_COORDS;
 	}
 
 	if (p_use_proxies && tile_set.is_valid()) {
-		Array proxyed = tile_set->map_tile_proxy(E->get().source_id, E->get().get_atlas_coords(), E->get().alternative_tile);
+		Array proxyed = tile_set->map_tile_proxy(E->value.source_id, E->value.get_atlas_coords(), E->value.alternative_tile);
 		return proxyed[1];
 	}
 
-	return E->get().get_atlas_coords();
+	return E->value.get_atlas_coords();
 }
 
 int TileMap::get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetSource::INVALID_TILE_ALTERNATIVE);
 
 	// Get a cell source id from position
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
-	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	HashMap<Vector2i, TileMapCell>::ConstIterator E = tile_map.find(p_coords);
 
 	if (!E) {
 		return TileSetSource::INVALID_TILE_ALTERNATIVE;
 	}
 
 	if (p_use_proxies && tile_set.is_valid()) {
-		Array proxyed = tile_set->map_tile_proxy(E->get().source_id, E->get().get_atlas_coords(), E->get().alternative_tile);
+		Array proxyed = tile_set->map_tile_proxy(E->value.source_id, E->value.get_atlas_coords(), E->value.alternative_tile);
 		return proxyed[2];
 	}
 
-	return E->get().alternative_tile;
+	return E->value.alternative_tile;
 }
 
 Ref<TileMapPattern> TileMap::get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array) {
@@ -2147,13 +2149,13 @@ void TileMap::set_pattern(int p_layer, Vector2i p_position, const Ref<TileMapPat
 	}
 }
 
-Set<TileSet::TerrainsPattern> TileMap::_get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, Set<TerrainConstraint> p_constraints) {
+RBSet<TileSet::TerrainsPattern> TileMap::_get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints) {
 	if (!tile_set.is_valid()) {
-		return Set<TileSet::TerrainsPattern>();
+		return RBSet<TileSet::TerrainsPattern>();
 	}
 
 	// Returns all tiles compatible with the given constraints.
-	Set<TileSet::TerrainsPattern> compatible_terrain_tile_patterns;
+	RBSet<TileSet::TerrainsPattern> compatible_terrain_tile_patterns;
 	for (TileSet::TerrainsPattern &terrain_pattern : tile_set->get_terrains_pattern_set(p_terrain_set)) {
 		int valid = true;
 		for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
@@ -2161,7 +2163,7 @@ Set<TileSet::TerrainsPattern> TileMap::_get_valid_terrains_patterns_for_constrai
 			if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, bit)) {
 				// Check if the bit is compatible with the constraints.
 				TerrainConstraint terrain_bit_constraint = TerrainConstraint(this, p_position, bit, terrain_pattern.get_terrain(bit));
-				Set<TerrainConstraint>::Element *in_set_constraint_element = p_constraints.find(terrain_bit_constraint);
+				RBSet<TerrainConstraint>::Element *in_set_constraint_element = p_constraints.find(terrain_bit_constraint);
 				if (in_set_constraint_element && in_set_constraint_element->get().get_terrain() != terrain_bit_constraint.get_terrain()) {
 					valid = false;
 					break;
@@ -2177,17 +2179,17 @@ Set<TileSet::TerrainsPattern> TileMap::_get_valid_terrains_patterns_for_constrai
 	return compatible_terrain_tile_patterns;
 }
 
-Set<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_cells_list(int p_layer, const Set<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains) const {
+RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_cells_list(int p_layer, const RBSet<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains) const {
 	if (!tile_set.is_valid()) {
-		return Set<TerrainConstraint>();
+		return RBSet<TerrainConstraint>();
 	}
 
-	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), Set<TerrainConstraint>());
-	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), Set<TerrainConstraint>());
+	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), RBSet<TerrainConstraint>());
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), RBSet<TerrainConstraint>());
 
 	// Build a set of dummy constraints get the constrained points.
-	Set<TerrainConstraint> dummy_constraints;
-	for (Set<Vector2i>::Element *E = p_to_replace.front(); E; E = E->next()) {
+	RBSet<TerrainConstraint> dummy_constraints;
+	for (RBSet<Vector2i>::Element *E = p_to_replace.front(); E; E = E->next()) {
 		for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) { // Iterates over sides.
 			TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
 			if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, bit)) {
@@ -2197,14 +2199,14 @@ Set<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_ce
 	}
 
 	// For each constrained point, we get all overlapping tiles, and select the most adequate terrain for it.
-	Set<TerrainConstraint> constraints;
-	for (Set<TerrainConstraint>::Element *E = dummy_constraints.front(); E; E = E->next()) {
+	RBSet<TerrainConstraint> constraints;
+	for (RBSet<TerrainConstraint>::Element *E = dummy_constraints.front(); E; E = E->next()) {
 		TerrainConstraint c = E->get();
 
-		Map<int, int> terrain_count;
+		HashMap<int, int> terrain_count;
 
 		// Count the number of occurrences per terrain.
-		Map<Vector2i, TileSet::CellNeighbor> overlapping_terrain_bits = c.get_overlapping_coords_and_peering_bits();
+		HashMap<Vector2i, TileSet::CellNeighbor> overlapping_terrain_bits = c.get_overlapping_coords_and_peering_bits();
 		for (const KeyValue<Vector2i, TileSet::CellNeighbor> &E_overlapping : overlapping_terrain_bits) {
 			if (!p_to_replace.has(E_overlapping.key)) {
 				TileData *neighbor_tile_data = nullptr;
@@ -2250,13 +2252,13 @@ Set<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_ce
 	return constraints;
 }
 
-Set<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const {
+RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const {
 	if (!tile_set.is_valid()) {
-		return Set<TerrainConstraint>();
+		return RBSet<TerrainConstraint>();
 	}
 
 	// Compute the constraints needed from the surrounding tiles.
-	Set<TerrainConstraint> output;
+	RBSet<TerrainConstraint> output;
 	for (uint32_t i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 		TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
 		if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, side)) {
@@ -2268,35 +2270,35 @@ Set<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_added_tile
 	return output;
 }
 
-Map<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(const Set<Vector2i> &p_to_replace, int p_terrain_set, const Set<TerrainConstraint> p_constraints) {
+HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(const RBSet<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints) {
 	if (!tile_set.is_valid()) {
-		return Map<Vector2i, TileSet::TerrainsPattern>();
+		return HashMap<Vector2i, TileSet::TerrainsPattern>();
 	}
 
 	// Copy the constraints set.
-	Set<TerrainConstraint> constraints = p_constraints;
+	RBSet<TerrainConstraint> constraints = p_constraints;
 
 	// Compute all acceptable patterns for each cell.
-	Map<Vector2i, Set<TileSet::TerrainsPattern>> per_cell_acceptable_tiles;
+	HashMap<Vector2i, RBSet<TileSet::TerrainsPattern>> per_cell_acceptable_tiles;
 	for (Vector2i cell : p_to_replace) {
 		per_cell_acceptable_tiles[cell] = _get_valid_terrains_patterns_for_constraints(p_terrain_set, cell, constraints);
 	}
 
 	// Output map.
-	Map<Vector2i, TileSet::TerrainsPattern> output;
+	HashMap<Vector2i, TileSet::TerrainsPattern> output;
 
 	// Add all positions to a set.
-	Set<Vector2i> to_replace = Set<Vector2i>(p_to_replace);
+	RBSet<Vector2i> to_replace = RBSet<Vector2i>(p_to_replace);
 	while (!to_replace.is_empty()) {
 		// Compute the minimum number of tile possibilities for each cell.
 		int min_nb_possibilities = 100000000;
-		for (const KeyValue<Vector2i, Set<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
+		for (const KeyValue<Vector2i, RBSet<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
 			min_nb_possibilities = MIN(min_nb_possibilities, E.value.size());
 		}
 
 		// Get the set of possible cells to fill, out of the most constrained ones.
 		LocalVector<Vector2i> to_choose_from;
-		for (const KeyValue<Vector2i, Set<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
+		for (const KeyValue<Vector2i, RBSet<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
 			if (E.value.size() == min_nb_possibilities) {
 				to_choose_from.push_back(E.key);
 			}
@@ -2306,7 +2308,7 @@ Map<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(
 		Vector2i selected_cell_to_replace = to_choose_from[Math::random(0, to_choose_from.size() - 1)];
 
 		// Get the list of acceptable patterns for the given cell.
-		Set<TileSet::TerrainsPattern> valid_tiles = per_cell_acceptable_tiles[selected_cell_to_replace];
+		RBSet<TileSet::TerrainsPattern> valid_tiles = per_cell_acceptable_tiles[selected_cell_to_replace];
 		if (valid_tiles.is_empty()) {
 			break; // No possibilities :/
 		}
@@ -2317,7 +2319,7 @@ Map<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(
 		LocalVector<int> terrains_counts;
 		int pattern_index = 0;
 		for (const TileSet::TerrainsPattern &pattern : valid_tiles) {
-			Set<int> terrains;
+			RBSet<int> terrains;
 			for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 				TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
 				if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, side)) {
@@ -2345,8 +2347,8 @@ Map<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(
 		per_cell_acceptable_tiles.erase(selected_cell_to_replace);
 
 		// Add the new constraints from the added tiles.
-		Set<TerrainConstraint> new_constraints = get_terrain_constraints_from_added_tile(selected_cell_to_replace, p_terrain_set, selected_terrain_tile_pattern);
-		for (Set<TerrainConstraint>::Element *E_constraint = new_constraints.front(); E_constraint; E_constraint = E_constraint->next()) {
+		RBSet<TerrainConstraint> new_constraints = get_terrain_constraints_from_added_tile(selected_cell_to_replace, p_terrain_set, selected_terrain_tile_pattern);
+		for (RBSet<TerrainConstraint>::Element *E_constraint = new_constraints.front(); E_constraint; E_constraint = E_constraint->next()) {
 			constraints.insert(E_constraint->get());
 		}
 
@@ -2369,14 +2371,14 @@ void TileMap::set_cells_from_surrounding_terrains(int p_layer, TypedArray<Vector
 	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 	ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count());
 
-	Set<Vector2i> coords_set;
+	RBSet<Vector2i> coords_set;
 	for (int i = 0; i < p_coords_array.size(); i++) {
 		coords_set.insert(p_coords_array[i]);
 	}
 
-	Set<TileMap::TerrainConstraint> constraints = get_terrain_constraints_from_removed_cells_list(p_layer, coords_set, p_terrain_set, p_ignore_empty_terrains);
+	RBSet<TileMap::TerrainConstraint> constraints = get_terrain_constraints_from_removed_cells_list(p_layer, coords_set, p_terrain_set, p_ignore_empty_terrains);
 
-	Map<Vector2i, TileSet::TerrainsPattern> wfc_output = terrain_wave_function_collapse(coords_set, p_terrain_set, constraints);
+	HashMap<Vector2i, TileSet::TerrainsPattern> wfc_output = terrain_wave_function_collapse(coords_set, p_terrain_set, constraints);
 	for (const KeyValue<Vector2i, TileSet::TerrainsPattern> &kv : wfc_output) {
 		TileMapCell cell = tile_set->get_random_tile_from_terrains_pattern(p_terrain_set, kv.value);
 		set_cell(p_layer, kv.key, cell.source_id, cell.get_atlas_coords(), cell.alternative_tile);
@@ -2385,11 +2387,11 @@ void TileMap::set_cells_from_surrounding_terrains(int p_layer, TypedArray<Vector
 
 TileMapCell TileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileMapCell());
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	if (!tile_map.has(p_coords)) {
 		return TileMapCell();
 	} else {
-		TileMapCell c = tile_map.find(p_coords)->get();
+		TileMapCell c = tile_map.find(p_coords)->value;
 		if (p_use_proxies && tile_set.is_valid()) {
 			Array proxyed = tile_set->map_tile_proxy(c.source_id, c.get_atlas_coords(), c.alternative_tile);
 			c.source_id = proxyed[0];
@@ -2400,7 +2402,7 @@ TileMapCell TileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_
 	}
 }
 
-Map<Vector2i, TileMapQuadrant> *TileMap::get_quadrant_map(int p_layer) {
+HashMap<Vector2i, TileMapQuadrant> *TileMap::get_quadrant_map(int p_layer) {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
 
 	return &layers[p_layer].quadrant_map;
@@ -2415,15 +2417,15 @@ void TileMap::fix_invalid_tiles() {
 	ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot fix invalid tiles if Tileset is not open.");
 
 	for (unsigned int i = 0; i < layers.size(); i++) {
-		const Map<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
-		Set<Vector2i> coords;
+		const HashMap<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
+		RBSet<Vector2i> coords;
 		for (const KeyValue<Vector2i, TileMapCell> &E : tile_map) {
 			TileSetSource *source = *tile_set->get_source(E.value.source_id);
 			if (!source || !source->has_tile(E.value.get_atlas_coords()) || !source->has_alternative_tile(E.value.get_atlas_coords(), E.value.alternative_tile)) {
 				coords.insert(E.key);
 			}
 		}
-		for (Set<Vector2i>::Element *E = coords.front(); E; E = E->next()) {
+		for (RBSet<Vector2i>::Element *E = coords.front(); E; E = E->next()) {
 			set_cell(i, E->get(), TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE);
 		}
 	}
@@ -2546,7 +2548,7 @@ Vector<int> TileMap::_get_tile_data(int p_layer) const {
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), Vector<int>());
 
 	// Export tile data to raw format
-	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
+	const HashMap<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	Vector<int> data;
 	data.resize(tile_map.size() * 3);
 	int *w = data.ptrw();
@@ -3375,10 +3377,10 @@ Rect2 TileMap::get_used_rect() { // Not const because of cache
 		used_rect_cache = Rect2i();
 
 		for (unsigned int i = 0; i < layers.size(); i++) {
-			const Map<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
+			const HashMap<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
 			if (tile_map.size() > 0) {
 				if (first) {
-					used_rect_cache = Rect2i(tile_map.front()->key().x, tile_map.front()->key().y, 0, 0);
+					used_rect_cache = Rect2i(tile_map.begin()->key.x, tile_map.begin()->key.y, 0, 0);
 					first = false;
 				}
 
@@ -3448,8 +3450,8 @@ void TileMap::set_texture_filter(TextureFilter p_texture_filter) {
 	// Set a default texture filter for the whole tilemap
 	CanvasItem::set_texture_filter(p_texture_filter);
 	for (unsigned int layer = 0; layer < layers.size(); layer++) {
-		for (Map<Vector2i, TileMapQuadrant>::Element *F = layers[layer].quadrant_map.front(); F; F = F->next()) {
-			TileMapQuadrant &q = F->get();
+		for (HashMap<Vector2i, TileMapQuadrant>::Iterator F = layers[layer].quadrant_map.begin(); F; ++F) {
+			TileMapQuadrant &q = F->value;
 			for (const RID &ci : q.canvas_items) {
 				RenderingServer::get_singleton()->canvas_item_set_default_texture_filter(ci, RS::CanvasItemTextureFilter(p_texture_filter));
 				_make_quadrant_dirty(F);
@@ -3463,8 +3465,8 @@ void TileMap::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) {
 	// Set a default texture repeat for the whole tilemap
 	CanvasItem::set_texture_repeat(p_texture_repeat);
 	for (unsigned int layer = 0; layer < layers.size(); layer++) {
-		for (Map<Vector2i, TileMapQuadrant>::Element *F = layers[layer].quadrant_map.front(); F; F = F->next()) {
-			TileMapQuadrant &q = F->get();
+		for (HashMap<Vector2i, TileMapQuadrant>::Iterator F = layers[layer].quadrant_map.begin(); F; ++F) {
+			TileMapQuadrant &q = F->value;
 			for (const RID &ci : q.canvas_items) {
 				RenderingServer::get_singleton()->canvas_item_set_default_texture_repeat(ci, RS::CanvasItemTextureRepeat(p_texture_repeat));
 				_make_quadrant_dirty(F);
@@ -3512,7 +3514,7 @@ TypedArray<Vector2i> TileMap::get_surrounding_tiles(Vector2i coords) {
 	return around;
 }
 
-void TileMap::draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Color p_color, Transform2D p_transform) {
+void TileMap::draw_cells_outline(Control *p_control, RBSet<Vector2i> p_cells, Color p_color, Transform2D p_transform) {
 	if (!tile_set.is_valid()) {
 		return;
 	}
@@ -3522,7 +3524,7 @@ void TileMap::draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Colo
 	Vector<Vector2> polygon = tile_set->get_tile_shape_polygon();
 	TileSet::TileShape shape = tile_set->get_tile_shape();
 
-	for (Set<Vector2i>::Element *E = p_cells.front(); E; E = E->next()) {
+	for (RBSet<Vector2i>::Element *E = p_cells.front(); E; E = E->next()) {
 		Vector2 center = map_to_world(E->get());
 
 #define DRAW_SIDE_IF_NEEDED(side, polygon_index_from, polygon_index_to)                     \
@@ -3576,7 +3578,7 @@ TypedArray<String> TileMap::get_configuration_warnings() const {
 	TypedArray<String> warnings = Node::get_configuration_warnings();
 
 	// Retrieve the set of Z index values with a Y-sorted layer.
-	Set<int> y_sorted_z_index;
+	RBSet<int> y_sorted_z_index;
 	for (int layer = 0; layer < (int)layers.size(); layer++) {
 		if (layers[layer].y_sort_enabled) {
 			y_sorted_z_index.insert(layers[layer].z_index);
diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h
index a0655dea2a..02a2b3a1c6 100644
--- a/scene/2d/tile_map.h
+++ b/scene/2d/tile_map.h
@@ -57,11 +57,11 @@ struct TileMapQuadrant {
 	Vector2i coords;
 
 	// TileMapCells
-	Set<Vector2i> cells;
+	RBSet<Vector2i> cells;
 	// We need those two maps to sort by world position for rendering
 	// This is kind of workaround, it would be better to sort the cells directly in the "cells" set instead.
-	Map<Vector2i, Vector2i> map_to_world;
-	Map<Vector2i, Vector2i, CoordsWorldComparator> world_to_map;
+	RBMap<Vector2i, Vector2i> map_to_world;
+	RBMap<Vector2i, Vector2i, CoordsWorldComparator> world_to_map;
 
 	// Debug.
 	RID debug_canvas_item;
@@ -74,13 +74,13 @@ struct TileMapQuadrant {
 	List<RID> bodies;
 
 	// Navigation.
-	Map<Vector2i, Vector<RID>> navigation_regions;
+	HashMap<Vector2i, Vector<RID>> navigation_regions;
 
 	// Scenes.
-	Map<Vector2i, String> scenes;
+	HashMap<Vector2i, String> scenes;
 
 	// Runtime TileData cache.
-	Map<Vector2i, TileData *> runtime_tile_data_cache;
+	HashMap<Vector2i, TileData *> runtime_tile_data_cache;
 
 	void operator=(const TileMapQuadrant &q) {
 		layer = q.layer;
@@ -135,7 +135,7 @@ public:
 			return base_cell_coords;
 		}
 
-		Map<Vector2i, TileSet::CellNeighbor> get_overlapping_coords_and_peering_bits() const;
+		HashMap<Vector2i, TileSet::CellNeighbor> get_overlapping_coords_and_peering_bits() const;
 
 		void set_terrain(int p_terrain) {
 			terrain = p_terrain;
@@ -193,22 +193,22 @@ private:
 		int y_sort_origin = 0;
 		int z_index = 0;
 		RID canvas_item;
-		Map<Vector2i, TileMapCell> tile_map;
-		Map<Vector2i, TileMapQuadrant> quadrant_map;
+		HashMap<Vector2i, TileMapCell> tile_map;
+		HashMap<Vector2i, TileMapQuadrant> quadrant_map;
 		SelfList<TileMapQuadrant>::List dirty_quadrant_list;
 	};
 	LocalVector<TileMapLayer> layers;
 	int selected_layer = -1;
 
 	// Mapping for RID to coords.
-	Map<RID, Vector2i> bodies_coords;
+	HashMap<RID, Vector2i> bodies_coords;
 
 	// Quadrants and internals management.
 	Vector2i _coords_to_quadrant_coords(int p_layer, const Vector2i &p_coords) const;
 
-	Map<Vector2i, TileMapQuadrant>::Element *_create_quadrant(int p_layer, const Vector2i &p_qk);
+	HashMap<Vector2i, TileMapQuadrant>::Iterator _create_quadrant(int p_layer, const Vector2i &p_qk);
 
-	void _make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q);
+	void _make_quadrant_dirty(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
 	void _make_all_quadrants_dirty();
 	void _queue_update_dirty_quadrants();
 
@@ -217,7 +217,7 @@ private:
 	void _recreate_layer_internals(int p_layer);
 	void _recreate_internals();
 
-	void _erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q);
+	void _erase_quadrant(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
 	void _clear_layer_internals(int p_layer);
 	void _clear_internals();
 
@@ -251,7 +251,7 @@ private:
 	void _scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
 
 	// Terrains.
-	Set<TileSet::TerrainsPattern> _get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, Set<TerrainConstraint> p_constraints);
+	RBSet<TileSet::TerrainsPattern> _get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints);
 
 	// Set and get tiles from data arrays.
 	void _set_tile_data(int p_layer, const Vector<int> &p_data);
@@ -333,14 +333,14 @@ public:
 	void set_pattern(int p_layer, Vector2i p_position, const Ref<TileMapPattern> p_pattern);
 
 	// Terrains.
-	Set<TerrainConstraint> get_terrain_constraints_from_removed_cells_list(int p_layer, const Set<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains = true) const; // Not exposed.
-	Set<TerrainConstraint> get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const; // Not exposed.
-	Map<Vector2i, TileSet::TerrainsPattern> terrain_wave_function_collapse(const Set<Vector2i> &p_to_replace, int p_terrain_set, const Set<TerrainConstraint> p_constraints); // Not exposed.
+	RBSet<TerrainConstraint> get_terrain_constraints_from_removed_cells_list(int p_layer, const RBSet<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains = true) const; // Not exposed.
+	RBSet<TerrainConstraint> get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const; // Not exposed.
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_wave_function_collapse(const RBSet<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints); // Not exposed.
 	void set_cells_from_surrounding_terrains(int p_layer, TypedArray<Vector2i> p_coords_array, int p_terrain_set, bool p_ignore_empty_terrains = true);
 
 	// Not exposed to users
 	TileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
-	Map<Vector2i, TileMapQuadrant> *get_quadrant_map(int p_layer);
+	HashMap<Vector2i, TileMapQuadrant> *get_quadrant_map(int p_layer);
 	int get_effective_quadrant_size(int p_layer) const;
 	//---
 
@@ -377,7 +377,7 @@ public:
 
 	// Helpers?
 	TypedArray<Vector2i> get_surrounding_tiles(Vector2i coords);
-	void draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Color p_color, Transform2D p_transform = Transform2D());
+	void draw_cells_outline(Control *p_control, RBSet<Vector2i> p_cells, Color p_color, Transform2D p_transform = Transform2D());
 
 	// Virtual function to modify the TileData at runtime
 	GDVIRTUAL2R(bool, _use_tile_data_runtime_update, int, Vector2i);
diff --git a/scene/2d/visible_on_screen_notifier_2d.h b/scene/2d/visible_on_screen_notifier_2d.h
index e0d580f174..3165eb92df 100644
--- a/scene/2d/visible_on_screen_notifier_2d.h
+++ b/scene/2d/visible_on_screen_notifier_2d.h
@@ -37,7 +37,7 @@ class Viewport;
 class VisibleOnScreenNotifier2D : public Node2D {
 	GDCLASS(VisibleOnScreenNotifier2D, Node2D);
 
-	Set<Viewport *> viewports;
+	RBSet<Viewport *> viewports;
 
 	Rect2 rect;
 
diff --git a/scene/3d/area_3d.cpp b/scene/3d/area_3d.cpp
index fb37e64a1a..54737e13b3 100644
--- a/scene/3d/area_3d.cpp
+++ b/scene/3d/area_3d.cpp
@@ -192,14 +192,14 @@ void Area3D::_body_enter_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 
-	Map<ObjectID, BodyState>::Element *E = body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_tree);
+	ERR_FAIL_COND(E->value.in_tree);
 
-	E->get().in_tree = true;
+	E->value.in_tree = true;
 	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].area_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
 	}
 }
 
@@ -207,13 +207,13 @@ void Area3D::_body_exit_tree(ObjectID p_id) {
 	Object *obj = ObjectDB::get_instance(p_id);
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
-	Map<ObjectID, BodyState>::Element *E = body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_tree);
-	E->get().in_tree = false;
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
 	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].area_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].area_shape);
 	}
 }
 
@@ -224,7 +224,7 @@ void Area3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, i
 	Object *obj = ObjectDB::get_instance(objid);
 	Node *node = Object::cast_to<Node>(obj);
 
-	Map<ObjectID, BodyState>::Element *E = body_map.find(objid);
+	HashMap<ObjectID, BodyState>::Iterator E = body_map.find(objid);
 
 	if (!body_in && !E) {
 		return; //likely removed from the tree
@@ -235,36 +235,36 @@ void Area3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, i
 	if (body_in) {
 		if (!E) {
 			E = body_map.insert(objid, BodyState());
-			E->get().rid = p_body;
-			E->get().rc = 0;
-			E->get().in_tree = node && node->is_inside_tree();
+			E->value.rid = p_body;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_body_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_body_exit_tree), make_binds(objid));
-				if (E->get().in_tree) {
+				if (E->value.in_tree) {
 					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 				}
 			}
 		}
-		E->get().rc++;
+		E->value.rc++;
 		if (node) {
-			E->get().shapes.insert(ShapePair(p_body_shape, p_area_shape));
+			E->value.shapes.insert(ShapePair(p_body_shape, p_area_shape));
 		}
 
-		if (E->get().in_tree) {
+		if (E->value.in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_area_shape);
 		}
 
 	} else {
-		E->get().rc--;
+		E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(ShapePair(p_body_shape, p_area_shape));
+			E->value.shapes.erase(ShapePair(p_body_shape, p_area_shape));
 		}
 
-		bool in_tree = E->get().in_tree;
-		if (E->get().rc == 0) {
-			body_map.erase(E);
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			body_map.remove(E);
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_body_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_body_exit_tree));
@@ -285,7 +285,7 @@ void Area3D::_clear_monitoring() {
 	ERR_FAIL_COND_MSG(locked, "This function can't be used during the in/out signal.");
 
 	{
-		Map<ObjectID, BodyState> bmcopy = body_map;
+		HashMap<ObjectID, BodyState> bmcopy = body_map;
 		body_map.clear();
 		//disconnect all monitored stuff
 
@@ -314,7 +314,7 @@ void Area3D::_clear_monitoring() {
 	}
 
 	{
-		Map<ObjectID, AreaState> bmcopy = area_map;
+		HashMap<ObjectID, AreaState> bmcopy = area_map;
 		area_map.clear();
 		//disconnect all monitored stuff
 
@@ -379,14 +379,14 @@ void Area3D::_area_enter_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 
-	Map<ObjectID, AreaState>::Element *E = area_map.find(p_id);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_tree);
+	ERR_FAIL_COND(E->value.in_tree);
 
-	E->get().in_tree = true;
+	E->value.in_tree = true;
 	emit_signal(SceneStringNames::get_singleton()->area_entered, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->area_shape_entered, E->get().rid, node, E->get().shapes[i].area_shape, E->get().shapes[i].self_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_entered, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
 	}
 }
 
@@ -394,13 +394,13 @@ void Area3D::_area_exit_tree(ObjectID p_id) {
 	Object *obj = ObjectDB::get_instance(p_id);
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
-	Map<ObjectID, AreaState>::Element *E = area_map.find(p_id);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_tree);
-	E->get().in_tree = false;
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
 	emit_signal(SceneStringNames::get_singleton()->area_exited, node);
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E->get().rid, node, E->get().shapes[i].area_shape, E->get().shapes[i].self_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->area_shape_exited, E->value.rid, node, E->value.shapes[i].area_shape, E->value.shapes[i].self_shape);
 	}
 }
 
@@ -411,7 +411,7 @@ void Area3D::_area_inout(int p_status, const RID &p_area, ObjectID p_instance, i
 	Object *obj = ObjectDB::get_instance(objid);
 	Node *node = Object::cast_to<Node>(obj);
 
-	Map<ObjectID, AreaState>::Element *E = area_map.find(objid);
+	HashMap<ObjectID, AreaState>::Iterator E = area_map.find(objid);
 
 	if (!area_in && !E) {
 		return; //likely removed from the tree
@@ -422,36 +422,36 @@ void Area3D::_area_inout(int p_status, const RID &p_area, ObjectID p_instance, i
 	if (area_in) {
 		if (!E) {
 			E = area_map.insert(objid, AreaState());
-			E->get().rid = p_area;
-			E->get().rc = 0;
-			E->get().in_tree = node && node->is_inside_tree();
+			E->value.rid = p_area;
+			E->value.rc = 0;
+			E->value.in_tree = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_area_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_area_exit_tree), make_binds(objid));
-				if (E->get().in_tree) {
+				if (E->value.in_tree) {
 					emit_signal(SceneStringNames::get_singleton()->area_entered, node);
 				}
 			}
 		}
-		E->get().rc++;
+		E->value.rc++;
 		if (node) {
-			E->get().shapes.insert(AreaShapePair(p_area_shape, p_self_shape));
+			E->value.shapes.insert(AreaShapePair(p_area_shape, p_self_shape));
 		}
 
-		if (!node || E->get().in_tree) {
+		if (!node || E->value.in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->area_shape_entered, p_area, node, p_area_shape, p_self_shape);
 		}
 
 	} else {
-		E->get().rc--;
+		E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(AreaShapePair(p_area_shape, p_self_shape));
+			E->value.shapes.erase(AreaShapePair(p_area_shape, p_self_shape));
 		}
 
-		bool in_tree = E->get().in_tree;
-		if (E->get().rc == 0) {
-			area_map.erase(E);
+		bool in_tree = E->value.in_tree;
+		if (E->value.rc == 0) {
+			area_map.remove(E);
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &Area3D::_area_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &Area3D::_area_exit_tree));
@@ -524,20 +524,20 @@ TypedArray<Area3D> Area3D::get_overlapping_areas() const {
 
 bool Area3D::overlaps_area(Node *p_area) const {
 	ERR_FAIL_NULL_V(p_area, false);
-	const Map<ObjectID, AreaState>::Element *E = area_map.find(p_area->get_instance_id());
+	HashMap<ObjectID, AreaState>::ConstIterator E = area_map.find(p_area->get_instance_id());
 	if (!E) {
 		return false;
 	}
-	return E->get().in_tree;
+	return E->value.in_tree;
 }
 
 bool Area3D::overlaps_body(Node *p_body) const {
 	ERR_FAIL_NULL_V(p_body, false);
-	const Map<ObjectID, BodyState>::Element *E = body_map.find(p_body->get_instance_id());
+	HashMap<ObjectID, BodyState>::ConstIterator E = body_map.find(p_body->get_instance_id());
 	if (!E) {
 		return false;
 	}
-	return E->get().in_tree;
+	return E->value.in_tree;
 }
 
 void Area3D::set_audio_bus_override(bool p_override) {
diff --git a/scene/3d/area_3d.h b/scene/3d/area_3d.h
index 31ded00fb7..3b892baf57 100644
--- a/scene/3d/area_3d.h
+++ b/scene/3d/area_3d.h
@@ -98,7 +98,7 @@ private:
 		VSet<ShapePair> shapes;
 	};
 
-	Map<ObjectID, BodyState> body_map;
+	HashMap<ObjectID, BodyState> body_map;
 
 	void _area_inout(int p_status, const RID &p_area, ObjectID p_instance, int p_area_shape, int p_self_shape);
 
@@ -130,7 +130,7 @@ private:
 		VSet<AreaShapePair> shapes;
 	};
 
-	Map<ObjectID, AreaState> area_map;
+	HashMap<ObjectID, AreaState> area_map;
 	void _clear_monitoring();
 
 	bool audio_bus_override = false;
diff --git a/scene/3d/audio_stream_player_3d.cpp b/scene/3d/audio_stream_player_3d.cpp
index f057c72012..4a20a88346 100644
--- a/scene/3d/audio_stream_player_3d.cpp
+++ b/scene/3d/audio_stream_player_3d.cpp
@@ -281,7 +281,7 @@ void AudioStreamPlayer3D::_notification(int p_what) {
 				active.set();
 				Ref<AudioStreamPlayback> new_playback = stream->instance_playback();
 				ERR_FAIL_COND_MSG(new_playback.is_null(), "Failed to instantiate playback.");
-				Map<StringName, Vector<AudioFrame>> bus_map;
+				HashMap<StringName, Vector<AudioFrame>> bus_map;
 				bus_map[_get_actual_bus()] = volume_vector;
 				AudioServer::get_singleton()->start_playback_stream(new_playback, bus_map, setplay.get(), actual_pitch_scale, linear_attenuation, attenuation_filter_cutoff_hz);
 				stream_playbacks.push_back(new_playback);
@@ -387,7 +387,7 @@ Vector<AudioFrame> AudioStreamPlayer3D::_update_panning() {
 	Ref<World3D> world_3d = get_world_3d();
 	ERR_FAIL_COND_V(world_3d.is_null(), output_volume_vector);
 
-	Set<Camera3D *> cameras = world_3d->get_cameras();
+	RBSet<Camera3D *> cameras = world_3d->get_cameras();
 	cameras.insert(get_viewport()->get_camera_3d());
 
 	PhysicsDirectSpaceState3D *space_state = PhysicsServer3D::get_singleton()->space_get_direct_state(world_3d->get_space());
@@ -466,7 +466,7 @@ Vector<AudioFrame> AudioStreamPlayer3D::_update_panning() {
 			output_volume_vector.write[k] = multiplier * output_volume_vector[k];
 		}
 
-		Map<StringName, Vector<AudioFrame>> bus_volumes;
+		HashMap<StringName, Vector<AudioFrame>> bus_volumes;
 		if (area) {
 			if (area->is_overriding_audio_bus()) {
 				//override audio bus
diff --git a/scene/3d/collision_object_3d.cpp b/scene/3d/collision_object_3d.cpp
index 40c09593a4..87812167cb 100644
--- a/scene/3d/collision_object_3d.cpp
+++ b/scene/3d/collision_object_3d.cpp
@@ -345,7 +345,7 @@ void CollisionObject3D::_update_debug_shapes() {
 		return;
 	}
 
-	for (Set<uint32_t>::Element *shapedata_idx = debug_shapes_to_update.front(); shapedata_idx; shapedata_idx = shapedata_idx->next()) {
+	for (RBSet<uint32_t>::Element *shapedata_idx = debug_shapes_to_update.front(); shapedata_idx; shapedata_idx = shapedata_idx->next()) {
 		if (shapes.has(shapedata_idx->get())) {
 			ShapeData &shapedata = shapes[shapedata_idx->get()];
 			ShapeData::ShapeBase *shapes = shapedata.shapes.ptrw();
diff --git a/scene/3d/collision_object_3d.h b/scene/3d/collision_object_3d.h
index e92843d784..84b00de9c9 100644
--- a/scene/3d/collision_object_3d.h
+++ b/scene/3d/collision_object_3d.h
@@ -71,14 +71,14 @@ private:
 
 	int total_subshapes = 0;
 
-	Map<uint32_t, ShapeData> shapes;
+	RBMap<uint32_t, ShapeData> shapes;
 
 	bool only_update_transform_changes = false; // This is used for sync to physics.
 
 	bool capture_input_on_drag = false;
 	bool ray_pickable = true;
 
-	Set<uint32_t> debug_shapes_to_update;
+	RBSet<uint32_t> debug_shapes_to_update;
 	int debug_shapes_count = 0;
 	Transform3D debug_shape_old_transform;
 
diff --git a/scene/3d/label_3d.cpp b/scene/3d/label_3d.cpp
index 9375190151..2d7da48ab1 100644
--- a/scene/3d/label_3d.cpp
+++ b/scene/3d/label_3d.cpp
@@ -469,8 +469,8 @@ void Label3D::_shape() {
 	aabb = AABB();
 
 	// Clear materials.
-	for (Map<uint64_t, SurfaceData>::Element *E = surfaces.front(); E; E = E->next()) {
-		RenderingServer::get_singleton()->free(E->get().material);
+	for (const KeyValue<uint64_t, SurfaceData> &E : surfaces) {
+		RenderingServer::get_singleton()->free(E.value.material);
 	}
 	surfaces.clear();
 
@@ -599,20 +599,20 @@ void Label3D::_shape() {
 		offset.y -= (TS->shaped_text_get_descent(lines_rid[i]) + line_spacing + font->get_spacing(TextServer::SPACING_BOTTOM)) * pixel_size;
 	}
 
-	for (Map<uint64_t, SurfaceData>::Element *E = surfaces.front(); E; E = E->next()) {
+	for (const KeyValue<uint64_t, SurfaceData> &E : surfaces) {
 		Array mesh_array;
 		mesh_array.resize(RS::ARRAY_MAX);
-		mesh_array[RS::ARRAY_VERTEX] = E->get().mesh_vertices;
-		mesh_array[RS::ARRAY_NORMAL] = E->get().mesh_normals;
-		mesh_array[RS::ARRAY_TANGENT] = E->get().mesh_tangents;
-		mesh_array[RS::ARRAY_COLOR] = E->get().mesh_colors;
-		mesh_array[RS::ARRAY_TEX_UV] = E->get().mesh_uvs;
-		mesh_array[RS::ARRAY_INDEX] = E->get().indices;
+		mesh_array[RS::ARRAY_VERTEX] = E.value.mesh_vertices;
+		mesh_array[RS::ARRAY_NORMAL] = E.value.mesh_normals;
+		mesh_array[RS::ARRAY_TANGENT] = E.value.mesh_tangents;
+		mesh_array[RS::ARRAY_COLOR] = E.value.mesh_colors;
+		mesh_array[RS::ARRAY_TEX_UV] = E.value.mesh_uvs;
+		mesh_array[RS::ARRAY_INDEX] = E.value.indices;
 
 		RS::SurfaceData sd;
 		RS::get_singleton()->mesh_create_surface_data_from_arrays(&sd, RS::PRIMITIVE_TRIANGLES, mesh_array);
 
-		sd.material = E->get().material;
+		sd.material = E.value.material;
 
 		RS::get_singleton()->mesh_add_surface(mesh, sd);
 	}
@@ -1003,8 +1003,8 @@ Label3D::~Label3D() {
 	TS->free_rid(text_rid);
 
 	RenderingServer::get_singleton()->free(mesh);
-	for (Map<uint64_t, SurfaceData>::Element *E = surfaces.front(); E; E = E->next()) {
-		RenderingServer::get_singleton()->free(E->get().material);
+	for (KeyValue<uint64_t, SurfaceData> E : surfaces) {
+		RenderingServer::get_singleton()->free(E.value.material);
 	}
 	surfaces.clear();
 }
diff --git a/scene/3d/label_3d.h b/scene/3d/label_3d.h
index 86b8faa617..f57797a247 100644
--- a/scene/3d/label_3d.h
+++ b/scene/3d/label_3d.h
@@ -83,7 +83,7 @@ private:
 		RID material;
 	};
 
-	Map<uint64_t, SurfaceData> surfaces;
+	HashMap<uint64_t, SurfaceData> surfaces;
 
 	HorizontalAlignment horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER;
 	VerticalAlignment vertical_alignment = VERTICAL_ALIGNMENT_CENTER;
diff --git a/scene/3d/lightmapper.h b/scene/3d/lightmapper.h
index f641c99ec1..55d9a52a28 100644
--- a/scene/3d/lightmapper.h
+++ b/scene/3d/lightmapper.h
@@ -88,7 +88,9 @@ public:
 				instID(INVALID_GEOMETRY_ID) {}
 
 		/*! Tests if we hit something. */
-		_FORCE_INLINE_ explicit operator bool() const { return geomID != INVALID_GEOMETRY_ID; }
+		_FORCE_INLINE_ explicit operator bool() const {
+			return geomID != INVALID_GEOMETRY_ID;
+		}
 
 	public:
 		Vector3 org; //!< Ray origin + tnear
@@ -116,7 +118,7 @@ public:
 	virtual void set_mesh_alpha_texture(Ref<Image> p_alpha_texture, unsigned int p_id) = 0;
 	virtual void commit() = 0;
 
-	virtual void set_mesh_filter(const Set<int> &p_mesh_ids) = 0;
+	virtual void set_mesh_filter(const RBSet<int> &p_mesh_ids) = 0;
 	virtual void clear_mesh_filter() = 0;
 
 	static Ref<LightmapRaycaster> create();
diff --git a/scene/3d/mesh_instance_3d.cpp b/scene/3d/mesh_instance_3d.cpp
index 31c33a6b61..189ab7fc3b 100644
--- a/scene/3d/mesh_instance_3d.cpp
+++ b/scene/3d/mesh_instance_3d.cpp
@@ -42,9 +42,9 @@ bool MeshInstance3D::_set(const StringName &p_name, const Variant &p_value) {
 		return false;
 	}
 
-	Map<StringName, int>::Element *E = blend_shape_properties.find(p_name);
+	HashMap<StringName, int>::Iterator E = blend_shape_properties.find(p_name);
 	if (E) {
-		set_blend_shape_value(E->get(), p_value);
+		set_blend_shape_value(E->value, p_value);
 		return true;
 	}
 
@@ -66,9 +66,9 @@ bool MeshInstance3D::_get(const StringName &p_name, Variant &r_ret) const {
 		return false;
 	}
 
-	const Map<StringName, int>::Element *E = blend_shape_properties.find(p_name);
+	HashMap<StringName, int>::ConstIterator E = blend_shape_properties.find(p_name);
 	if (E) {
-		r_ret = get_blend_shape_value(E->get());
+		r_ret = get_blend_shape_value(E->value);
 		return true;
 	}
 
diff --git a/scene/3d/mesh_instance_3d.h b/scene/3d/mesh_instance_3d.h
index 0bf5c32410..dc9c64fa41 100644
--- a/scene/3d/mesh_instance_3d.h
+++ b/scene/3d/mesh_instance_3d.h
@@ -47,7 +47,7 @@ protected:
 	NodePath skeleton_path = NodePath("..");
 
 	LocalVector<float> blend_shape_tracks;
-	Map<StringName, int> blend_shape_properties;
+	HashMap<StringName, int> blend_shape_properties;
 	Vector<Ref<Material>> surface_override_materials;
 
 	void _mesh_changed();
diff --git a/scene/3d/physics_body_3d.cpp b/scene/3d/physics_body_3d.cpp
index 5f9bca7c49..94cd5400db 100644
--- a/scene/3d/physics_body_3d.cpp
+++ b/scene/3d/physics_body_3d.cpp
@@ -390,18 +390,18 @@ void RigidDynamicBody3D::_body_enter_tree(ObjectID p_id) {
 	ERR_FAIL_COND(!node);
 
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(E->get().in_tree);
+	ERR_FAIL_COND(E->value.in_tree);
 
-	E->get().in_tree = true;
+	E->value.in_tree = true;
 
 	contact_monitor->locked = true;
 
 	emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_entered, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
 	}
 
 	contact_monitor->locked = false;
@@ -412,17 +412,17 @@ void RigidDynamicBody3D::_body_exit_tree(ObjectID p_id) {
 	Node *node = Object::cast_to<Node>(obj);
 	ERR_FAIL_COND(!node);
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(p_id);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(p_id);
 	ERR_FAIL_COND(!E);
-	ERR_FAIL_COND(!E->get().in_tree);
-	E->get().in_tree = false;
+	ERR_FAIL_COND(!E->value.in_tree);
+	E->value.in_tree = false;
 
 	contact_monitor->locked = true;
 
 	emit_signal(SceneStringNames::get_singleton()->body_exited, node);
 
-	for (int i = 0; i < E->get().shapes.size(); i++) {
-		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->get().rid, node, E->get().shapes[i].body_shape, E->get().shapes[i].local_shape);
+	for (int i = 0; i < E->value.shapes.size(); i++) {
+		emit_signal(SceneStringNames::get_singleton()->body_shape_exited, E->value.rid, node, E->value.shapes[i].body_shape, E->value.shapes[i].local_shape);
 	}
 
 	contact_monitor->locked = false;
@@ -436,43 +436,43 @@ void RigidDynamicBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p
 	Node *node = Object::cast_to<Node>(obj);
 
 	ERR_FAIL_COND(!contact_monitor);
-	Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(objid);
+	HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(objid);
 
 	ERR_FAIL_COND(!body_in && !E);
 
 	if (body_in) {
 		if (!E) {
 			E = contact_monitor->body_map.insert(objid, BodyState());
-			E->get().rid = p_body;
-			//E->get().rc=0;
-			E->get().in_tree = node && node->is_inside_tree();
+			E->value.rid = p_body;
+			//E->value.rc=0;
+			E->value.in_tree = node && node->is_inside_tree();
 			if (node) {
 				node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody3D::_body_enter_tree), make_binds(objid));
 				node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody3D::_body_exit_tree), make_binds(objid));
-				if (E->get().in_tree) {
+				if (E->value.in_tree) {
 					emit_signal(SceneStringNames::get_singleton()->body_entered, node);
 				}
 			}
 		}
-		//E->get().rc++;
+		//E->value.rc++;
 		if (node) {
-			E->get().shapes.insert(ShapePair(p_body_shape, p_local_shape));
+			E->value.shapes.insert(ShapePair(p_body_shape, p_local_shape));
 		}
 
-		if (E->get().in_tree) {
+		if (E->value.in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_entered, p_body, node, p_body_shape, p_local_shape);
 		}
 
 	} else {
-		//E->get().rc--;
+		//E->value.rc--;
 
 		if (node) {
-			E->get().shapes.erase(ShapePair(p_body_shape, p_local_shape));
+			E->value.shapes.erase(ShapePair(p_body_shape, p_local_shape));
 		}
 
-		bool in_tree = E->get().in_tree;
+		bool in_tree = E->value.in_tree;
 
-		if (E->get().shapes.is_empty()) {
+		if (E->value.shapes.is_empty()) {
 			if (node) {
 				node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody3D::_body_enter_tree));
 				node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody3D::_body_exit_tree));
@@ -481,7 +481,7 @@ void RigidDynamicBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p
 				}
 			}
 
-			contact_monitor->body_map.erase(E);
+			contact_monitor->body_map.remove(E);
 		}
 		if (node && in_tree) {
 			emit_signal(SceneStringNames::get_singleton()->body_shape_exited, p_body, obj, p_body_shape, p_local_shape);
@@ -547,7 +547,7 @@ void RigidDynamicBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state)
 
 			//bool found=false;
 
-			Map<ObjectID, BodyState>::Element *E = contact_monitor->body_map.find(obj);
+			HashMap<ObjectID, BodyState>::Iterator E = contact_monitor->body_map.find(obj);
 			if (!E) {
 				toadd[toadd_count].rid = rid;
 				toadd[toadd_count].local_shape = local_shape;
@@ -558,7 +558,7 @@ void RigidDynamicBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state)
 			}
 
 			ShapePair sp(shape, local_shape);
-			int idx = E->get().shapes.find(sp);
+			int idx = E->value.shapes.find(sp);
 			if (idx == -1) {
 				toadd[toadd_count].rid = rid;
 				toadd[toadd_count].local_shape = local_shape;
@@ -568,7 +568,7 @@ void RigidDynamicBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state)
 				continue;
 			}
 
-			E->get().shapes[idx].tagged = true;
+			E->value.shapes[idx].tagged = true;
 		}
 
 		//put the ones to remove
diff --git a/scene/3d/physics_body_3d.h b/scene/3d/physics_body_3d.h
index e64987b73e..22dcb218bc 100644
--- a/scene/3d/physics_body_3d.h
+++ b/scene/3d/physics_body_3d.h
@@ -212,7 +212,7 @@ private:
 
 	struct ContactMonitor {
 		bool locked = false;
-		Map<ObjectID, BodyState> body_map;
+		HashMap<ObjectID, BodyState> body_map;
 	};
 
 	ContactMonitor *contact_monitor = nullptr;
@@ -714,7 +714,9 @@ public:
 	const JointData *get_joint_data() const;
 	Skeleton3D *find_skeleton_parent();
 
-	int get_bone_id() const { return bone_id; }
+	int get_bone_id() const {
+		return bone_id;
+	}
 
 	void set_joint_type(JointType p_joint_type);
 	JointType get_joint_type() const;
diff --git a/scene/3d/ray_cast_3d.h b/scene/3d/ray_cast_3d.h
index ad85001591..d6062969d8 100644
--- a/scene/3d/ray_cast_3d.h
+++ b/scene/3d/ray_cast_3d.h
@@ -46,7 +46,7 @@ class RayCast3D : public Node3D {
 	Vector3 collision_normal;
 
 	Vector3 target_position = Vector3(0, -1, 0);
-	Set<RID> exclude;
+	RBSet<RID> exclude;
 
 	uint32_t collision_mask = 1;
 	bool exclude_parent_body = true;
diff --git a/scene/3d/skeleton_3d.cpp b/scene/3d/skeleton_3d.cpp
index 9e403a6ecd..f4a7767c44 100644
--- a/scene/3d/skeleton_3d.cpp
+++ b/scene/3d/skeleton_3d.cpp
@@ -263,7 +263,7 @@ void Skeleton3D::_notification(int p_what) {
 			force_update_all_bone_transforms();
 
 			// Update skins.
-			for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
+			for (RBSet<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
 				const Skin *skin = E->get()->skin.operator->();
 				RID skeleton = E->get()->skeleton;
 				uint32_t bind_count = skin->get_bind_count();
@@ -1000,7 +1000,7 @@ Ref<Skin> Skeleton3D::create_skin_from_rest_transforms() {
 Ref<SkinReference> Skeleton3D::register_skin(const Ref<Skin> &p_skin) {
 	ERR_FAIL_COND_V(p_skin.is_null(), Ref<SkinReference>());
 
-	for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
+	for (RBSet<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
 		if (E->get()->skin == p_skin) {
 			return Ref<SkinReference>(E->get());
 		}
@@ -1303,7 +1303,7 @@ Skeleton3D::Skeleton3D() {
 
 Skeleton3D::~Skeleton3D() {
 	// Some skins may remain bound.
-	for (Set<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
+	for (RBSet<SkinReference *>::Element *E = skin_bindings.front(); E; E = E->next()) {
 		E->get()->skeleton_node = nullptr;
 	}
 }
diff --git a/scene/3d/skeleton_3d.h b/scene/3d/skeleton_3d.h
index ca706bea98..c72792bd47 100644
--- a/scene/3d/skeleton_3d.h
+++ b/scene/3d/skeleton_3d.h
@@ -131,7 +131,7 @@ private:
 		}
 	};
 
-	Set<SkinReference *> skin_bindings;
+	RBSet<SkinReference *> skin_bindings;
 
 	void _skin_changed();
 
diff --git a/scene/3d/spring_arm_3d.h b/scene/3d/spring_arm_3d.h
index b247ea1707..78d9db7259 100644
--- a/scene/3d/spring_arm_3d.h
+++ b/scene/3d/spring_arm_3d.h
@@ -37,7 +37,7 @@ class SpringArm3D : public Node3D {
 	GDCLASS(SpringArm3D, Node3D);
 
 	Ref<Shape3D> shape;
-	Set<RID> excluded_objects;
+	RBSet<RID> excluded_objects;
 	real_t spring_length = 1.0;
 	real_t current_spring_length = 0.0;
 	bool keep_child_basis = false;
diff --git a/scene/3d/vehicle_body_3d.h b/scene/3d/vehicle_body_3d.h
index d2371d819b..4ef70f7764 100644
--- a/scene/3d/vehicle_body_3d.h
+++ b/scene/3d/vehicle_body_3d.h
@@ -162,7 +162,7 @@ class VehicleBody3D : public RigidDynamicBody3D {
 	real_t m_steeringValue = 0.0;
 	real_t m_currentVehicleSpeedKmHour = 0.0;
 
-	Set<RID> exclude;
+	RBSet<RID> exclude;
 
 	Vector<Vector3> m_forwardWS;
 	Vector<Vector3> m_axle;
diff --git a/scene/3d/voxelizer.h b/scene/3d/voxelizer.h
index dc7569d17c..0179795ddc 100644
--- a/scene/3d/voxelizer.h
+++ b/scene/3d/voxelizer.h
@@ -86,7 +86,7 @@ private:
 		Vector<Color> emission;
 	};
 
-	Map<Ref<Material>, MaterialCache> material_cache;
+	HashMap<Ref<Material>, MaterialCache> material_cache;
 	AABB original_bounds;
 	AABB po2_bounds;
 	int axis_cell_size[3] = {};
diff --git a/scene/animation/animation_blend_tree.h b/scene/animation/animation_blend_tree.h
index 2acacd7396..73bde633cb 100644
--- a/scene/animation/animation_blend_tree.h
+++ b/scene/animation/animation_blend_tree.h
@@ -354,7 +354,7 @@ class AnimationNodeBlendTree : public AnimationRootNode {
 		Vector<StringName> connections;
 	};
 
-	Map<StringName, Node> nodes;
+	HashMap<StringName, Node> nodes;
 
 	Vector2 graph_offset;
 
diff --git a/scene/animation/animation_node_state_machine.cpp b/scene/animation/animation_node_state_machine.cpp
index b3cae4f5b5..81df12791c 100644
--- a/scene/animation/animation_node_state_machine.cpp
+++ b/scene/animation/animation_node_state_machine.cpp
@@ -188,7 +188,7 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 	Vector2 current_pos = p_state_machine->states[current].position;
 	Vector2 target_pos = p_state_machine->states[p_travel].position;
 
-	Map<StringName, AStarCost> cost_map;
+	HashMap<StringName, AStarCost> cost_map;
 
 	List<int> open_list;
 
diff --git a/scene/animation/animation_node_state_machine.h b/scene/animation/animation_node_state_machine.h
index 39a84358fb..07d0579533 100644
--- a/scene/animation/animation_node_state_machine.h
+++ b/scene/animation/animation_node_state_machine.h
@@ -152,7 +152,7 @@ private:
 		Vector2 position;
 	};
 
-	Map<StringName, State> states;
+	HashMap<StringName, State> states;
 
 	struct Transition {
 		StringName from;
diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp
index 081e6e809a..9ace6db505 100644
--- a/scene/animation/animation_player.cpp
+++ b/scene/animation/animation_player.cpp
@@ -163,7 +163,7 @@ bool AnimationPlayer::_get(const StringName &p_name, Variant &r_ret) const {
 		for (int i = 0; i < keys.size(); i++) {
 			array.push_back(keys[i].from);
 			array.push_back(keys[i].to);
-			array.push_back(blend_times[keys[i]]);
+			array.push_back(blend_times.get(keys[i]));
 		}
 
 		r_ret = array;
@@ -588,10 +588,10 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, double
 
 				//StringName property=a->track_get_path(i).get_property();
 
-				Map<StringName, TrackNodeCache::PropertyAnim>::Element *E = nc->property_anim.find(a->track_get_path(i).get_concatenated_subnames());
+				HashMap<StringName, TrackNodeCache::PropertyAnim>::Iterator E = nc->property_anim.find(a->track_get_path(i).get_concatenated_subnames());
 				ERR_CONTINUE(!E); //should it continue, or create a new one?
 
-				TrackNodeCache::PropertyAnim *pa = &E->get();
+				TrackNodeCache::PropertyAnim *pa = &E->value;
 
 				Animation::UpdateMode update_mode = a->value_track_get_update_mode(i);
 
@@ -738,10 +738,10 @@ void AnimationPlayer::_animation_process_animation(AnimationData *p_anim, double
 					continue;
 				}
 
-				Map<StringName, TrackNodeCache::BezierAnim>::Element *E = nc->bezier_anim.find(a->track_get_path(i).get_concatenated_subnames());
+				HashMap<StringName, TrackNodeCache::BezierAnim>::Iterator E = nc->bezier_anim.find(a->track_get_path(i).get_concatenated_subnames());
 				ERR_CONTINUE(!E); //should it continue, or create a new one?
 
-				TrackNodeCache::BezierAnim *ba = &E->get();
+				TrackNodeCache::BezierAnim *ba = &E->value;
 
 				real_t bezier = a->bezier_track_interpolate(i, p_time);
 				if (ba->accum_pass != accum_pass) {
@@ -1272,7 +1272,7 @@ void AnimationPlayer::_animation_removed(const StringName &p_name, const StringN
 void AnimationPlayer::_rename_animation(const StringName &p_from_name, const StringName &p_to_name) {
 	// Rename autoplay or blends if needed.
 	List<BlendKey> to_erase;
-	Map<BlendKey, float> to_insert;
+	HashMap<BlendKey, float, BlendKey> to_insert;
 	for (const KeyValue<BlendKey, float> &E : blend_times) {
 		BlendKey bk = E.key;
 		BlendKey new_bk = bk;
@@ -1298,8 +1298,8 @@ void AnimationPlayer::_rename_animation(const StringName &p_from_name, const Str
 	}
 
 	while (to_insert.size()) {
-		blend_times[to_insert.front()->key()] = to_insert.front()->get();
-		to_insert.erase(to_insert.front());
+		blend_times[to_insert.begin()->key] = to_insert.begin()->value;
+		to_insert.remove(to_insert.begin());
 	}
 
 	if (autoplay == p_from_name) {
@@ -1766,7 +1766,7 @@ void AnimationPlayer::_animation_changed() {
 }
 
 void AnimationPlayer::_stop_playing_caches() {
-	for (Set<TrackNodeCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
+	for (RBSet<TrackNodeCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
 		if (E->get()->node && E->get()->audio_playing) {
 			E->get()->node->call(SNAME("stop"));
 		}
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index 8c2f0e390b..3ef87dba28 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -132,7 +132,7 @@ private:
 			Variant capture;
 		};
 
-		Map<StringName, PropertyAnim> property_anim;
+		HashMap<StringName, PropertyAnim> property_anim;
 
 		struct BezierAnim {
 			Vector<StringName> bezier_property;
@@ -142,7 +142,7 @@ private:
 			uint64_t accum_pass = 0;
 		};
 
-		Map<StringName, BezierAnim> bezier_anim;
+		HashMap<StringName, BezierAnim> bezier_anim;
 
 		uint32_t last_setup_pass = 0;
 		TrackNodeCache() {}
@@ -153,6 +153,16 @@ private:
 		int bone_idx = -1;
 		int blend_shape_idx = -1;
 
+		static uint32_t hash(const TrackNodeCacheKey &p_key) {
+			uint32_t h = hash_one_uint64(p_key.id);
+			h = hash_djb2_one_32(p_key.bone_idx, h);
+			return hash_djb2_one_32(p_key.blend_shape_idx, h);
+		}
+
+		inline bool operator==(const TrackNodeCacheKey &p_right) const {
+			return id == p_right.id && bone_idx == p_right.bone_idx && blend_shape_idx == p_right.blend_shape_idx;
+		}
+
 		inline bool operator<(const TrackNodeCacheKey &p_right) const {
 			if (id == p_right.id) {
 				if (blend_shape_idx == p_right.blend_shape_idx) {
@@ -166,7 +176,7 @@ private:
 		}
 	};
 
-	Map<TrackNodeCacheKey, TrackNodeCache> node_cache_map;
+	HashMap<TrackNodeCacheKey, TrackNodeCache, TrackNodeCacheKey> node_cache_map;
 
 	TrackNodeCache *cache_update[NODE_CACHE_UPDATE_MAX];
 	int cache_update_size = 0;
@@ -174,7 +184,7 @@ private:
 	int cache_update_prop_size = 0;
 	TrackNodeCache::BezierAnim *cache_update_bezier[NODE_CACHE_UPDATE_MAX];
 	int cache_update_bezier_size = 0;
-	Set<TrackNodeCache *> playing_caches;
+	RBSet<TrackNodeCache *> playing_caches;
 
 	uint64_t accum_pass = 1;
 	float speed_scale = 1.0;
@@ -189,7 +199,7 @@ private:
 		uint64_t last_update = 0;
 	};
 
-	Map<StringName, AnimationData> animation_set;
+	HashMap<StringName, AnimationData> animation_set;
 
 	struct AnimationLibraryData {
 		StringName name;
@@ -202,10 +212,22 @@ private:
 	struct BlendKey {
 		StringName from;
 		StringName to;
-		bool operator<(const BlendKey &bk) const { return from == bk.from ? String(to) < String(bk.to) : String(from) < String(bk.from); }
+		static uint32_t hash(const BlendKey &p_key) {
+			return hash_one_uint64((uint64_t(p_key.from.hash()) << 32) | uint32_t(p_key.to.hash()));
+		}
+		bool operator==(const BlendKey &bk) const {
+			return from == bk.from && to == bk.to;
+		}
+		bool operator<(const BlendKey &bk) const {
+			if (from == bk.from) {
+				return to < bk.to;
+			} else {
+				return from < bk.from;
+			}
+		}
 	};
 
-	Map<BlendKey, float> blend_times;
+	HashMap<BlendKey, float, BlendKey> blend_times;
 
 	struct PlaybackData {
 		AnimationData *from = nullptr;
diff --git a/scene/animation/animation_tree.cpp b/scene/animation/animation_tree.cpp
index d957c7f2de..92af15d5d3 100644
--- a/scene/animation/animation_tree.cpp
+++ b/scene/animation/animation_tree.cpp
@@ -486,7 +486,7 @@ void AnimationTree::set_active(bool p_active) {
 	}
 
 	if (!active && is_inside_tree()) {
-		for (Set<TrackCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
+		for (RBSet<TrackCache *>::Element *E = playing_caches.front(); E; E = E->next()) {
 			if (ObjectDB::get_instance(E->get()->object_id)) {
 				E->get()->object->call(SNAME("stop"));
 			}
diff --git a/scene/animation/animation_tree.h b/scene/animation/animation_tree.h
index 3f09bf7f4b..d40d4ccbbd 100644
--- a/scene/animation/animation_tree.h
+++ b/scene/animation/animation_tree.h
@@ -266,7 +266,7 @@ private:
 	};
 
 	HashMap<NodePath, TrackCache *> track_cache;
-	Set<TrackCache *> playing_caches;
+	RBSet<TrackCache *> playing_caches;
 
 	Ref<AnimationNode> root;
 
diff --git a/scene/debugger/scene_debugger.cpp b/scene/debugger/scene_debugger.cpp
index 17b573b776..b792b11dbc 100644
--- a/scene/debugger/scene_debugger.cpp
+++ b/scene/debugger/scene_debugger.cpp
@@ -68,7 +68,7 @@ bool SceneDebugger::RPCProfilerFrame::deserialize(const Array &p_arr) {
 }
 
 class SceneDebugger::RPCProfiler : public EngineProfiler {
-	Map<ObjectID, RPCNodeInfo> rpc_node_data;
+	HashMap<ObjectID, RPCNodeInfo> rpc_node_data;
 	uint64_t last_profile_time = 0;
 
 	void init_node(const ObjectID p_node) {
@@ -345,22 +345,22 @@ void SceneDebugger::remove_from_cache(const String &p_filename, Node *p_node) {
 		return;
 	}
 
-	Map<String, Set<Node *>> &edit_cache = debugger->live_scene_edit_cache;
-	Map<String, Set<Node *>>::Element *E = edit_cache.find(p_filename);
+	HashMap<String, RBSet<Node *>> &edit_cache = debugger->live_scene_edit_cache;
+	HashMap<String, RBSet<Node *>>::Iterator E = edit_cache.find(p_filename);
 	if (E) {
-		E->get().erase(p_node);
-		if (E->get().size() == 0) {
-			edit_cache.erase(E);
+		E->value.erase(p_node);
+		if (E->value.size() == 0) {
+			edit_cache.remove(E);
 		}
 	}
 
-	Map<Node *, Map<ObjectID, Node *>> &remove_list = debugger->live_edit_remove_list;
-	Map<Node *, Map<ObjectID, Node *>>::Element *F = remove_list.find(p_node);
+	HashMap<Node *, HashMap<ObjectID, Node *>> &remove_list = debugger->live_edit_remove_list;
+	HashMap<Node *, HashMap<ObjectID, Node *>>::Iterator F = remove_list.find(p_node);
 	if (F) {
-		for (const KeyValue<ObjectID, Node *> &G : F->get()) {
+		for (const KeyValue<ObjectID, Node *> &G : F->value) {
 			memdelete(G.value);
 		}
-		remove_list.erase(F);
+		remove_list.remove(F);
 	}
 }
 
@@ -408,47 +408,47 @@ SceneDebuggerObject::SceneDebuggerObject(ObjectID p_id) {
 }
 
 void SceneDebuggerObject::_parse_script_properties(Script *p_script, ScriptInstance *p_instance) {
-	typedef Map<const Script *, Set<StringName>> ScriptMemberMap;
-	typedef Map<const Script *, Map<StringName, Variant>> ScriptConstantsMap;
+	typedef HashMap<const Script *, RBSet<StringName>> ScriptMemberMap;
+	typedef HashMap<const Script *, HashMap<StringName, Variant>> ScriptConstantsMap;
 
 	ScriptMemberMap members;
 	if (p_instance) {
-		members[p_script] = Set<StringName>();
+		members[p_script] = RBSet<StringName>();
 		p_script->get_members(&(members[p_script]));
 	}
 
 	ScriptConstantsMap constants;
-	constants[p_script] = Map<StringName, Variant>();
+	constants[p_script] = HashMap<StringName, Variant>();
 	p_script->get_constants(&(constants[p_script]));
 
 	Ref<Script> base = p_script->get_base_script();
 	while (base.is_valid()) {
 		if (p_instance) {
-			members[base.ptr()] = Set<StringName>();
+			members[base.ptr()] = RBSet<StringName>();
 			base->get_members(&(members[base.ptr()]));
 		}
 
-		constants[base.ptr()] = Map<StringName, Variant>();
+		constants[base.ptr()] = HashMap<StringName, Variant>();
 		base->get_constants(&(constants[base.ptr()]));
 
 		base = base->get_base_script();
 	}
 
 	// Members
-	for (ScriptMemberMap::Element *sm = members.front(); sm; sm = sm->next()) {
-		for (Set<StringName>::Element *E = sm->get().front(); E; E = E->next()) {
+	for (KeyValue<const Script *, RBSet<StringName>> sm : members) {
+		for (RBSet<StringName>::Element *E = sm.value.front(); E; E = E->next()) {
 			Variant m;
 			if (p_instance->get(E->get(), m)) {
-				String script_path = sm->key() == p_script ? "" : sm->key()->get_path().get_file() + "/";
+				String script_path = sm.key == p_script ? "" : sm.key->get_path().get_file() + "/";
 				PropertyInfo pi(m.get_type(), "Members/" + script_path + E->get());
 				properties.push_back(SceneDebuggerProperty(pi, m));
 			}
 		}
 	}
 	// Constants
-	for (ScriptConstantsMap::Element *sc = constants.front(); sc; sc = sc->next()) {
-		for (const KeyValue<StringName, Variant> &E : sc->get()) {
-			String script_path = sc->key() == p_script ? "" : sc->key()->get_path().get_file() + "/";
+	for (KeyValue<const Script *, HashMap<StringName, Variant>> &sc : constants) {
+		for (const KeyValue<StringName, Variant> &E : sc.value) {
+			String script_path = sc.key == p_script ? "" : sc.key->get_path().get_file() + "/";
 			if (E.value.get_type() == Variant::OBJECT) {
 				Variant id = ((Object *)E.value)->get_instance_id();
 				PropertyInfo pi(id.get_type(), "Constants/" + E.key, PROPERTY_HINT_OBJECT_ID, "Object");
@@ -624,12 +624,12 @@ void LiveEditor::_node_set_func(int p_id, const StringName &p_prop, const Varian
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
@@ -668,12 +668,12 @@ void LiveEditor::_node_call_func(int p_id, const StringName &p_method, const Var
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
@@ -753,12 +753,12 @@ void LiveEditor::_create_node_func(const NodePath &p_parent, const String &p_typ
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
@@ -797,12 +797,12 @@ void LiveEditor::_instance_node_func(const NodePath &p_parent, const String &p_p
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
@@ -835,13 +835,13 @@ void LiveEditor::_remove_node_func(const NodePath &p_at) {
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F;) {
-		Set<Node *>::Element *N = F->next();
+	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
+		RBSet<Node *>::Element *N = F->next();
 
 		Node *n = F->get();
 
@@ -871,13 +871,13 @@ void LiveEditor::_remove_and_keep_node_func(const NodePath &p_at, ObjectID p_kee
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F;) {
-		Set<Node *>::Element *N = F->next();
+	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
+		RBSet<Node *>::Element *N = F->next();
 
 		Node *n = F->get();
 
@@ -910,13 +910,13 @@ void LiveEditor::_restore_node_func(ObjectID p_id, const NodePath &p_at, int p_a
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F;) {
-		Set<Node *>::Element *N = F->next();
+	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
+		RBSet<Node *>::Element *N = F->next();
 
 		Node *n = F->get();
 
@@ -929,23 +929,23 @@ void LiveEditor::_restore_node_func(ObjectID p_id, const NodePath &p_at, int p_a
 		}
 		Node *n2 = n->get_node(p_at);
 
-		Map<Node *, Map<ObjectID, Node *>>::Element *EN = live_edit_remove_list.find(n);
+		HashMap<Node *, HashMap<ObjectID, Node *>>::Iterator EN = live_edit_remove_list.find(n);
 
 		if (!EN) {
 			continue;
 		}
 
-		Map<ObjectID, Node *>::Element *FN = EN->get().find(p_id);
+		HashMap<ObjectID, Node *>::Iterator FN = EN->value.find(p_id);
 
 		if (!FN) {
 			continue;
 		}
-		n2->add_child(FN->get());
+		n2->add_child(FN->value);
 
-		EN->get().erase(FN);
+		EN->value.remove(FN);
 
-		if (EN->get().size() == 0) {
-			live_edit_remove_list.erase(EN);
+		if (EN->value.size() == 0) {
+			live_edit_remove_list.remove(EN);
 		}
 
 		F = N;
@@ -963,12 +963,12 @@ void LiveEditor::_duplicate_node_func(const NodePath &p_at, const String &p_new_
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
@@ -1002,12 +1002,12 @@ void LiveEditor::_reparent_node_func(const NodePath &p_at, const NodePath &p_new
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	Map<String, Set<Node *>>::Element *E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (Set<Node *>::Element *F = E->get().front(); F; F = F->next()) {
+	for (RBSet<Node *>::Element *F = E->value.front(); F; F = F->next()) {
 		Node *n = F->get();
 
 		if (base && !base->is_ancestor_of(n)) {
diff --git a/scene/debugger/scene_debugger.h b/scene/debugger/scene_debugger.h
index 29d7da7d11..0daefa9609 100644
--- a/scene/debugger/scene_debugger.h
+++ b/scene/debugger/scene_debugger.h
@@ -132,14 +132,14 @@ public:
 class LiveEditor {
 private:
 	friend class SceneDebugger;
-	Map<int, NodePath> live_edit_node_path_cache;
-	Map<int, String> live_edit_resource_cache;
+	HashMap<int, NodePath> live_edit_node_path_cache;
+	HashMap<int, String> live_edit_resource_cache;
 
 	NodePath live_edit_root;
 	String live_edit_scene;
 
-	Map<String, Set<Node *>> live_scene_edit_cache;
-	Map<Node *, Map<ObjectID, Node *>> live_edit_remove_list;
+	HashMap<String, RBSet<Node *>> live_scene_edit_cache;
+	HashMap<Node *, HashMap<ObjectID, Node *>> live_edit_remove_list;
 
 	void _send_tree();
 
diff --git a/scene/gui/base_button.cpp b/scene/gui/base_button.cpp
index 789c01adf3..595f0cbea7 100644
--- a/scene/gui/base_button.cpp
+++ b/scene/gui/base_button.cpp
@@ -43,7 +43,7 @@ void BaseButton::_unpress_group() {
 		status.pressed = true;
 	}
 
-	for (Set<BaseButton *>::Element *E = button_group->buttons.front(); E; E = E->next()) {
+	for (RBSet<BaseButton *>::Element *E = button_group->buttons.front(); E; E = E->next()) {
 		if (E->get() == this) {
 			continue;
 		}
@@ -485,14 +485,14 @@ BaseButton::~BaseButton() {
 }
 
 void ButtonGroup::get_buttons(List<BaseButton *> *r_buttons) {
-	for (Set<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
+	for (RBSet<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
 		r_buttons->push_back(E->get());
 	}
 }
 
 Array ButtonGroup::_get_buttons() {
 	Array btns;
-	for (Set<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
+	for (RBSet<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
 		btns.push_back(E->get());
 	}
 
@@ -500,7 +500,7 @@ Array ButtonGroup::_get_buttons() {
 }
 
 BaseButton *ButtonGroup::get_pressed_button() {
-	for (Set<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
+	for (RBSet<BaseButton *>::Element *E = buttons.front(); E; E = E->next()) {
 		if (E->get()->is_pressed()) {
 			return E->get();
 		}
diff --git a/scene/gui/base_button.h b/scene/gui/base_button.h
index f4f9b88868..0b70d285ee 100644
--- a/scene/gui/base_button.h
+++ b/scene/gui/base_button.h
@@ -143,7 +143,7 @@ VARIANT_ENUM_CAST(BaseButton::ActionMode)
 class ButtonGroup : public Resource {
 	GDCLASS(ButtonGroup, Resource);
 	friend class BaseButton;
-	Set<BaseButton *> buttons;
+	RBSet<BaseButton *> buttons;
 
 protected:
 	static void _bind_methods();
diff --git a/scene/gui/box_container.cpp b/scene/gui/box_container.cpp
index 251648da69..df695feba8 100644
--- a/scene/gui/box_container.cpp
+++ b/scene/gui/box_container.cpp
@@ -52,7 +52,7 @@ void BoxContainer::_resort() {
 	int stretch_min = 0;
 	int stretch_avail = 0;
 	float stretch_ratio_total = 0.0;
-	Map<Control *, _MinSizeCache> min_size_cache;
+	HashMap<Control *, _MinSizeCache> min_size_cache;
 
 	for (int i = 0; i < get_child_count(); i++) {
 		Control *c = Object::cast_to<Control>(get_child(i));
diff --git a/scene/gui/code_edit.cpp b/scene/gui/code_edit.cpp
index b2aa4030b7..197c9005c3 100644
--- a/scene/gui/code_edit.cpp
+++ b/scene/gui/code_edit.cpp
@@ -740,7 +740,7 @@ void CodeEdit::set_auto_indent_prefixes(const TypedArray<String> &p_prefixes) {
 
 TypedArray<String> CodeEdit::get_auto_indent_prefixes() const {
 	TypedArray<String> prefixes;
-	for (const Set<char32_t>::Element *E = auto_indent_prefixes.front(); E; E = E->next()) {
+	for (const RBSet<char32_t>::Element *E = auto_indent_prefixes.front(); E; E = E->next()) {
 		prefixes.push_back(String::chr(E->get()));
 	}
 	return prefixes;
@@ -1628,7 +1628,7 @@ Point2 CodeEdit::get_delimiter_start_position(int p_line, int p_column) const {
 	start_position.y = -1;
 	start_position.x = -1;
 
-	bool in_region = ((p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value()) != -1;
+	bool in_region = ((p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->get()) != -1;
 
 	/* Check the keys for this line. */
 	for (const KeyValue<int, int> &E : delimiter_cache[p_line]) {
@@ -1752,7 +1752,7 @@ void CodeEdit::set_code_completion_prefixes(const TypedArray<String> &p_prefixes
 
 TypedArray<String> CodeEdit::get_code_completion_prefixes() const {
 	TypedArray<String> prefixes;
-	for (const Set<char32_t>::Element *E = code_completion_prefixes.front(); E; E = E->next()) {
+	for (const RBSet<char32_t>::Element *E = code_completion_prefixes.front(); E; E = E->next()) {
 		prefixes.push_back(String::chr(E->get()));
 	}
 	return prefixes;
@@ -2402,7 +2402,7 @@ void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) {
 			}
 		} else {
 			for (int i = start_line; i < end_line; i++) {
-				delimiter_cache.insert(i, Map<int, int>());
+				delimiter_cache.insert(i, RBMap<int, int>());
 			}
 		}
 	}
@@ -2539,7 +2539,7 @@ int CodeEdit::_is_in_delimiter(int p_line, int p_column, DelimiterType p_type) c
 
 	int region = (p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value();
 	bool in_region = region != -1 && delimiters[region].type == p_type;
-	for (Map<int, int>::Element *E = delimiter_cache[p_line].front(); E; E = E->next()) {
+	for (RBMap<int, int>::Element *E = delimiter_cache[p_line].front(); E; E = E->next()) {
 		/* If column is specified, loop until the key is larger then the column. */
 		if (p_column != -1) {
 			if (E->key() > p_column) {
diff --git a/scene/gui/code_edit.h b/scene/gui/code_edit.h
index 135dd32780..0b00735f46 100644
--- a/scene/gui/code_edit.h
+++ b/scene/gui/code_edit.h
@@ -58,7 +58,7 @@ private:
 	String indent_text = "\t";
 
 	bool auto_indent = false;
-	Set<char32_t> auto_indent_prefixes;
+	RBSet<char32_t> auto_indent_prefixes;
 
 	bool indent_using_spaces = false;
 	int _calculate_spaces_till_next_left_indent(int p_column) const;
@@ -176,7 +176,7 @@ private:
 	 *      ]
 	 *  ]
 	 */
-	Vector<Map<int, int>> delimiter_cache;
+	Vector<RBMap<int, int>> delimiter_cache;
 
 	void _update_delimiter_cache(int p_from_line = 0, int p_to_line = -1);
 	int _is_in_delimiter(int p_line, int p_column, DelimiterType p_type) const;
@@ -214,7 +214,7 @@ private:
 	int code_completion_longest_line = 0;
 	Rect2i code_completion_rect;
 
-	Set<char32_t> code_completion_prefixes;
+	RBSet<char32_t> code_completion_prefixes;
 	List<ScriptLanguage::CodeCompletionOption> code_completion_option_submitted;
 	List<ScriptLanguage::CodeCompletionOption> code_completion_option_sources;
 	String code_completion_base;
diff --git a/scene/gui/flow_container.cpp b/scene/gui/flow_container.cpp
index 1e5863b845..30b694da76 100644
--- a/scene/gui/flow_container.cpp
+++ b/scene/gui/flow_container.cpp
@@ -49,7 +49,7 @@ void FlowContainer::_resort() {
 
 	bool rtl = is_layout_rtl();
 
-	Map<Control *, Size2i> children_minsize_cache;
+	HashMap<Control *, Size2i> children_minsize_cache;
 
 	Vector<_LineData> lines_data;
 
diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp
index 4c8006e33d..6f3a361e82 100644
--- a/scene/gui/graph_edit.cpp
+++ b/scene/gui/graph_edit.cpp
@@ -1684,10 +1684,10 @@ void GraphEdit::set_warped_panning(bool p_warped) {
 	warped_panning = p_warped;
 }
 
-int GraphEdit::_set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u, const Set<StringName> &r_v) {
+int GraphEdit::_set_operations(SET_OPERATIONS p_operation, RBSet<StringName> &r_u, const RBSet<StringName> &r_v) {
 	switch (p_operation) {
 		case GraphEdit::IS_EQUAL: {
-			for (Set<StringName>::Element *E = r_u.front(); E; E = E->next()) {
+			for (RBSet<StringName>::Element *E = r_u.front(); E; E = E->next()) {
 				if (!r_v.has(E->get())) {
 					return 0;
 				}
@@ -1698,7 +1698,7 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u,
 			if (r_u.size() == r_v.size() && !r_u.size()) {
 				return 1;
 			}
-			for (Set<StringName>::Element *E = r_u.front(); E; E = E->next()) {
+			for (RBSet<StringName>::Element *E = r_u.front(); E; E = E->next()) {
 				if (!r_v.has(E->get())) {
 					return 0;
 				}
@@ -1706,7 +1706,7 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u,
 			return 1;
 		} break;
 		case GraphEdit::DIFFERENCE: {
-			for (Set<StringName>::Element *E = r_u.front(); E; E = E->next()) {
+			for (RBSet<StringName>::Element *E = r_u.front(); E; E = E->next()) {
 				if (r_v.has(E->get())) {
 					r_u.erase(E->get());
 				}
@@ -1714,7 +1714,7 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u,
 			return r_u.size();
 		} break;
 		case GraphEdit::UNION: {
-			for (Set<StringName>::Element *E = r_v.front(); E; E = E->next()) {
+			for (RBSet<StringName>::Element *E = r_v.front(); E; E = E->next()) {
 				if (!r_u.has(E->get())) {
 					r_u.insert(E->get());
 				}
@@ -1727,17 +1727,17 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u,
 	return -1;
 }
 
-HashMap<int, Vector<StringName>> GraphEdit::_layering(const Set<StringName> &r_selected_nodes, const HashMap<StringName, Set<StringName>> &r_upper_neighbours) {
+HashMap<int, Vector<StringName>> GraphEdit::_layering(const RBSet<StringName> &r_selected_nodes, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours) {
 	HashMap<int, Vector<StringName>> l;
 
-	Set<StringName> p = r_selected_nodes, q = r_selected_nodes, u, z;
+	RBSet<StringName> p = r_selected_nodes, q = r_selected_nodes, u, z;
 	int current_layer = 0;
 	bool selected = false;
 
 	while (!_set_operations(GraphEdit::IS_EQUAL, q, u)) {
 		_set_operations(GraphEdit::DIFFERENCE, p, u);
-		for (const Set<StringName>::Element *E = p.front(); E; E = E->next()) {
-			Set<StringName> n = r_upper_neighbours[E->get()];
+		for (const RBSet<StringName>::Element *E = p.front(); E; E = E->next()) {
+			RBSet<StringName> n = r_upper_neighbours[E->get()];
 			if (_set_operations(GraphEdit::IS_SUBSET, n, z)) {
 				Vector<StringName> t;
 				t.push_back(E->get());
@@ -1747,7 +1747,7 @@ HashMap<int, Vector<StringName>> GraphEdit::_layering(const Set<StringName> &r_s
 				selected = true;
 				t.append_array(l[current_layer]);
 				l.insert(current_layer, t);
-				Set<StringName> V;
+				RBSet<StringName> V;
 				V.insert(E->get());
 				_set_operations(GraphEdit::UNION, u, V);
 			}
@@ -1789,8 +1789,8 @@ Vector<StringName> GraphEdit::_split(const Vector<StringName> &r_layer, const Ha
 	return left;
 }
 
-void GraphEdit::_horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, Set<StringName>> &r_upper_neighbours, const Set<StringName> &r_selected_nodes) {
-	for (const Set<StringName>::Element *E = r_selected_nodes.front(); E; E = E->next()) {
+void GraphEdit::_horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours, const RBSet<StringName> &r_selected_nodes) {
+	for (const RBSet<StringName>::Element *E = r_selected_nodes.front(); E; E = E->next()) {
 		r_root[E->get()] = E->get();
 		r_align[E->get()] = E->get();
 	}
@@ -1829,7 +1829,7 @@ void GraphEdit::_horizontal_alignment(Dictionary &r_root, Dictionary &r_align, c
 	}
 }
 
-void GraphEdit::_crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, Set<StringName>> &r_upper_neighbours) {
+void GraphEdit::_crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours) {
 	if (r_layers.size() == 1) {
 		return;
 	}
@@ -1867,8 +1867,8 @@ void GraphEdit::_crossing_minimisation(HashMap<int, Vector<StringName>> &r_layer
 	}
 }
 
-void GraphEdit::_calculate_inner_shifts(Dictionary &r_inner_shifts, const Dictionary &r_root, const Dictionary &r_node_names, const Dictionary &r_align, const Set<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info) {
-	for (const Set<StringName>::Element *E = r_block_heads.front(); E; E = E->next()) {
+void GraphEdit::_calculate_inner_shifts(Dictionary &r_inner_shifts, const Dictionary &r_root, const Dictionary &r_node_names, const Dictionary &r_align, const RBSet<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info) {
+	for (const RBSet<StringName>::Element *E = r_block_heads.front(); E; E = E->next()) {
 		real_t left = 0;
 		StringName u = E->get();
 		StringName v = r_align[u];
@@ -2040,7 +2040,7 @@ void GraphEdit::arrange_nodes() {
 	}
 
 	Dictionary node_names;
-	Set<StringName> selected_nodes;
+	RBSet<StringName> selected_nodes;
 
 	for (int i = get_child_count() - 1; i >= 0; i--) {
 		GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));
@@ -2051,7 +2051,7 @@ void GraphEdit::arrange_nodes() {
 		node_names[gn->get_name()] = gn;
 	}
 
-	HashMap<StringName, Set<StringName>> upper_neighbours;
+	HashMap<StringName, RBSet<StringName>> upper_neighbours;
 	HashMap<StringName, Pair<int, int>> port_info;
 	Vector2 origin(FLT_MAX, FLT_MAX);
 
@@ -2066,7 +2066,7 @@ void GraphEdit::arrange_nodes() {
 
 		if (gn->is_selected()) {
 			selected_nodes.insert(gn->get_name());
-			Set<StringName> s;
+			RBSet<StringName> s;
 			for (List<Connection>::Element *E = connections.front(); E; E = E->next()) {
 				GraphNode *p_from = Object::cast_to<GraphNode>(node_names[E->get().from]);
 				if (E->get().to == gn->get_name() && p_from->is_selected()) {
@@ -2103,9 +2103,9 @@ void GraphEdit::arrange_nodes() {
 	HashMap<StringName, Vector2> new_positions;
 	Vector2 default_position(FLT_MAX, FLT_MAX);
 	Dictionary inner_shift;
-	Set<StringName> block_heads;
+	RBSet<StringName> block_heads;
 
-	for (const Set<StringName>::Element *E = selected_nodes.front(); E; E = E->next()) {
+	for (const RBSet<StringName>::Element *E = selected_nodes.front(); E; E = E->next()) {
 		inner_shift[E->get()] = 0.0f;
 		sink[E->get()] = E->get();
 		shift[E->get()] = FLT_MAX;
@@ -2117,13 +2117,13 @@ void GraphEdit::arrange_nodes() {
 
 	_calculate_inner_shifts(inner_shift, root, node_names, align, block_heads, port_info);
 
-	for (const Set<StringName>::Element *E = block_heads.front(); E; E = E->next()) {
+	for (const RBSet<StringName>::Element *E = block_heads.front(); E; E = E->next()) {
 		_place_block(E->get(), gap_v, layers, root, align, node_names, inner_shift, sink, shift, new_positions);
 	}
 	origin.y = Object::cast_to<GraphNode>(node_names[layers[0][0]])->get_position_offset().y - (new_positions[layers[0][0]].y + (float)inner_shift[layers[0][0]]);
 	origin.x = Object::cast_to<GraphNode>(node_names[layers[0][0]])->get_position_offset().x;
 
-	for (const Set<StringName>::Element *E = block_heads.front(); E; E = E->next()) {
+	for (const RBSet<StringName>::Element *E = block_heads.front(); E; E = E->next()) {
 		StringName u = E->get();
 		float start_from = origin.y + new_positions[E->get()].y;
 		do {
@@ -2169,7 +2169,7 @@ void GraphEdit::arrange_nodes() {
 	}
 
 	emit_signal(SNAME("begin_node_move"));
-	for (const Set<StringName>::Element *E = selected_nodes.front(); E; E = E->next()) {
+	for (const RBSet<StringName>::Element *E = selected_nodes.front(); E; E = E->next()) {
 		GraphNode *gn = Object::cast_to<GraphNode>(node_names[E->get()]);
 		gn->set_drag(true);
 		Vector2 pos = (new_positions[E->get()]);
diff --git a/scene/gui/graph_edit.h b/scene/gui/graph_edit.h
index f556fcdd23..9e34d5528f 100644
--- a/scene/gui/graph_edit.h
+++ b/scene/gui/graph_edit.h
@@ -228,9 +228,9 @@ private:
 		}
 	};
 
-	Set<ConnType> valid_connection_types;
-	Set<int> valid_left_disconnect_types;
-	Set<int> valid_right_disconnect_types;
+	RBSet<ConnType> valid_connection_types;
+	RBSet<int> valid_left_disconnect_types;
+	RBSet<int> valid_right_disconnect_types;
 
 	HashMap<StringName, Vector<GraphNode *>> comment_enclosed_nodes;
 	void _update_comment_enclosed_nodes_list(GraphNode *p_node, HashMap<StringName, Vector<GraphNode *>> &p_comment_enclosed_nodes);
@@ -258,12 +258,12 @@ private:
 		UNION,
 	};
 
-	int _set_operations(SET_OPERATIONS p_operation, Set<StringName> &r_u, const Set<StringName> &r_v);
-	HashMap<int, Vector<StringName>> _layering(const Set<StringName> &r_selected_nodes, const HashMap<StringName, Set<StringName>> &r_upper_neighbours);
+	int _set_operations(SET_OPERATIONS p_operation, RBSet<StringName> &r_u, const RBSet<StringName> &r_v);
+	HashMap<int, Vector<StringName>> _layering(const RBSet<StringName> &r_selected_nodes, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours);
 	Vector<StringName> _split(const Vector<StringName> &r_layer, const HashMap<StringName, Dictionary> &r_crossings);
-	void _horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, Set<StringName>> &r_upper_neighbours, const Set<StringName> &r_selected_nodes);
-	void _crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, Set<StringName>> &r_upper_neighbours);
-	void _calculate_inner_shifts(Dictionary &r_inner_shifts, const Dictionary &r_root, const Dictionary &r_node_names, const Dictionary &r_align, const Set<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info);
+	void _horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours, const RBSet<StringName> &r_selected_nodes);
+	void _crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours);
+	void _calculate_inner_shifts(Dictionary &r_inner_shifts, const Dictionary &r_root, const Dictionary &r_node_names, const Dictionary &r_align, const RBSet<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info);
 	float _calculate_threshold(StringName p_v, StringName p_w, const Dictionary &r_node_names, const HashMap<int, Vector<StringName>> &r_layers, const Dictionary &r_root, const Dictionary &r_align, const Dictionary &r_inner_shift, real_t p_current_threshold, const HashMap<StringName, Vector2> &r_node_positions);
 	void _place_block(StringName p_v, float p_delta, const HashMap<int, Vector<StringName>> &r_layers, const Dictionary &r_root, const Dictionary &r_align, const Dictionary &r_node_name, const Dictionary &r_inner_shift, Dictionary &r_sink, Dictionary &r_shift, HashMap<StringName, Vector2> &r_node_positions);
 
diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp
index e3ecd17ed8..85b32a52b5 100644
--- a/scene/gui/graph_node.cpp
+++ b/scene/gui/graph_node.cpp
@@ -193,7 +193,7 @@ void GraphNode::_resort() {
 	int stretch_min = 0;
 	int stretch_avail = 0;
 	float stretch_ratio_total = 0;
-	Map<Control *, _MinSizeCache> min_size_cache;
+	HashMap<Control *, _MinSizeCache> min_size_cache;
 
 	for (int i = 0; i < get_child_count(); i++) {
 		Control *c = Object::cast_to<Control>(get_child(i));
diff --git a/scene/gui/graph_node.h b/scene/gui/graph_node.h
index 7eb5f27cff..75e10b82b5 100644
--- a/scene/gui/graph_node.h
+++ b/scene/gui/graph_node.h
@@ -85,7 +85,7 @@ private:
 	Vector<ConnCache> conn_input_cache;
 	Vector<ConnCache> conn_output_cache;
 
-	Map<int, Slot> slot_info;
+	HashMap<int, Slot> slot_info;
 
 	bool connpos_dirty = true;
 
diff --git a/scene/gui/grid_container.cpp b/scene/gui/grid_container.cpp
index b58bb4d74a..b2cf2f66a9 100644
--- a/scene/gui/grid_container.cpp
+++ b/scene/gui/grid_container.cpp
@@ -33,10 +33,10 @@
 void GridContainer::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_SORT_CHILDREN: {
-			Map<int, int> col_minw; // Max of min_width of all controls in each col (indexed by col).
-			Map<int, int> row_minh; // Max of min_height of all controls in each row (indexed by row).
-			Set<int> col_expanded; // Columns which have the SIZE_EXPAND flag set.
-			Set<int> row_expanded; // Rows which have the SIZE_EXPAND flag set.
+			HashMap<int, int> col_minw; // Max of min_width of all controls in each col (indexed by col).
+			HashMap<int, int> row_minh; // Max of min_height of all controls in each row (indexed by row).
+			RBSet<int> col_expanded; // Columns which have the SIZE_EXPAND flag set.
+			RBSet<int> row_expanded; // Rows which have the SIZE_EXPAND flag set.
 
 			int hsep = get_theme_constant(SNAME("h_separation"));
 			int vsep = get_theme_constant(SNAME("v_separation"));
@@ -104,7 +104,7 @@ void GridContainer::_notification(int p_what) {
 				// Check if all minwidth constraints are OK if we use the remaining space.
 				can_fit = true;
 				int max_index = col_expanded.front()->get();
-				for (Set<int>::Element *E = col_expanded.front(); E; E = E->next()) {
+				for (RBSet<int>::Element *E = col_expanded.front(); E; E = E->next()) {
 					if (col_minw[E->get()] > col_minw[max_index]) {
 						max_index = E->get();
 					}
@@ -125,7 +125,7 @@ void GridContainer::_notification(int p_what) {
 				// Check if all minheight constraints are OK if we use the remaining space.
 				can_fit = true;
 				int max_index = row_expanded.front()->get();
-				for (Set<int>::Element *E = row_expanded.front(); E; E = E->next()) {
+				for (RBSet<int>::Element *E = row_expanded.front(); E; E = E->next()) {
 					if (row_minh[E->get()] > row_minh[max_index]) {
 						max_index = E->get();
 					}
@@ -214,8 +214,8 @@ void GridContainer::_bind_methods() {
 }
 
 Size2 GridContainer::get_minimum_size() const {
-	Map<int, int> col_minw;
-	Map<int, int> row_minh;
+	HashMap<int, int> col_minw;
+	HashMap<int, int> row_minh;
 
 	int hsep = get_theme_constant(SNAME("h_separation"));
 	int vsep = get_theme_constant(SNAME("v_separation"));
diff --git a/scene/gui/popup_menu.h b/scene/gui/popup_menu.h
index 98d76875cb..12587b7e73 100644
--- a/scene/gui/popup_menu.h
+++ b/scene/gui/popup_menu.h
@@ -117,7 +117,7 @@ class PopupMenu : public Popup {
 	bool hide_on_multistate_item_selection = false;
 	Vector2 moved;
 
-	Map<Ref<Shortcut>, int> shortcut_refcount;
+	HashMap<Ref<Shortcut>, int> shortcut_refcount;
 
 	void _ref_shortcut(Ref<Shortcut> p_sc);
 	void _unref_shortcut(Ref<Shortcut> p_sc);
diff --git a/scene/gui/range.cpp b/scene/gui/range.cpp
index 8e66826e9d..73f19a8eda 100644
--- a/scene/gui/range.cpp
+++ b/scene/gui/range.cpp
@@ -50,7 +50,7 @@ void Range::_value_changed_notify() {
 }
 
 void Range::Shared::emit_value_changed() {
-	for (Set<Range *>::Element *E = owners.front(); E; E = E->next()) {
+	for (RBSet<Range *>::Element *E = owners.front(); E; E = E->next()) {
 		Range *r = E->get();
 		if (!r->is_inside_tree()) {
 			continue;
@@ -70,7 +70,7 @@ void Range::_validate_values() {
 }
 
 void Range::Shared::emit_changed(const char *p_what) {
-	for (Set<Range *>::Element *E = owners.front(); E; E = E->next()) {
+	for (RBSet<Range *>::Element *E = owners.front(); E; E = E->next()) {
 		Range *r = E->get();
 		if (!r->is_inside_tree()) {
 			continue;
diff --git a/scene/gui/range.h b/scene/gui/range.h
index 46b0d39202..a59bfa9677 100644
--- a/scene/gui/range.h
+++ b/scene/gui/range.h
@@ -45,7 +45,7 @@ class Range : public Control {
 		bool exp_ratio = false;
 		bool allow_greater = false;
 		bool allow_lesser = false;
-		Set<Range *> owners;
+		RBSet<Range *> owners;
 		void emit_value_changed();
 		void emit_changed(const char *p_what = "");
 	};
diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp
index 7ed28ac3c8..fa0c2ce12c 100644
--- a/scene/gui/rich_text_label.cpp
+++ b/scene/gui/rich_text_label.cpp
@@ -3177,7 +3177,7 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 
 		// Find optional parameters.
 		String bbcode_name;
-		typedef Map<String, String> OptionMap;
+		typedef HashMap<String, String> OptionMap;
 		OptionMap bbcode_options;
 		if (!split_tag_block.is_empty()) {
 			bbcode_name = split_tag_block[0];
@@ -3620,9 +3620,9 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			Ref<Texture2D> texture = ResourceLoader::load(image, "Texture2D");
 			if (texture.is_valid()) {
 				Color color = Color(1.0, 1.0, 1.0);
-				OptionMap::Element *color_option = bbcode_options.find("color");
+				OptionMap::Iterator color_option = bbcode_options.find("color");
 				if (color_option) {
-					color = Color::from_string(color_option->value(), color);
+					color = Color::from_string(color_option->value, color);
 				}
 
 				int width = 0;
@@ -3636,14 +3636,14 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 						height = bbcode_value.substr(sep + 1).to_int();
 					}
 				} else {
-					OptionMap::Element *width_option = bbcode_options.find("width");
+					OptionMap::Iterator width_option = bbcode_options.find("width");
 					if (width_option) {
-						width = width_option->value().to_int();
+						width = width_option->value.to_int();
 					}
 
-					OptionMap::Element *height_option = bbcode_options.find("height");
+					OptionMap::Iterator height_option = bbcode_options.find("height");
 					if (height_option) {
-						height = height_option->value().to_int();
+						height = height_option->value.to_int();
 					}
 				}
 
@@ -3729,15 +3729,15 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 
 		} else if (bbcode_name == "fade") {
 			int start_index = 0;
-			OptionMap::Element *start_option = bbcode_options.find("start");
+			OptionMap::Iterator start_option = bbcode_options.find("start");
 			if (start_option) {
-				start_index = start_option->value().to_int();
+				start_index = start_option->value.to_int();
 			}
 
 			int length = 10;
-			OptionMap::Element *length_option = bbcode_options.find("length");
+			OptionMap::Iterator length_option = bbcode_options.find("length");
 			if (length_option) {
-				length = length_option->value().to_int();
+				length = length_option->value.to_int();
 			}
 
 			push_fade(start_index, length);
@@ -3745,15 +3745,15 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			tag_stack.push_front("fade");
 		} else if (bbcode_name == "shake") {
 			int strength = 5;
-			OptionMap::Element *strength_option = bbcode_options.find("level");
+			OptionMap::Iterator strength_option = bbcode_options.find("level");
 			if (strength_option) {
-				strength = strength_option->value().to_int();
+				strength = strength_option->value.to_int();
 			}
 
 			float rate = 20.0f;
-			OptionMap::Element *rate_option = bbcode_options.find("rate");
+			OptionMap::Iterator rate_option = bbcode_options.find("rate");
 			if (rate_option) {
-				rate = rate_option->value().to_float();
+				rate = rate_option->value.to_float();
 			}
 
 			push_shake(strength, rate);
@@ -3762,15 +3762,15 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			set_process_internal(true);
 		} else if (bbcode_name == "wave") {
 			float amplitude = 20.0f;
-			OptionMap::Element *amplitude_option = bbcode_options.find("amp");
+			OptionMap::Iterator amplitude_option = bbcode_options.find("amp");
 			if (amplitude_option) {
-				amplitude = amplitude_option->value().to_float();
+				amplitude = amplitude_option->value.to_float();
 			}
 
 			float period = 5.0f;
-			OptionMap::Element *period_option = bbcode_options.find("freq");
+			OptionMap::Iterator period_option = bbcode_options.find("freq");
 			if (period_option) {
-				period = period_option->value().to_float();
+				period = period_option->value.to_float();
 			}
 
 			push_wave(period, amplitude);
@@ -3779,15 +3779,15 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			set_process_internal(true);
 		} else if (bbcode_name == "tornado") {
 			float radius = 10.0f;
-			OptionMap::Element *radius_option = bbcode_options.find("radius");
+			OptionMap::Iterator radius_option = bbcode_options.find("radius");
 			if (radius_option) {
-				radius = radius_option->value().to_float();
+				radius = radius_option->value.to_float();
 			}
 
 			float frequency = 1.0f;
-			OptionMap::Element *frequency_option = bbcode_options.find("freq");
+			OptionMap::Iterator frequency_option = bbcode_options.find("freq");
 			if (frequency_option) {
-				frequency = frequency_option->value().to_float();
+				frequency = frequency_option->value.to_float();
 			}
 
 			push_tornado(frequency, radius);
@@ -3796,21 +3796,21 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			set_process_internal(true);
 		} else if (bbcode_name == "rainbow") {
 			float saturation = 0.8f;
-			OptionMap::Element *saturation_option = bbcode_options.find("sat");
+			OptionMap::Iterator saturation_option = bbcode_options.find("sat");
 			if (saturation_option) {
-				saturation = saturation_option->value().to_float();
+				saturation = saturation_option->value.to_float();
 			}
 
 			float value = 0.8f;
-			OptionMap::Element *value_option = bbcode_options.find("val");
+			OptionMap::Iterator value_option = bbcode_options.find("val");
 			if (value_option) {
-				value = value_option->value().to_float();
+				value = value_option->value.to_float();
 			}
 
 			float frequency = 1.0f;
-			OptionMap::Element *frequency_option = bbcode_options.find("freq");
+			OptionMap::Iterator frequency_option = bbcode_options.find("freq");
 			if (frequency_option) {
-				frequency = frequency_option->value().to_float();
+				frequency = frequency_option->value.to_float();
 			}
 
 			push_rainbow(saturation, value, frequency);
diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h
index 194cad72d1..993203bee6 100644
--- a/scene/gui/text_edit.h
+++ b/scene/gui/text_edit.h
@@ -356,7 +356,7 @@ private:
 		Vector<int> last_visible_chars;
 	};
 
-	Map<int, LineDrawingCache> line_drawing_cache;
+	HashMap<int, LineDrawingCache> line_drawing_cache;
 
 	int _get_char_pos_for_line(int p_px, int p_line, int p_wrap_index = 0) const;
 
@@ -511,7 +511,6 @@ private:
 
 	/* Syntax highlighting. */
 	Ref<SyntaxHighlighter> syntax_highlighter;
-	Map<int, Dictionary> syntax_highlighting_cache;
 
 	Dictionary _get_line_syntax_highlighting(int p_line);
 
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index 8961b5ba54..0c1a62c667 100644
--- a/scene/main/node.cpp
+++ b/scene/main/node.cpp
@@ -1637,7 +1637,7 @@ Node *Node::find_common_parent_with(const Node *p_node) const {
 		return const_cast<Node *>(p_node);
 	}
 
-	Set<const Node *> visited;
+	RBSet<const Node *> visited;
 
 	const Node *n = this;
 
@@ -1669,7 +1669,7 @@ NodePath Node::get_path_to(const Node *p_node) const {
 		return NodePath(".");
 	}
 
-	Set<const Node *> visited;
+	RBSet<const Node *> visited;
 
 	const Node *n = this;
 
@@ -1763,15 +1763,15 @@ void Node::add_to_group(const StringName &p_identifier, bool p_persistent) {
 void Node::remove_from_group(const StringName &p_identifier) {
 	ERR_FAIL_COND(!data.grouped.has(p_identifier));
 
-	Map<StringName, GroupData>::Element *E = data.grouped.find(p_identifier);
+	HashMap<StringName, GroupData>::Iterator E = data.grouped.find(p_identifier);
 
 	ERR_FAIL_COND(!E);
 
 	if (data.tree) {
-		data.tree->remove_from_group(E->key(), this);
+		data.tree->remove_from_group(E->key, this);
 	}
 
-	data.grouped.erase(E);
+	data.grouped.remove(E);
 }
 
 Array Node::_get_groups() const {
@@ -2042,7 +2042,7 @@ StringName Node::get_property_store_alias(const StringName &p_property) const {
 }
 #endif
 
-void Node::get_storable_properties(Set<StringName> &r_storable_properties) const {
+void Node::get_storable_properties(RBSet<StringName> &r_storable_properties) const {
 	List<PropertyInfo> pi;
 	get_property_list(&pi);
 	for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) {
@@ -2088,7 +2088,7 @@ bool Node::get_scene_instance_load_placeholder() const {
 	return data.use_placeholder;
 }
 
-Node *Node::_duplicate(int p_flags, Map<const Node *, Node *> *r_duplimap) const {
+Node *Node::_duplicate(int p_flags, HashMap<const Node *, Node *> *r_duplimap) const {
 	Node *node = nullptr;
 
 	bool instantiated = false;
@@ -2280,11 +2280,11 @@ Node *Node::duplicate(int p_flags) const {
 }
 
 #ifdef TOOLS_ENABLED
-Node *Node::duplicate_from_editor(Map<const Node *, Node *> &r_duplimap) const {
-	return duplicate_from_editor(r_duplimap, Map<Ref<Resource>, Ref<Resource>>());
+Node *Node::duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap) const {
+	return duplicate_from_editor(r_duplimap, HashMap<Ref<Resource>, Ref<Resource>>());
 }
 
-Node *Node::duplicate_from_editor(Map<const Node *, Node *> &r_duplimap, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
+Node *Node::duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
 	Node *dupe = _duplicate(DUPLICATE_SIGNALS | DUPLICATE_GROUPS | DUPLICATE_SCRIPTS | DUPLICATE_USE_INSTANCING | DUPLICATE_FROM_EDITOR, &r_duplimap);
 
 	// This is used by SceneTreeDock's paste functionality. When pasting to foreign scene, resources are duplicated.
@@ -2300,7 +2300,7 @@ Node *Node::duplicate_from_editor(Map<const Node *, Node *> &r_duplimap, const M
 	return dupe;
 }
 
-void Node::remap_node_resources(Node *p_node, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
+void Node::remap_node_resources(Node *p_node, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
 	List<PropertyInfo> props;
 	p_node->get_property_list(&props);
 
@@ -2326,7 +2326,7 @@ void Node::remap_node_resources(Node *p_node, const Map<Ref<Resource>, Ref<Resou
 	}
 }
 
-void Node::remap_nested_resources(Ref<Resource> p_resource, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
+void Node::remap_nested_resources(Ref<Resource> p_resource, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const {
 	List<PropertyInfo> props;
 	p_resource->get_property_list(&props);
 
diff --git a/scene/main/node.h b/scene/main/node.h
index 72f340bbc3..8505d2618f 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -32,7 +32,7 @@
 #define NODE_H
 
 #include "core/string/node_path.h"
-#include "core/templates/map.h"
+#include "core/templates/rb_map.h"
 #include "core/variant/typed_array.h"
 #include "scene/main/scene_tree.h"
 
@@ -119,7 +119,7 @@ private:
 
 		Viewport *viewport = nullptr;
 
-		Map<StringName, GroupData> grouped;
+		HashMap<StringName, GroupData> grouped;
 		List<Node *>::Element *OW = nullptr; // Owned element.
 		List<Node *> owned;
 
@@ -177,7 +177,7 @@ private:
 	Array _get_node_and_resource(const NodePath &p_path);
 
 	void _duplicate_signals(const Node *p_original, Node *p_copy) const;
-	Node *_duplicate(int p_flags, Map<const Node *, Node *> *r_duplimap = nullptr) const;
+	Node *_duplicate(int p_flags, HashMap<const Node *, Node *> *r_duplimap = nullptr) const;
 
 	TypedArray<Node> _get_children(bool p_include_internal = true) const;
 	Array _get_groups() const;
@@ -378,7 +378,7 @@ public:
 	bool is_property_pinned(const StringName &p_property) const;
 	virtual StringName get_property_store_alias(const StringName &p_property) const;
 #endif
-	void get_storable_properties(Set<StringName> &r_storable_properties) const;
+	void get_storable_properties(RBSet<StringName> &r_storable_properties) const;
 
 	virtual String to_string() override;
 
@@ -420,10 +420,10 @@ public:
 
 	Node *duplicate(int p_flags = DUPLICATE_GROUPS | DUPLICATE_SIGNALS | DUPLICATE_SCRIPTS) const;
 #ifdef TOOLS_ENABLED
-	Node *duplicate_from_editor(Map<const Node *, Node *> &r_duplimap) const;
-	Node *duplicate_from_editor(Map<const Node *, Node *> &r_duplimap, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
-	void remap_node_resources(Node *p_node, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
-	void remap_nested_resources(Ref<Resource> p_resource, const Map<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
+	Node *duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap) const;
+	Node *duplicate_from_editor(HashMap<const Node *, Node *> &r_duplimap, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
+	void remap_node_resources(Node *p_node, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
+	void remap_nested_resources(Ref<Resource> p_resource, const HashMap<Ref<Resource>, Ref<Resource>> &p_resource_remap) const;
 #endif
 
 	// used by editors, to save what has changed only
@@ -522,6 +522,6 @@ public:
 
 VARIANT_ENUM_CAST(Node::DuplicateFlags);
 
-typedef Set<Node *, Node::Comparator> NodeSet;
+typedef RBSet<Node *, Node::Comparator> NodeSet;
 
 #endif
diff --git a/scene/main/resource_preloader.cpp b/scene/main/resource_preloader.cpp
index 8fb7456335..b3595c6227 100644
--- a/scene/main/resource_preloader.cpp
+++ b/scene/main/resource_preloader.cpp
@@ -55,14 +55,14 @@ Array ResourcePreloader::_get_resources() const {
 	arr.resize(resources.size());
 	names.resize(resources.size());
 
-	Set<String> sorted_names;
+	RBSet<String> sorted_names;
 
 	for (const KeyValue<StringName, Ref<Resource>> &E : resources) {
 		sorted_names.insert(E.key);
 	}
 
 	int i = 0;
-	for (Set<String>::Element *E = sorted_names.front(); E; E = E->next()) {
+	for (RBSet<String>::Element *E = sorted_names.front(); E; E = E->next()) {
 		names.set(i, E->get());
 		arr[i] = resources[E->get()];
 		i++;
@@ -123,8 +123,9 @@ Vector<String> ResourcePreloader::_get_resource_list() const {
 	Vector<String> res;
 	res.resize(resources.size());
 	int i = 0;
-	for (Map<StringName, Ref<Resource>>::Element *E = resources.front(); E; E = E->next(), i++) {
-		res.set(i, E->key());
+	for (const KeyValue<StringName, Ref<Resource>> &E : resources) {
+		res.set(i, E.key);
+		i++;
 	}
 
 	return res;
diff --git a/scene/main/resource_preloader.h b/scene/main/resource_preloader.h
index 2df8b5cda7..fe59bc8ae3 100644
--- a/scene/main/resource_preloader.h
+++ b/scene/main/resource_preloader.h
@@ -36,7 +36,7 @@
 class ResourcePreloader : public Node {
 	GDCLASS(ResourcePreloader, Node);
 
-	Map<StringName, Ref<Resource>> resources;
+	HashMap<StringName, Ref<Resource>> resources;
 
 	void _set_resources(const Array &p_data);
 	Array _get_resources() const;
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index baa0362f63..231b672f63 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -129,32 +129,32 @@ void SceneTree::node_renamed(Node *p_node) {
 }
 
 SceneTree::Group *SceneTree::add_to_group(const StringName &p_group, Node *p_node) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		E = group_map.insert(p_group, Group());
 	}
 
-	ERR_FAIL_COND_V_MSG(E->get().nodes.has(p_node), &E->get(), "Already in group: " + p_group + ".");
-	E->get().nodes.push_back(p_node);
-	//E->get().last_tree_version=0;
-	E->get().changed = true;
-	return &E->get();
+	ERR_FAIL_COND_V_MSG(E->value.nodes.has(p_node), &E->value, "Already in group: " + p_group + ".");
+	E->value.nodes.push_back(p_node);
+	//E->value.last_tree_version=0;
+	E->value.changed = true;
+	return &E->value;
 }
 
 void SceneTree::remove_from_group(const StringName &p_group, Node *p_node) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	ERR_FAIL_COND(!E);
 
-	E->get().nodes.erase(p_node);
-	if (E->get().nodes.is_empty()) {
-		group_map.erase(E);
+	E->value.nodes.erase(p_node);
+	if (E->value.nodes.is_empty()) {
+		group_map.remove(E);
 	}
 }
 
 void SceneTree::make_group_changed(const StringName &p_group) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (E) {
-		E->get().changed = true;
+		E->value.changed = true;
 	}
 }
 
@@ -173,17 +173,17 @@ void SceneTree::_flush_ugc() {
 	ugc_locked = true;
 
 	while (unique_group_calls.size()) {
-		Map<UGCall, Vector<Variant>>::Element *E = unique_group_calls.front();
+		HashMap<UGCall, Vector<Variant>, UGCall>::Iterator E = unique_group_calls.begin();
 
-		const Variant **argptrs = (const Variant **)alloca(E->get().size() * sizeof(Variant *));
+		const Variant **argptrs = (const Variant **)alloca(E->value.size() * sizeof(Variant *));
 
-		for (int i = 0; i < E->get().size(); i++) {
-			argptrs[i] = &E->get()[i];
+		for (int i = 0; i < E->value.size(); i++) {
+			argptrs[i] = &E->value[i];
 		}
 
-		call_group_flagsp(GROUP_CALL_DEFAULT, E->key().group, E->key().call, argptrs, E->get().size());
+		call_group_flagsp(GROUP_CALL_DEFAULT, E->key.group, E->key.call, argptrs, E->value.size());
 
-		unique_group_calls.erase(E);
+		unique_group_calls.remove(E);
 	}
 
 	ugc_locked = false;
@@ -211,11 +211,11 @@ void SceneTree::_update_group_order(Group &g, bool p_use_priority) {
 }
 
 void SceneTree::call_group_flagsp(uint32_t p_call_flags, const StringName &p_group, const StringName &p_function, const Variant **p_args, int p_argcount) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
-	Group &g = E->get();
+	Group &g = E->value;
 	if (g.nodes.is_empty()) {
 		return;
 	}
@@ -284,11 +284,11 @@ void SceneTree::call_group_flagsp(uint32_t p_call_flags, const StringName &p_gro
 }
 
 void SceneTree::notify_group_flags(uint32_t p_call_flags, const StringName &p_group, int p_notification) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
-	Group &g = E->get();
+	Group &g = E->value;
 	if (g.nodes.is_empty()) {
 		return;
 	}
@@ -335,11 +335,11 @@ void SceneTree::notify_group_flags(uint32_t p_call_flags, const StringName &p_gr
 }
 
 void SceneTree::set_group_flags(uint32_t p_call_flags, const StringName &p_group, const String &p_name, const Variant &p_value) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
-	Group &g = E->get();
+	Group &g = E->value;
 	if (g.nodes.is_empty()) {
 		return;
 	}
@@ -818,11 +818,11 @@ bool SceneTree::is_paused() const {
 }
 
 void SceneTree::_notify_group_pause(const StringName &p_group, int p_notification) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
-	Group &g = E->get();
+	Group &g = E->value;
 	if (g.nodes.is_empty()) {
 		return;
 	}
@@ -862,11 +862,11 @@ void SceneTree::_notify_group_pause(const StringName &p_group, int p_notificatio
 }
 
 void SceneTree::_call_input_pause(const StringName &p_group, CallInputType p_call_type, const Ref<InputEvent> &p_input, Viewport *p_viewport) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
-	Group &g = E->get();
+	Group &g = E->value;
 	if (g.nodes.is_empty()) {
 		return;
 	}
@@ -952,20 +952,20 @@ int64_t SceneTree::get_frame() const {
 
 Array SceneTree::_get_nodes_in_group(const StringName &p_group) {
 	Array ret;
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return ret;
 	}
 
-	_update_group_order(E->get()); //update order just in case
-	int nc = E->get().nodes.size();
+	_update_group_order(E->value); //update order just in case
+	int nc = E->value.nodes.size();
 	if (nc == 0) {
 		return ret;
 	}
 
 	ret.resize(nc);
 
-	Node **ptr = E->get().nodes.ptrw();
+	Node **ptr = E->value.nodes.ptrw();
 	for (int i = 0; i < nc; i++) {
 		ret[i] = ptr[i];
 	}
@@ -978,32 +978,32 @@ bool SceneTree::has_group(const StringName &p_identifier) const {
 }
 
 Node *SceneTree::get_first_node_in_group(const StringName &p_group) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return nullptr; // No group.
 	}
 
-	_update_group_order(E->get()); // Update order just in case.
+	_update_group_order(E->value); // Update order just in case.
 
-	if (E->get().nodes.is_empty()) {
+	if (E->value.nodes.is_empty()) {
 		return nullptr;
 	}
 
-	return E->get().nodes[0];
+	return E->value.nodes[0];
 }
 
 void SceneTree::get_nodes_in_group(const StringName &p_group, List<Node *> *p_list) {
-	Map<StringName, Group>::Element *E = group_map.find(p_group);
+	HashMap<StringName, Group>::Iterator E = group_map.find(p_group);
 	if (!E) {
 		return;
 	}
 
-	_update_group_order(E->get()); //update order just in case
-	int nc = E->get().nodes.size();
+	_update_group_order(E->value); //update order just in case
+	int nc = E->value.nodes.size();
 	if (nc == 0) {
 		return;
 	}
-	Node **ptr = E->get().nodes.ptrw();
+	Node **ptr = E->value.nodes.ptrw();
 	for (int i = 0; i < nc; i++) {
 		p_list->push_back(ptr[i]);
 	}
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index d633fb38d0..bdcfd2d35a 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -102,7 +102,7 @@ private:
 	bool paused = false;
 	int root_lock = 0;
 
-	Map<StringName, Group> group_map;
+	HashMap<StringName, Group> group_map;
 	bool _quit = false;
 	bool initialized = false;
 
@@ -121,16 +121,20 @@ private:
 		StringName group;
 		StringName call;
 
+		static uint32_t hash(const UGCall &p_val) {
+			return p_val.group.hash() ^ p_val.call.hash();
+		}
+		bool operator==(const UGCall &p_with) const { return group == p_with.group && call == p_with.call; }
 		bool operator<(const UGCall &p_with) const { return group == p_with.group ? call < p_with.call : group < p_with.group; }
 	};
 
 	// Safety for when a node is deleted while a group is being called.
 	int call_lock = 0;
-	Set<Node *> call_skip; // Skip erased nodes.
+	RBSet<Node *> call_skip; // Skip erased nodes.
 
 	List<ObjectID> delete_queue;
 
-	Map<UGCall, Vector<Variant>> unique_group_calls;
+	HashMap<UGCall, Vector<Variant>, UGCall> unique_group_calls;
 	bool ugc_locked = false;
 	void _flush_ugc();
 
diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp
index e4037c2843..a2399c8b5a 100644
--- a/scene/main/viewport.cpp
+++ b/scene/main/viewport.cpp
@@ -412,7 +412,7 @@ void Viewport::_notification(int p_what) {
 #ifndef _3D_DISABLED
 			if (audio_listener_3d_set.size() && !audio_listener_3d) {
 				AudioListener3D *first = nullptr;
-				for (Set<AudioListener3D *>::Element *E = audio_listener_3d_set.front(); E; E = E->next()) {
+				for (RBSet<AudioListener3D *>::Element *E = audio_listener_3d_set.front(); E; E = E->next()) {
 					if (first == nullptr || first->is_greater_than(E->get())) {
 						first = E->get();
 					}
@@ -426,7 +426,7 @@ void Viewport::_notification(int p_what) {
 			if (camera_3d_set.size() && !camera_3d) {
 				// There are cameras but no current camera, pick first in tree and make it current.
 				Camera3D *first = nullptr;
-				for (Set<Camera3D *>::Element *E = camera_3d_set.front(); E; E = E->next()) {
+				for (RBSet<Camera3D *>::Element *E = camera_3d_set.front(); E; E = E->next()) {
 					if (first == nullptr || first->is_greater_than(E->get())) {
 						first = E->get();
 					}
@@ -647,7 +647,7 @@ void Viewport::_process_picking() {
 			uint64_t frame = get_tree()->get_frame();
 
 			PhysicsDirectSpaceState2D::ShapeResult res[64];
-			for (Set<CanvasLayer *>::Element *E = canvas_layers.front(); E; E = E->next()) {
+			for (RBSet<CanvasLayer *>::Element *E = canvas_layers.front(); E; E = E->next()) {
 				Transform2D canvas_transform;
 				ObjectID canvas_layer_id;
 				if (E->get()) {
@@ -675,23 +675,23 @@ void Viewport::_process_picking() {
 						if (co && co->can_process()) {
 							bool send_event = true;
 							if (is_mouse) {
-								Map<ObjectID, uint64_t>::Element *F = physics_2d_mouseover.find(res[i].collider_id);
+								HashMap<ObjectID, uint64_t>::Iterator F = physics_2d_mouseover.find(res[i].collider_id);
 								if (!F) {
 									physics_2d_mouseover.insert(res[i].collider_id, frame);
 									co->_mouse_enter();
 								} else {
-									F->get() = frame;
+									F->value = frame;
 									// It was already hovered, so don't send the event if it's faked.
 									if (mm.is_valid() && mm->get_device() == InputEvent::DEVICE_ID_INTERNAL) {
 										send_event = false;
 									}
 								}
-								Map<Pair<ObjectID, int>, uint64_t, PairSort<ObjectID, int>>::Element *SF = physics_2d_shape_mouseover.find(Pair(res[i].collider_id, res[i].shape));
+								HashMap<Pair<ObjectID, int>, uint64_t, PairHash<ObjectID, int>>::Iterator SF = physics_2d_shape_mouseover.find(Pair(res[i].collider_id, res[i].shape));
 								if (!SF) {
 									physics_2d_shape_mouseover.insert(Pair(res[i].collider_id, res[i].shape), frame);
 									co->_mouse_shape_enter(res[i].shape);
 								} else {
-									SF->get() = frame;
+									SF->value = frame;
 								}
 							}
 
@@ -2250,14 +2250,14 @@ void Viewport::_drop_physics_mouseover(bool p_paused_only) {
 }
 
 void Viewport::_cleanup_mouseover_colliders(bool p_clean_all_frames, bool p_paused_only, uint64_t p_frame_reference) {
-	List<Map<ObjectID, uint64_t>::Element *> to_erase;
+	List<ObjectID> to_erase;
 
-	for (Map<ObjectID, uint64_t>::Element *E = physics_2d_mouseover.front(); E; E = E->next()) {
-		if (!p_clean_all_frames && E->get() == p_frame_reference) {
+	for (const KeyValue<ObjectID, uint64_t> &E : physics_2d_mouseover) {
+		if (!p_clean_all_frames && E.value == p_frame_reference) {
 			continue;
 		}
 
-		Object *o = ObjectDB::get_instance(E->key());
+		Object *o = ObjectDB::get_instance(E.key);
 		if (o) {
 			CollisionObject2D *co = Object::cast_to<CollisionObject2D>(o);
 			if (co && co->is_inside_tree()) {
@@ -2267,7 +2267,7 @@ void Viewport::_cleanup_mouseover_colliders(bool p_clean_all_frames, bool p_paus
 				co->_mouse_exit();
 			}
 		}
-		to_erase.push_back(E);
+		to_erase.push_back(E.key);
 	}
 
 	while (to_erase.size()) {
@@ -2276,24 +2276,24 @@ void Viewport::_cleanup_mouseover_colliders(bool p_clean_all_frames, bool p_paus
 	}
 
 	// Per-shape.
-	List<Map<Pair<ObjectID, int>, uint64_t, PairSort<ObjectID, int>>::Element *> shapes_to_erase;
+	List<Pair<ObjectID, int>> shapes_to_erase;
 
-	for (Map<Pair<ObjectID, int>, uint64_t, PairSort<ObjectID, int>>::Element *E = physics_2d_shape_mouseover.front(); E; E = E->next()) {
-		if (!p_clean_all_frames && E->get() == p_frame_reference) {
+	for (KeyValue<Pair<ObjectID, int>, uint64_t> &E : physics_2d_shape_mouseover) {
+		if (!p_clean_all_frames && E.value == p_frame_reference) {
 			continue;
 		}
 
-		Object *o = ObjectDB::get_instance(E->key().first);
+		Object *o = ObjectDB::get_instance(E.key.first);
 		if (o) {
 			CollisionObject2D *co = Object::cast_to<CollisionObject2D>(o);
 			if (co && co->is_inside_tree()) {
 				if (p_clean_all_frames && p_paused_only && co->can_process()) {
 					continue;
 				}
-				co->_mouse_shape_exit(E->key().second);
+				co->_mouse_shape_exit(E.key.second);
 			}
 		}
-		shapes_to_erase.push_back(E);
+		shapes_to_erase.push_back(E.key);
 	}
 
 	while (shapes_to_erase.size()) {
@@ -3179,7 +3179,7 @@ void Viewport::_audio_listener_3d_remove(AudioListener3D *p_listener) {
 
 void Viewport::_audio_listener_3d_make_next_current(AudioListener3D *p_exclude) {
 	if (audio_listener_3d_set.size() > 0) {
-		for (Set<AudioListener3D *>::Element *E = audio_listener_3d_set.front(); E; E = E->next()) {
+		for (RBSet<AudioListener3D *>::Element *E = audio_listener_3d_set.front(); E; E = E->next()) {
 			if (p_exclude == E->get()) {
 				continue;
 			}
@@ -3267,7 +3267,7 @@ void Viewport::_camera_3d_remove(Camera3D *p_camera) {
 }
 
 void Viewport::_camera_3d_make_next_current(Camera3D *p_exclude) {
-	for (Set<Camera3D *>::Element *E = camera_3d_set.front(); E; E = E->next()) {
+	for (RBSet<Camera3D *>::Element *E = camera_3d_set.front(); E; E = E->next()) {
 		if (p_exclude == E->get()) {
 			continue;
 		}
@@ -3913,7 +3913,7 @@ Viewport::Viewport() {
 
 Viewport::~Viewport() {
 	// Erase itself from viewport textures.
-	for (Set<ViewportTexture *>::Element *E = viewport_textures.front(); E; E = E->next()) {
+	for (RBSet<ViewportTexture *>::Element *E = viewport_textures.front(); E; E = E->next()) {
 		E->get()->vp = nullptr;
 	}
 	RenderingServer::get_singleton()->free(viewport);
diff --git a/scene/main/viewport.h b/scene/main/viewport.h
index c1e71c69a3..c1e4b30c20 100644
--- a/scene/main/viewport.h
+++ b/scene/main/viewport.h
@@ -203,7 +203,7 @@ private:
 
 	AudioListener2D *audio_listener_2d = nullptr;
 	Camera2D *camera_2d = nullptr;
-	Set<CanvasLayer *> canvas_layers;
+	RBSet<CanvasLayer *> canvas_layers;
 
 	RID viewport;
 	RID current_canvas;
@@ -258,9 +258,9 @@ private:
 	bool local_input_handled = false;
 
 	// Collider to frame
-	Map<ObjectID, uint64_t> physics_2d_mouseover;
+	HashMap<ObjectID, uint64_t> physics_2d_mouseover;
 	// Collider & shape to frame
-	Map<Pair<ObjectID, int>, uint64_t, PairSort<ObjectID, int>> physics_2d_shape_mouseover;
+	HashMap<Pair<ObjectID, int>, uint64_t, PairHash<ObjectID, int>> physics_2d_shape_mouseover;
 	// Cleans up colliders corresponding to old frames or all of them.
 	void _cleanup_mouseover_colliders(bool p_clean_all_frames, bool p_paused_only, uint64_t p_frame_reference = 0);
 
@@ -301,7 +301,7 @@ private:
 	bool use_occlusion_culling = false;
 
 	Ref<ViewportTexture> default_texture;
-	Set<ViewportTexture *> viewport_textures;
+	RBSet<ViewportTexture *> viewport_textures;
 
 	SDFOversize sdf_oversize = SDF_OVERSIZE_120_PERCENT;
 	SDFScale sdf_scale = SDF_SCALE_50_PERCENT;
@@ -615,7 +615,7 @@ public:
 	bool use_xr = false;
 	friend class AudioListener3D;
 	AudioListener3D *audio_listener_3d = nullptr;
-	Set<AudioListener3D *> audio_listener_3d_set;
+	RBSet<AudioListener3D *> audio_listener_3d_set;
 	bool is_audio_listener_3d_enabled = false;
 	RID internal_audio_listener_3d;
 	AudioListener3D *get_audio_listener_3d() const;
@@ -650,7 +650,7 @@ public:
 
 	friend class Camera3D;
 	Camera3D *camera_3d = nullptr;
-	Set<Camera3D *> camera_3d_set;
+	RBSet<Camera3D *> camera_3d_set;
 	Camera3D *get_camera_3d() const;
 	void _camera_3d_transform_changed_notify();
 	void _camera_3d_set(Camera3D *p_camera);
diff --git a/scene/main/window.cpp b/scene/main/window.cpp
index 6feccb7eec..d8264e7d33 100644
--- a/scene/main/window.cpp
+++ b/scene/main/window.cpp
@@ -263,7 +263,7 @@ void Window::_make_window() {
 		DisplayServer::get_singleton()->window_set_transient(window_id, transient_parent->window_id);
 	}
 
-	for (Set<Window *>::Element *E = transient_children.front(); E; E = E->next()) {
+	for (RBSet<Window *>::Element *E = transient_children.front(); E; E = E->next()) {
 		if (E->get()->window_id != DisplayServer::INVALID_WINDOW_ID) {
 			DisplayServer::get_singleton()->window_set_transient(E->get()->window_id, transient_parent->window_id);
 		}
@@ -290,7 +290,7 @@ void Window::_clear_window() {
 		DisplayServer::get_singleton()->window_set_transient(window_id, DisplayServer::INVALID_WINDOW_ID);
 	}
 
-	for (Set<Window *>::Element *E = transient_children.front(); E; E = E->next()) {
+	for (RBSet<Window *>::Element *E = transient_children.front(); E; E = E->next()) {
 		if (E->get()->window_id != DisplayServer::INVALID_WINDOW_ID) {
 			DisplayServer::get_singleton()->window_set_transient(E->get()->window_id, DisplayServer::INVALID_WINDOW_ID);
 		}
diff --git a/scene/main/window.h b/scene/main/window.h
index f674f6425a..80dd9a854c 100644
--- a/scene/main/window.h
+++ b/scene/main/window.h
@@ -131,7 +131,7 @@ private:
 	void _make_transient();
 	Window *transient_parent = nullptr;
 	Window *exclusive_child = nullptr;
-	Set<Window *> transient_children;
+	RBSet<Window *> transient_children;
 
 	friend class Control;
 	Ref<Theme> theme;
diff --git a/scene/multiplayer/multiplayer_spawner.h b/scene/multiplayer/multiplayer_spawner.h
index 63948e39a5..ac35df7ff3 100644
--- a/scene/multiplayer/multiplayer_spawner.h
+++ b/scene/multiplayer/multiplayer_spawner.h
@@ -47,7 +47,7 @@ public:
 
 private:
 	TypedArray<PackedScene> spawnable_scenes;
-	Set<ResourceUID::ID> spawnable_ids;
+	RBSet<ResourceUID::ID> spawnable_ids;
 	NodePath spawn_path;
 
 	struct SpawnInfo {
diff --git a/scene/multiplayer/scene_cache_interface.cpp b/scene/multiplayer/scene_cache_interface.cpp
index a933758946..a7e84b6bca 100644
--- a/scene/multiplayer/scene_cache_interface.cpp
+++ b/scene/multiplayer/scene_cache_interface.cpp
@@ -132,9 +132,9 @@ void SceneCacheInterface::process_confirm_path(int p_from, const uint8_t *p_pack
 	PathSentCache *psc = path_send_cache.getptr(path);
 	ERR_FAIL_COND_MSG(!psc, "Invalid packet received. Tries to confirm a path which was not found in cache.");
 
-	Map<int, bool>::Element *E = psc->confirmed_peers.find(p_from);
+	HashMap<int, bool>::Iterator E = psc->confirmed_peers.find(p_from);
 	ERR_FAIL_COND_MSG(!E, "Invalid packet received. Source peer was not found in cache for the given path.");
-	E->get() = true;
+	E->value = true;
 }
 
 Error SceneCacheInterface::_send_confirm_path(Node *p_node, NodePath p_path, PathSentCache *psc, const List<int> &p_peers) {
@@ -182,9 +182,9 @@ Error SceneCacheInterface::_send_confirm_path(Node *p_node, NodePath p_path, Pat
 bool SceneCacheInterface::is_cache_confirmed(NodePath p_path, int p_peer) {
 	const PathSentCache *psc = path_send_cache.getptr(p_path);
 	ERR_FAIL_COND_V(!psc, false);
-	const Map<int, bool>::Element *F = psc->confirmed_peers.find(p_peer);
+	HashMap<int, bool>::ConstIterator F = psc->confirmed_peers.find(p_peer);
 	ERR_FAIL_COND_V(!F, false); // Should never happen.
-	return F->get();
+	return F->value;
 }
 
 bool SceneCacheInterface::send_object_cache(Object *p_obj, NodePath p_path, int p_peer_id, int &r_id) {
@@ -205,16 +205,16 @@ bool SceneCacheInterface::send_object_cache(Object *p_obj, NodePath p_path, int
 
 	if (p_peer_id > 0) {
 		// Fast single peer check.
-		Map<int, bool>::Element *F = psc->confirmed_peers.find(p_peer_id);
+		HashMap<int, bool>::Iterator F = psc->confirmed_peers.find(p_peer_id);
 		if (!F) {
 			peers_to_add.push_back(p_peer_id); // Need to also be notified.
 			has_all_peers = false;
-		} else if (!F->get()) {
+		} else if (!F->value) {
 			has_all_peers = false;
 		}
 	} else {
 		// Long and painful.
-		for (const Set<int>::Element *E = multiplayer->get_connected_peers().front(); E; E = E->next()) {
+		for (const RBSet<int>::Element *E = multiplayer->get_connected_peers().front(); E; E = E->next()) {
 			if (p_peer_id < 0 && E->get() == -p_peer_id) {
 				continue; // Continue, excluded.
 			}
@@ -222,11 +222,11 @@ bool SceneCacheInterface::send_object_cache(Object *p_obj, NodePath p_path, int
 				continue; // Continue, not for this peer.
 			}
 
-			Map<int, bool>::Element *F = psc->confirmed_peers.find(E->get());
+			HashMap<int, bool>::Iterator F = psc->confirmed_peers.find(E->get());
 			if (!F) {
 				peers_to_add.push_back(E->get()); // Need to also be notified.
 				has_all_peers = false;
-			} else if (!F->get()) {
+			} else if (!F->value) {
 				has_all_peers = false;
 			}
 		}
@@ -242,13 +242,13 @@ bool SceneCacheInterface::send_object_cache(Object *p_obj, NodePath p_path, int
 Object *SceneCacheInterface::get_cached_object(int p_from, uint32_t p_cache_id) {
 	Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
 	ERR_FAIL_COND_V(!root_node, nullptr);
-	Map<int, PathGetCache>::Element *E = path_get_cache.find(p_from);
+	HashMap<int, PathGetCache>::Iterator E = path_get_cache.find(p_from);
 	ERR_FAIL_COND_V_MSG(!E, nullptr, vformat("No cache found for peer %d.", p_from));
 
-	Map<int, PathGetCache::NodeInfo>::Element *F = E->get().nodes.find(p_cache_id);
+	HashMap<int, PathGetCache::NodeInfo>::Iterator F = E->value.nodes.find(p_cache_id);
 	ERR_FAIL_COND_V_MSG(!F, nullptr, vformat("ID %d not found in cache of peer %d.", p_cache_id, p_from));
 
-	PathGetCache::NodeInfo *ni = &F->get();
+	PathGetCache::NodeInfo *ni = &F->value;
 	Node *node = root_node->get_node(ni->path);
 	if (!node) {
 		ERR_PRINT("Failed to get cached path: " + String(ni->path) + ".");
diff --git a/scene/multiplayer/scene_cache_interface.h b/scene/multiplayer/scene_cache_interface.h
index d53cf387fb..3116233b5b 100644
--- a/scene/multiplayer/scene_cache_interface.h
+++ b/scene/multiplayer/scene_cache_interface.h
@@ -41,7 +41,7 @@ private:
 
 	//path sent caches
 	struct PathSentCache {
-		Map<int, bool> confirmed_peers;
+		HashMap<int, bool> confirmed_peers;
 		int id;
 	};
 
@@ -52,11 +52,11 @@ private:
 			ObjectID instance;
 		};
 
-		Map<int, NodeInfo> nodes;
+		HashMap<int, NodeInfo> nodes;
 	};
 
 	HashMap<NodePath, PathSentCache> path_send_cache;
-	Map<int, PathGetCache> path_get_cache;
+	HashMap<int, PathGetCache> path_get_cache;
 	int last_send_cache_id = 1;
 
 protected:
diff --git a/scene/multiplayer/scene_replication_interface.cpp b/scene/multiplayer/scene_replication_interface.cpp
index 63259bcd39..55266c53ad 100644
--- a/scene/multiplayer/scene_replication_interface.cpp
+++ b/scene/multiplayer/scene_replication_interface.cpp
@@ -316,7 +316,7 @@ Error SceneReplicationInterface::on_despawn_receive(int p_from, const uint8_t *p
 }
 
 void SceneReplicationInterface::_send_sync(int p_peer, uint64_t p_msec) {
-	const Set<ObjectID> &known = rep_state->get_known_nodes(p_peer);
+	const RBSet<ObjectID> &known = rep_state->get_known_nodes(p_peer);
 	if (known.is_empty()) {
 		return;
 	}
diff --git a/scene/multiplayer/scene_replication_state.cpp b/scene/multiplayer/scene_replication_state.cpp
index 9a9b08b67b..e5cc57ff31 100644
--- a/scene/multiplayer/scene_replication_state.cpp
+++ b/scene/multiplayer/scene_replication_state.cpp
@@ -93,8 +93,8 @@ bool SceneReplicationState::update_sync_time(const ObjectID &p_id, uint64_t p_ms
 	return false;
 }
 
-const Set<ObjectID> SceneReplicationState::get_known_nodes(int p_peer) {
-	ERR_FAIL_COND_V(!peers_info.has(p_peer), Set<ObjectID>());
+const RBSet<ObjectID> SceneReplicationState::get_known_nodes(int p_peer) {
+	ERR_FAIL_COND_V(!peers_info.has(p_peer), RBSet<ObjectID>());
 	return peers_info[p_peer].known_nodes;
 }
 
diff --git a/scene/multiplayer/scene_replication_state.h b/scene/multiplayer/scene_replication_state.h
index 6ac9265b67..33f72363ac 100644
--- a/scene/multiplayer/scene_replication_state.h
+++ b/scene/multiplayer/scene_replication_state.h
@@ -62,27 +62,27 @@ private:
 	};
 
 	struct PeerInfo {
-		Set<ObjectID> known_nodes;
+		RBSet<ObjectID> known_nodes;
 		HashMap<uint32_t, ObjectID> recv_nodes;
 		uint16_t last_sent_sync = 0;
 		uint16_t last_recv_sync = 0;
 	};
 
-	Set<int> known_peers;
+	RBSet<int> known_peers;
 	uint32_t last_net_id = 0;
 	HashMap<ObjectID, TrackedNode> tracked_nodes;
 	HashMap<int, PeerInfo> peers_info;
-	Set<ObjectID> spawned_nodes;
-	Set<ObjectID> path_only_nodes;
+	RBSet<ObjectID> spawned_nodes;
+	RBSet<ObjectID> path_only_nodes;
 
 	TrackedNode &_track(const ObjectID &p_id);
 	void _untrack(const ObjectID &p_id);
 	bool is_tracked(const ObjectID &p_id) const { return tracked_nodes.has(p_id); }
 
 public:
-	const Set<int> get_peers() const { return known_peers; }
-	const Set<ObjectID> &get_spawned_nodes() const { return spawned_nodes; }
-	const Set<ObjectID> &get_path_only_nodes() const { return path_only_nodes; }
+	const RBSet<int> get_peers() const { return known_peers; }
+	const RBSet<ObjectID> &get_spawned_nodes() const { return spawned_nodes; }
+	const RBSet<ObjectID> &get_path_only_nodes() const { return path_only_nodes; }
 
 	MultiplayerSynchronizer *get_synchronizer(const ObjectID &p_id) { return tracked_nodes.has(p_id) ? tracked_nodes[p_id].get_synchronizer() : nullptr; }
 	MultiplayerSpawner *get_spawner(const ObjectID &p_id) { return tracked_nodes.has(p_id) ? tracked_nodes[p_id].get_spawner() : nullptr; }
@@ -90,7 +90,7 @@ public:
 	bool update_last_node_sync(const ObjectID &p_id, uint16_t p_time);
 	bool update_sync_time(const ObjectID &p_id, uint64_t p_msec);
 
-	const Set<ObjectID> get_known_nodes(int p_peer);
+	const RBSet<ObjectID> get_known_nodes(int p_peer);
 	uint32_t get_net_id(const ObjectID &p_id) const;
 	void set_net_id(const ObjectID &p_id, uint32_t p_net_id);
 	uint32_t ensure_net_id(const ObjectID &p_id);
diff --git a/scene/resources/animation_library.h b/scene/resources/animation_library.h
index 21f0162eb3..7a69cd140a 100644
--- a/scene/resources/animation_library.h
+++ b/scene/resources/animation_library.h
@@ -43,7 +43,7 @@ class AnimationLibrary : public Resource {
 	TypedArray<StringName> _get_animation_list() const;
 
 	friend class AnimationPlayer; //for faster access
-	Map<StringName, Ref<Animation>> animations;
+	HashMap<StringName, Ref<Animation>> animations;
 
 protected:
 	static void _bind_methods();
diff --git a/scene/resources/bit_map.cpp b/scene/resources/bit_map.cpp
index c2988c2e8c..634fb3ef2f 100644
--- a/scene/resources/bit_map.cpp
+++ b/scene/resources/bit_map.cpp
@@ -170,8 +170,8 @@ Vector<Vector2> BitMap::_march_square(const Rect2i &rect, const Point2i &start)
 	int curx = startx;
 	int cury = starty;
 	unsigned int count = 0;
-	Set<Point2i> case9s;
-	Set<Point2i> case6s;
+	RBSet<Point2i> case9s;
+	RBSet<Point2i> case6s;
 	Vector<Vector2> _points;
 	do {
 		int sv = 0;
diff --git a/scene/resources/canvas_item_material.cpp b/scene/resources/canvas_item_material.cpp
index 2d668cdf7f..aa6cc4aded 100644
--- a/scene/resources/canvas_item_material.cpp
+++ b/scene/resources/canvas_item_material.cpp
@@ -34,7 +34,7 @@
 
 Mutex CanvasItemMaterial::material_mutex;
 SelfList<CanvasItemMaterial>::List *CanvasItemMaterial::dirty_materials = nullptr;
-Map<CanvasItemMaterial::MaterialKey, CanvasItemMaterial::ShaderData> CanvasItemMaterial::shader_map;
+HashMap<CanvasItemMaterial::MaterialKey, CanvasItemMaterial::ShaderData, CanvasItemMaterial::MaterialKey> CanvasItemMaterial::shader_map;
 CanvasItemMaterial::ShaderNames *CanvasItemMaterial::shader_names = nullptr;
 
 void CanvasItemMaterial::init_shaders() {
diff --git a/scene/resources/canvas_item_material.h b/scene/resources/canvas_item_material.h
index b097d174f0..7c44c125a8 100644
--- a/scene/resources/canvas_item_material.h
+++ b/scene/resources/canvas_item_material.h
@@ -63,8 +63,11 @@ private:
 
 		uint32_t key = 0;
 
-		bool operator<(const MaterialKey &p_key) const {
-			return key < p_key.key;
+		static uint32_t hash(const MaterialKey &p_key) {
+			return hash_djb2_one_32(p_key.key);
+		}
+		bool operator==(const MaterialKey &p_key) const {
+			return key == p_key.key;
 		}
 	};
 
@@ -81,7 +84,7 @@ private:
 		int users = 0;
 	};
 
-	static Map<MaterialKey, ShaderData> shader_map;
+	static HashMap<MaterialKey, ShaderData, MaterialKey> shader_map;
 
 	MaterialKey current_key;
 
diff --git a/scene/resources/concave_polygon_shape_3d.cpp b/scene/resources/concave_polygon_shape_3d.cpp
index 3e178108c4..ab2c1da327 100644
--- a/scene/resources/concave_polygon_shape_3d.cpp
+++ b/scene/resources/concave_polygon_shape_3d.cpp
@@ -33,7 +33,7 @@
 #include "servers/physics_server_3d.h"
 
 Vector<Vector3> ConcavePolygonShape3D::get_debug_mesh_lines() const {
-	Set<DrawEdge> edges;
+	RBSet<DrawEdge> edges;
 
 	int index_count = faces.size();
 	ERR_FAIL_COND_V((index_count % 3) != 0, Vector<Vector3>());
@@ -50,7 +50,7 @@ Vector<Vector3> ConcavePolygonShape3D::get_debug_mesh_lines() const {
 	Vector<Vector3> points;
 	points.resize(edges.size() * 2);
 	int idx = 0;
-	for (Set<DrawEdge>::Element *E = edges.front(); E; E = E->next()) {
+	for (RBSet<DrawEdge>::Element *E = edges.front(); E; E = E->next()) {
 		points.write[idx + 0] = E->get().a;
 		points.write[idx + 1] = E->get().b;
 		idx += 2;
diff --git a/scene/resources/curve.cpp b/scene/resources/curve.cpp
index c719455a0a..34cbd3a360 100644
--- a/scene/resources/curve.cpp
+++ b/scene/resources/curve.cpp
@@ -632,7 +632,7 @@ Vector2 Curve2D::interpolatef(real_t p_findex) const {
 	return interpolate((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
 }
 
-void Curve2D::_bake_segment2d(Map<real_t, Vector2> &r_bake, real_t p_begin, real_t p_end, const Vector2 &p_a, const Vector2 &p_out, const Vector2 &p_b, const Vector2 &p_in, int p_depth, int p_max_depth, real_t p_tol) const {
+void Curve2D::_bake_segment2d(HashMap<real_t, Vector2> &r_bake, real_t p_begin, real_t p_end, const Vector2 &p_a, const Vector2 &p_out, const Vector2 &p_b, const Vector2 &p_in, int p_depth, int p_max_depth, real_t p_tol) const {
 	real_t mp = p_begin + (p_end - p_begin) * 0.5;
 	Vector2 beg = _bezier_interp(p_begin, p_a, p_a + p_out, p_b + p_in, p_b);
 	Vector2 mid = _bezier_interp(mp, p_a, p_a + p_out, p_b + p_in, p_b);
@@ -954,7 +954,7 @@ PackedVector2Array Curve2D::tessellate(int p_max_stages, real_t p_tolerance) con
 	if (points.size() == 0) {
 		return tess;
 	}
-	Vector<Map<real_t, Vector2>> midpoints;
+	Vector<HashMap<real_t, Vector2>> midpoints;
 
 	midpoints.resize(points.size() - 1);
 
@@ -1137,7 +1137,7 @@ Vector3 Curve3D::interpolatef(real_t p_findex) const {
 	return interpolate((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
 }
 
-void Curve3D::_bake_segment3d(Map<real_t, Vector3> &r_bake, real_t p_begin, real_t p_end, const Vector3 &p_a, const Vector3 &p_out, const Vector3 &p_b, const Vector3 &p_in, int p_depth, int p_max_depth, real_t p_tol) const {
+void Curve3D::_bake_segment3d(HashMap<real_t, Vector3> &r_bake, real_t p_begin, real_t p_end, const Vector3 &p_a, const Vector3 &p_out, const Vector3 &p_b, const Vector3 &p_in, int p_depth, int p_max_depth, real_t p_tol) const {
 	real_t mp = p_begin + (p_end - p_begin) * 0.5;
 	Vector3 beg = _bezier_interp(p_begin, p_a, p_a + p_out, p_b + p_in, p_b);
 	Vector3 mid = _bezier_interp(mp, p_a, p_a + p_out, p_b + p_in, p_b);
@@ -1668,7 +1668,7 @@ PackedVector3Array Curve3D::tessellate(int p_max_stages, real_t p_tolerance) con
 	if (points.size() == 0) {
 		return tess;
 	}
-	Vector<Map<real_t, Vector3>> midpoints;
+	Vector<HashMap<real_t, Vector3>> midpoints;
 
 	midpoints.resize(points.size() - 1);
 
diff --git a/scene/resources/curve.h b/scene/resources/curve.h
index 767900b843..f9b172f175 100644
--- a/scene/resources/curve.h
+++ b/scene/resources/curve.h
@@ -168,7 +168,7 @@ class Curve2D : public Resource {
 
 	real_t bake_interval = 5.0;
 
-	void _bake_segment2d(Map<real_t, Vector2> &r_bake, real_t p_begin, real_t p_end, const Vector2 &p_a, const Vector2 &p_out, const Vector2 &p_b, const Vector2 &p_in, int p_depth, int p_max_depth, real_t p_tol) const;
+	void _bake_segment2d(HashMap<real_t, Vector2> &r_bake, real_t p_begin, real_t p_end, const Vector2 &p_a, const Vector2 &p_out, const Vector2 &p_b, const Vector2 &p_in, int p_depth, int p_max_depth, real_t p_tol) const;
 	Dictionary _get_data() const;
 	void _set_data(const Dictionary &p_data);
 
@@ -233,7 +233,7 @@ class Curve3D : public Resource {
 	real_t bake_interval = 0.2;
 	bool up_vector_enabled = true;
 
-	void _bake_segment3d(Map<real_t, Vector3> &r_bake, real_t p_begin, real_t p_end, const Vector3 &p_a, const Vector3 &p_out, const Vector3 &p_b, const Vector3 &p_in, int p_depth, int p_max_depth, real_t p_tol) const;
+	void _bake_segment3d(HashMap<real_t, Vector3> &r_bake, real_t p_begin, real_t p_end, const Vector3 &p_a, const Vector3 &p_out, const Vector3 &p_b, const Vector3 &p_in, int p_depth, int p_max_depth, real_t p_tol) const;
 	Dictionary _get_data() const;
 	void _set_data(const Dictionary &p_data);
 
diff --git a/scene/resources/font.h b/scene/resources/font.h
index 9a90032605..96bfe3678b 100644
--- a/scene/resources/font.h
+++ b/scene/resources/font.h
@@ -33,7 +33,7 @@
 
 #include "core/io/resource.h"
 #include "core/templates/lru.h"
-#include "core/templates/map.h"
+#include "core/templates/rb_map.h"
 #include "scene/resources/texture.h"
 #include "servers/text_server.h"
 
diff --git a/scene/resources/importer_mesh.cpp b/scene/resources/importer_mesh.cpp
index cca875f708..0fbd29b1a6 100644
--- a/scene/resources/importer_mesh.cpp
+++ b/scene/resources/importer_mesh.cpp
@@ -306,7 +306,7 @@ void ImporterMesh::generate_lods(float p_normal_merge_angle, float p_normal_spli
 		float normal_split_threshold = Math::cos(Math::deg2rad(p_normal_split_angle));
 		const Vector3 *normals_ptr = normals.ptr();
 
-		Map<Vector3, LocalVector<Pair<int, int>>> unique_vertices;
+		HashMap<Vector3, LocalVector<Pair<int, int>>> unique_vertices;
 
 		LocalVector<int> vertex_remap;
 		LocalVector<int> vertex_inverse_remap;
@@ -320,10 +320,10 @@ void ImporterMesh::generate_lods(float p_normal_merge_angle, float p_normal_spli
 			const Vector3 &v = vertices_ptr[j];
 			const Vector3 &n = normals_ptr[j];
 
-			Map<Vector3, LocalVector<Pair<int, int>>>::Element *E = unique_vertices.find(v);
+			HashMap<Vector3, LocalVector<Pair<int, int>>>::Iterator E = unique_vertices.find(v);
 
 			if (E) {
-				const LocalVector<Pair<int, int>> &close_verts = E->get();
+				const LocalVector<Pair<int, int>> &close_verts = E->value;
 
 				bool found = false;
 				for (unsigned int k = 0; k < close_verts.size(); k++) {
@@ -706,15 +706,15 @@ void ImporterMesh::create_shadow_mesh() {
 		Vector<Vector3> vertices = surfaces[i].arrays[RS::ARRAY_VERTEX];
 		int vertex_count = vertices.size();
 		{
-			Map<Vector3, int> unique_vertices;
+			HashMap<Vector3, int> unique_vertices;
 			const Vector3 *vptr = vertices.ptr();
 			for (int j = 0; j < vertex_count; j++) {
 				const Vector3 &v = vptr[j];
 
-				Map<Vector3, int>::Element *E = unique_vertices.find(v);
+				HashMap<Vector3, int>::Iterator E = unique_vertices.find(v);
 
 				if (E) {
-					vertex_remap.push_back(E->get());
+					vertex_remap.push_back(E->value);
 				} else {
 					int vcount = unique_vertices.size();
 					unique_vertices[v] = vcount;
@@ -898,16 +898,16 @@ Vector<Ref<Shape3D>> ImporterMesh::convex_decompose(const Mesh::ConvexDecomposit
 	Vector<uint32_t> indices;
 	indices.resize(face_count * 3);
 	{
-		Map<Vector3, uint32_t> vertex_map;
+		HashMap<Vector3, uint32_t> vertex_map;
 		Vector3 *vertex_w = vertices.ptrw();
 		uint32_t *index_w = indices.ptrw();
 		for (int i = 0; i < face_count; i++) {
 			for (int j = 0; j < 3; j++) {
 				const Vector3 &vertex = faces[i].vertex[j];
-				Map<Vector3, uint32_t>::Element *found_vertex = vertex_map.find(vertex);
+				HashMap<Vector3, uint32_t>::Iterator found_vertex = vertex_map.find(vertex);
 				uint32_t index;
 				if (found_vertex) {
-					index = found_vertex->get();
+					index = found_vertex->value;
 				} else {
 					index = ++vertex_count;
 					vertex_map[vertex] = index;
@@ -960,7 +960,7 @@ Ref<NavigationMesh> ImporterMesh::create_navigation_mesh() {
 		return Ref<NavigationMesh>();
 	}
 
-	Map<Vector3, int> unique_vertices;
+	HashMap<Vector3, int> unique_vertices;
 	LocalVector<int> face_indices;
 
 	for (int i = 0; i < faces.size(); i++) {
diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 27e1590940..8abdfe713f 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -187,9 +187,9 @@ bool ShaderMaterial::_get(const StringName &p_name, Variant &r_ret) const {
 		}
 
 		if (pr) {
-			const Map<StringName, Variant>::Element *E = param_cache.find(pr);
+			HashMap<StringName, Variant>::ConstIterator E = param_cache.find(pr);
 			if (E) {
-				r_ret = E->get();
+				r_ret = E->value;
 			} else {
 				r_ret = Variant();
 			}
@@ -348,7 +348,7 @@ ShaderMaterial::~ShaderMaterial() {
 
 Mutex BaseMaterial3D::material_mutex;
 SelfList<BaseMaterial3D>::List *BaseMaterial3D::dirty_materials = nullptr;
-Map<BaseMaterial3D::MaterialKey, BaseMaterial3D::ShaderData> BaseMaterial3D::shader_map;
+HashMap<BaseMaterial3D::MaterialKey, BaseMaterial3D::ShaderData, BaseMaterial3D::MaterialKey> BaseMaterial3D::shader_map;
 BaseMaterial3D::ShaderNames *BaseMaterial3D::shader_names = nullptr;
 
 void BaseMaterial3D::init_shaders() {
diff --git a/scene/resources/material.h b/scene/resources/material.h
index 7edb8b7317..b845fd68c8 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -82,7 +82,7 @@ class ShaderMaterial : public Material {
 	GDCLASS(ShaderMaterial, Material);
 	Ref<Shader> shader;
 
-	Map<StringName, Variant> param_cache;
+	HashMap<StringName, Variant> param_cache;
 
 protected:
 	bool _set(const StringName &p_name, const Variant &p_value);
@@ -323,6 +323,9 @@ private:
 			memset(this, 0, sizeof(MaterialKey));
 		}
 
+		static uint32_t hash(const MaterialKey &p_key) {
+			return hash_djb2_buffer((const uint8_t *)&p_key, sizeof(MaterialKey));
+		}
 		bool operator==(const MaterialKey &p_key) const {
 			return memcmp(this, &p_key, sizeof(MaterialKey)) == 0;
 		}
@@ -337,7 +340,7 @@ private:
 		int users = 0;
 	};
 
-	static Map<MaterialKey, ShaderData> shader_map;
+	static HashMap<MaterialKey, ShaderData, MaterialKey> shader_map;
 
 	MaterialKey current_key;
 
diff --git a/scene/resources/mesh.cpp b/scene/resources/mesh.cpp
index 253ba53c35..ab1873ffe9 100644
--- a/scene/resources/mesh.cpp
+++ b/scene/resources/mesh.cpp
@@ -455,7 +455,7 @@ Ref<Mesh> Mesh::create_outline(float p_margin) const {
 			has_indices = true;
 		}
 
-		Map<Vector3, Vector3> normal_accum;
+		HashMap<Vector3, Vector3> normal_accum;
 
 		//fill normals with triangle normals
 		for (int i = 0; i < vc; i += 3) {
@@ -474,13 +474,13 @@ Ref<Mesh> Mesh::create_outline(float p_margin) const {
 			Vector3 n = Plane(t[0], t[1], t[2]).normal;
 
 			for (int j = 0; j < 3; j++) {
-				Map<Vector3, Vector3>::Element *E = normal_accum.find(t[j]);
+				HashMap<Vector3, Vector3>::Iterator E = normal_accum.find(t[j]);
 				if (!E) {
 					normal_accum[t[j]] = n;
 				} else {
-					float d = n.dot(E->get());
+					float d = n.dot(E->value);
 					if (d < 1.0) {
-						E->get() += n * (1.0 - d);
+						E->value += n * (1.0 - d);
 					}
 					//E->get()+=n;
 				}
@@ -499,10 +499,10 @@ Ref<Mesh> Mesh::create_outline(float p_margin) const {
 		for (int i = 0; i < vc2; i++) {
 			Vector3 t = r[i];
 
-			Map<Vector3, Vector3>::Element *E = normal_accum.find(t);
+			HashMap<Vector3, Vector3>::Iterator E = normal_accum.find(t);
 			ERR_CONTINUE(!E);
 
-			t += E->get() * p_margin;
+			t += E->value * p_margin;
 			r[i] = t;
 		}
 
diff --git a/scene/resources/mesh_data_tool.cpp b/scene/resources/mesh_data_tool.cpp
index 594f723a1d..33d63adc71 100644
--- a/scene/resources/mesh_data_tool.cpp
+++ b/scene/resources/mesh_data_tool.cpp
@@ -150,7 +150,7 @@ Error MeshDataTool::create_from_surface(const Ref<ArrayMesh> &p_mesh, int p_surf
 		vertices.write[i] = v;
 	}
 
-	Map<Point2i, int> edge_indices;
+	HashMap<Point2i, int> edge_indices;
 
 	for (int i = 0; i < icount; i += 3) {
 		Vertex *v[3] = { &vertices.write[r[i + 0]], &vertices.write[r[i + 1]], &vertices.write[r[i + 2]] };
diff --git a/scene/resources/mesh_library.h b/scene/resources/mesh_library.h
index e0f2ab2114..4105bd6960 100644
--- a/scene/resources/mesh_library.h
+++ b/scene/resources/mesh_library.h
@@ -32,7 +32,7 @@
 #define MESH_LIBRARY_H
 
 #include "core/io/resource.h"
-#include "core/templates/map.h"
+#include "core/templates/rb_map.h"
 #include "mesh.h"
 #include "scene/3d/navigation_region_3d.h"
 #include "shape_3d.h"
@@ -56,7 +56,7 @@ public:
 		Ref<NavigationMesh> navmesh;
 	};
 
-	Map<int, Item> item_map;
+	RBMap<int, Item> item_map;
 
 	void _set_item_shapes(int p_item, const Array &p_shapes);
 	Array _get_item_shapes(int p_item) const;
diff --git a/scene/resources/navigation_mesh.cpp b/scene/resources/navigation_mesh.cpp
index 552fa84bad..b1270e9dd6 100644
--- a/scene/resources/navigation_mesh.cpp
+++ b/scene/resources/navigation_mesh.cpp
@@ -338,7 +338,7 @@ Ref<Mesh> NavigationMesh::get_debug_mesh() {
 		}
 	}
 
-	Map<_EdgeKey, bool> edge_map;
+	HashMap<_EdgeKey, bool, _EdgeKey> edge_map;
 	Vector<Vector3> tmeshfaces;
 	tmeshfaces.resize(faces.size() * 3);
 
@@ -356,10 +356,10 @@ Ref<Mesh> NavigationMesh::get_debug_mesh() {
 					SWAP(ek.from, ek.to);
 				}
 
-				Map<_EdgeKey, bool>::Element *F = edge_map.find(ek);
+				HashMap<_EdgeKey, bool, _EdgeKey>::Iterator F = edge_map.find(ek);
 
 				if (F) {
-					F->get() = false;
+					F->value = false;
 
 				} else {
 					edge_map[ek] = true;
diff --git a/scene/resources/navigation_mesh.h b/scene/resources/navigation_mesh.h
index e43e8627e4..4d8611c3c9 100644
--- a/scene/resources/navigation_mesh.h
+++ b/scene/resources/navigation_mesh.h
@@ -49,7 +49,13 @@ class NavigationMesh : public Resource {
 		Vector3 from;
 		Vector3 to;
 
-		bool operator<(const _EdgeKey &p_with) const { return from == p_with.from ? to < p_with.to : from < p_with.from; }
+		static uint32_t hash(const _EdgeKey &p_key) {
+			return HashMapHasherDefault::hash(p_key.from) ^ HashMapHasherDefault::hash(p_key.to);
+		}
+
+		bool operator==(const _EdgeKey &p_with) const {
+			return HashMapComparatorDefault<Vector3>::compare(from, p_with.from) && HashMapComparatorDefault<Vector3>::compare(to, p_with.to);
+		}
 	};
 
 protected:
diff --git a/scene/resources/packed_scene.cpp b/scene/resources/packed_scene.cpp
index 12d1dc9925..c7b1981aed 100644
--- a/scene/resources/packed_scene.cpp
+++ b/scene/resources/packed_scene.cpp
@@ -53,7 +53,7 @@ static Array _sanitize_node_pinned_properties(Node *p_node) {
 	if (pinned.is_empty()) {
 		return Array();
 	}
-	Set<StringName> storable_properties;
+	RBSet<StringName> storable_properties;
 	p_node->get_storable_properties(storable_properties);
 	int i = 0;
 	do {
@@ -106,7 +106,7 @@ Node *SceneState::instantiate(GenEditState p_edit_state) const {
 
 	bool gen_node_path_cache = p_edit_state != GEN_EDIT_STATE_DISABLED && node_path_cache.is_empty();
 
-	Map<Ref<Resource>, Ref<Resource>> resources_local_to_scene;
+	HashMap<Ref<Resource>, Ref<Resource>> resources_local_to_scene;
 
 	for (int i = 0; i < nc; i++) {
 		const NodeData &n = nd[i];
@@ -257,10 +257,10 @@ Node *SceneState::instantiate(GenEditState p_edit_state) const {
 							Ref<Resource> res = value;
 							if (res.is_valid()) {
 								if (res->is_local_to_scene()) {
-									Map<Ref<Resource>, Ref<Resource>>::Element *E = resources_local_to_scene.find(res);
+									HashMap<Ref<Resource>, Ref<Resource>>::Iterator E = resources_local_to_scene.find(res);
 
 									if (E) {
-										value = E->get();
+										value = E->value;
 									} else {
 										Node *base = i == 0 ? node : ret_nodes[0];
 
@@ -430,7 +430,7 @@ Node *SceneState::instantiate(GenEditState p_edit_state) const {
 	return ret_nodes[0];
 }
 
-static int _nm_get_string(const String &p_string, Map<StringName, int> &name_map) {
+static int _nm_get_string(const String &p_string, HashMap<StringName, int> &name_map) {
 	if (name_map.has(p_string)) {
 		return name_map[p_string];
 	}
@@ -450,7 +450,7 @@ static int _vm_get_variant(const Variant &p_variant, HashMap<Variant, int, Varia
 	return idx;
 }
 
-Error SceneState::_parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map) {
+Error SceneState::_parse_node(Node *p_owner, Node *p_node, int p_parent_idx, HashMap<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, HashMap<Node *, int> &node_map, HashMap<Node *, int> &nodepath_map) {
 	// this function handles all the work related to properly packing scenes, be it
 	// instantiated or inherited.
 	// given the complexity of this process, an attempt will be made to properly
@@ -672,7 +672,7 @@ Error SceneState::_parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map
 	return OK;
 }
 
-Error SceneState::_parse_connections(Node *p_owner, Node *p_node, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map) {
+Error SceneState::_parse_connections(Node *p_owner, Node *p_node, HashMap<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, HashMap<Node *, int> &node_map, HashMap<Node *, int> &nodepath_map) {
 	if (p_node != p_owner && p_node->get_owner() && p_node->get_owner() != p_owner && !p_owner->is_editable_instance(p_node->get_owner())) {
 		return OK;
 	}
@@ -879,10 +879,10 @@ Error SceneState::pack(Node *p_scene) {
 
 	Node *scene = p_scene;
 
-	Map<StringName, int> name_map;
+	HashMap<StringName, int> name_map;
 	HashMap<Variant, int, VariantHasher, VariantComparator> variant_map;
-	Map<Node *, int> node_map;
-	Map<Node *, int> nodepath_map;
+	HashMap<Node *, int> node_map;
+	HashMap<Node *, int> nodepath_map;
 
 	// If using scene inheritance, pack the scene it inherits from.
 	if (scene->get_scene_inherited_state().is_valid()) {
diff --git a/scene/resources/packed_scene.h b/scene/resources/packed_scene.h
index 96222937d0..05abb23284 100644
--- a/scene/resources/packed_scene.h
+++ b/scene/resources/packed_scene.h
@@ -42,7 +42,7 @@ class SceneState : public RefCounted {
 	Vector<NodePath> node_paths;
 	Vector<NodePath> editable_instances;
 	mutable HashMap<NodePath, int> node_path_cache;
-	mutable Map<int, int> base_scene_node_remap;
+	mutable HashMap<int, int> base_scene_node_remap;
 
 	int base_scene_idx = -1;
 
@@ -83,8 +83,8 @@ class SceneState : public RefCounted {
 
 	Vector<ConnectionData> connections;
 
-	Error _parse_node(Node *p_owner, Node *p_node, int p_parent_idx, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map);
-	Error _parse_connections(Node *p_owner, Node *p_node, Map<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, Map<Node *, int> &node_map, Map<Node *, int> &nodepath_map);
+	Error _parse_node(Node *p_owner, Node *p_node, int p_parent_idx, HashMap<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, HashMap<Node *, int> &node_map, HashMap<Node *, int> &nodepath_map);
+	Error _parse_connections(Node *p_owner, Node *p_node, HashMap<StringName, int> &name_map, HashMap<Variant, int, VariantHasher, VariantComparator> &variant_map, HashMap<Node *, int> &node_map, HashMap<Node *, int> &nodepath_map);
 
 	String path;
 
@@ -225,7 +225,9 @@ public:
 
 	virtual void set_path(const String &p_path, bool p_take_over = false) override;
 #ifdef TOOLS_ENABLED
-	virtual void set_last_modified_time(uint64_t p_time) override { state->set_last_modified_time(p_time); }
+	virtual void set_last_modified_time(uint64_t p_time) override {
+		state->set_last_modified_time(p_time);
+	}
 
 #endif
 	Ref<SceneState> get_state() const;
diff --git a/scene/resources/particles_material.cpp b/scene/resources/particles_material.cpp
index 597d070285..587b84a11d 100644
--- a/scene/resources/particles_material.cpp
+++ b/scene/resources/particles_material.cpp
@@ -34,7 +34,7 @@
 
 Mutex ParticlesMaterial::material_mutex;
 SelfList<ParticlesMaterial>::List *ParticlesMaterial::dirty_materials = nullptr;
-Map<ParticlesMaterial::MaterialKey, ParticlesMaterial::ShaderData> ParticlesMaterial::shader_map;
+HashMap<ParticlesMaterial::MaterialKey, ParticlesMaterial::ShaderData, ParticlesMaterial::MaterialKey> ParticlesMaterial::shader_map;
 ParticlesMaterial::ShaderNames *ParticlesMaterial::shader_names = nullptr;
 
 void ParticlesMaterial::init_shaders() {
diff --git a/scene/resources/particles_material.h b/scene/resources/particles_material.h
index 4c3a3ba16c..24341d964d 100644
--- a/scene/resources/particles_material.h
+++ b/scene/resources/particles_material.h
@@ -109,6 +109,14 @@ private:
 
 		uint32_t key = 0;
 
+		static uint32_t hash(const MaterialKey &p_key) {
+			return hash_djb2_one_32(p_key.key);
+		}
+
+		bool operator==(const MaterialKey &p_key) const {
+			return key == p_key.key;
+		}
+
 		bool operator<(const MaterialKey &p_key) const {
 			return key < p_key.key;
 		}
@@ -119,7 +127,7 @@ private:
 		int users = 0;
 	};
 
-	static Map<MaterialKey, ShaderData> shader_map;
+	static HashMap<MaterialKey, ShaderData, MaterialKey> shader_map;
 
 	MaterialKey current_key;
 
diff --git a/scene/resources/polygon_path_finder.cpp b/scene/resources/polygon_path_finder.cpp
index 94e7f46ea5..155a8522cf 100644
--- a/scene/resources/polygon_path_finder.cpp
+++ b/scene/resources/polygon_path_finder.cpp
@@ -34,7 +34,7 @@
 bool PolygonPathFinder::_is_point_inside(const Vector2 &p_point) const {
 	int crosses = 0;
 
-	for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+	for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 		const Edge &e = E->get();
 
 		Vector2 a = points[e.points[0]].pos;
@@ -105,7 +105,7 @@ void PolygonPathFinder::setup(const Vector<Vector2> &p_points, const Vector<int>
 
 			bool valid = true;
 
-			for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+			for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 				const Edge &e = E->get();
 				if (e.points[0] == i || e.points[1] == i || e.points[0] == j || e.points[1] == j) {
 					continue;
@@ -140,7 +140,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 		float closest_dist = 1e20f;
 		Vector2 closest_point;
 
-		for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+		for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 			const Edge &e = E->get();
 			Vector2 seg[2] = {
 				points[e.points[0]].pos,
@@ -164,7 +164,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 		float closest_dist = 1e20f;
 		Vector2 closest_point;
 
-		for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+		for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 			const Edge &e = E->get();
 			Vector2 seg[2] = {
 				points[e.points[0]].pos,
@@ -188,7 +188,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 	{
 		bool can_see_eachother = true;
 
-		for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+		for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 			const Edge &e = E->get();
 			if (e.points[0] == ignore_from_edge.points[0] && e.points[1] == ignore_from_edge.points[1]) {
 				continue;
@@ -240,7 +240,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 			valid_b = false;
 		}
 
-		for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+		for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 			const Edge &e = E->get();
 
 			if (e.points[0] == i || e.points[1] == i) {
@@ -289,11 +289,11 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 	}
 	//solve graph
 
-	Set<int> open_list;
+	RBSet<int> open_list;
 
 	points.write[aidx].distance = 0;
 	points.write[aidx].prev = aidx;
-	for (Set<int>::Element *E = points[aidx].connections.front(); E; E = E->next()) {
+	for (RBSet<int>::Element *E = points[aidx].connections.front(); E; E = E->next()) {
 		open_list.insert(E->get());
 		points.write[E->get()].distance = from.distance_to(points[E->get()].pos);
 		points.write[E->get()].prev = aidx;
@@ -312,7 +312,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 		float least_cost = 1e30;
 
 		//this could be faster (cache previous results)
-		for (Set<int>::Element *E = open_list.front(); E; E = E->next()) {
+		for (RBSet<int>::Element *E = open_list.front(); E; E = E->next()) {
 			const Point &p = points[E->get()];
 			float cost = p.distance;
 			cost += p.pos.distance_to(to);
@@ -327,7 +327,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 		const Point &np = points[least_cost_point];
 		//open the neighbours for search
 
-		for (Set<int>::Element *E = np.connections.front(); E; E = E->next()) {
+		for (RBSet<int>::Element *E = np.connections.front(); E; E = E->next()) {
 			Point &p = points.write[E->get()];
 			float distance = np.pos.distance_to(p.pos) + np.distance;
 
@@ -459,7 +459,7 @@ Dictionary PolygonPathFinder::_get_data() const {
 			{
 				int *cw = c.ptrw();
 				int idx = 0;
-				for (Set<int>::Element *E = points[i].connections.front(); E; E = E->next()) {
+				for (RBSet<int>::Element *E = points[i].connections.front(); E; E = E->next()) {
 					cw[idx++] = E->get();
 				}
 			}
@@ -469,7 +469,7 @@ Dictionary PolygonPathFinder::_get_data() const {
 	{
 		int *iw = ind.ptrw();
 		int idx = 0;
-		for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+		for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 			iw[idx++] = E->get().points[0];
 			iw[idx++] = E->get().points[1];
 		}
@@ -492,7 +492,7 @@ Vector2 PolygonPathFinder::get_closest_point(const Vector2 &p_point) const {
 	float closest_dist = 1e20f;
 	Vector2 closest_point;
 
-	for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+	for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 		const Edge &e = E->get();
 		Vector2 seg[2] = {
 			points[e.points[0]].pos,
@@ -516,7 +516,7 @@ Vector2 PolygonPathFinder::get_closest_point(const Vector2 &p_point) const {
 Vector<Vector2> PolygonPathFinder::get_intersections(const Vector2 &p_from, const Vector2 &p_to) const {
 	Vector<Vector2> inters;
 
-	for (Set<Edge>::Element *E = edges.front(); E; E = E->next()) {
+	for (RBSet<Edge>::Element *E = edges.front(); E; E = E->next()) {
 		Vector2 a = points[E->get().points[0]].pos;
 		Vector2 b = points[E->get().points[1]].pos;
 
diff --git a/scene/resources/polygon_path_finder.h b/scene/resources/polygon_path_finder.h
index db96192917..71ad77eb6e 100644
--- a/scene/resources/polygon_path_finder.h
+++ b/scene/resources/polygon_path_finder.h
@@ -38,7 +38,7 @@ class PolygonPathFinder : public Resource {
 
 	struct Point {
 		Vector2 pos;
-		Set<int> connections;
+		RBSet<int> connections;
 		float distance = 0.0;
 		float penalty = 0.0;
 		int prev = 0;
@@ -68,7 +68,7 @@ class PolygonPathFinder : public Resource {
 	Rect2 bounds;
 
 	Vector<Point> points;
-	Set<Edge> edges;
+	RBSet<Edge> edges;
 
 	bool _is_point_inside(const Vector2 &p_point) const;
 
diff --git a/scene/resources/resource_format_text.cpp b/scene/resources/resource_format_text.cpp
index ae321fd9a7..193bd0ac05 100644
--- a/scene/resources/resource_format_text.cpp
+++ b/scene/resources/resource_format_text.cpp
@@ -867,7 +867,7 @@ void ResourceLoaderText::get_dependencies(Ref<FileAccess> p_f, List<String> *p_d
 	}
 }
 
-Error ResourceLoaderText::rename_dependencies(Ref<FileAccess> p_f, const String &p_path, const Map<String, String> &p_map) {
+Error ResourceLoaderText::rename_dependencies(Ref<FileAccess> p_f, const String &p_path, const HashMap<String, String> &p_map) {
 	open(p_f, true);
 	ERR_FAIL_COND_V(error != OK, error);
 	ignore_resource_parsing = true;
@@ -1232,7 +1232,7 @@ Error ResourceLoaderText::save_as_binary(Ref<FileAccess> p_f, const String &p_pa
 				}
 
 				if (!assign.is_empty()) {
-					Map<StringName, int> empty_string_map; //unused
+					HashMap<StringName, int> empty_string_map; //unused
 					bs_save_unicode_string(wf2, assign, true);
 					ResourceFormatSaverBinaryInstance::write_variant(wf2, value, dummy_read.resource_index_map, dummy_read.external_resources, empty_string_map);
 					prop_count++;
@@ -1293,7 +1293,7 @@ Error ResourceLoaderText::save_as_binary(Ref<FileAccess> p_f, const String &p_pa
 				String name = E.name;
 				Variant value = packed_scene->get(name);
 
-				Map<StringName, int> empty_string_map; //unused
+				HashMap<StringName, int> empty_string_map; //unused
 				bs_save_unicode_string(wf2, name, true);
 				ResourceFormatSaverBinaryInstance::write_variant(wf2, value, dummy_read.resource_index_map, dummy_read.external_resources, empty_string_map);
 				prop_count++;
@@ -1507,7 +1507,7 @@ void ResourceFormatLoaderText::get_dependencies(const String &p_path, List<Strin
 	loader.get_dependencies(f, p_dependencies, p_add_types);
 }
 
-Error ResourceFormatLoaderText::rename_dependencies(const String &p_path, const Map<String, String> &p_map) {
+Error ResourceFormatLoaderText::rename_dependencies(const String &p_path, const HashMap<String, String> &p_map) {
 	Error err = OK;
 	{
 		Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ);
@@ -1737,7 +1737,7 @@ Error ResourceFormatSaverTextInstance::save(const String &p_path, const Ref<Reso
 
 #ifdef TOOLS_ENABLED
 	// Keep order from cached ids.
-	Set<String> cached_ids_found;
+	RBSet<String> cached_ids_found;
 	for (KeyValue<Ref<Resource>, String> &E : external_resources) {
 		String cached_id = E.key->get_id_for_path(local_path);
 		if (cached_id.is_empty() || cached_ids_found.has(cached_id)) {
@@ -1809,7 +1809,7 @@ Error ResourceFormatSaverTextInstance::save(const String &p_path, const Ref<Reso
 		f->store_line(String()); // Separate.
 	}
 
-	Set<String> used_unique_ids;
+	RBSet<String> used_unique_ids;
 
 	for (List<Ref<Resource>>::Element *E = saved_resources.front(); E; E = E->next()) {
 		Ref<Resource> res = E->get();
diff --git a/scene/resources/resource_format_text.h b/scene/resources/resource_format_text.h
index e67df72d7e..adab503599 100644
--- a/scene/resources/resource_format_text.h
+++ b/scene/resources/resource_format_text.h
@@ -58,8 +58,8 @@ class ResourceLoaderText {
 
 	bool ignore_resource_parsing = false;
 
-	Map<String, ExtResource> ext_resources;
-	Map<String, Ref<Resource>> int_resources;
+	HashMap<String, ExtResource> ext_resources;
+	HashMap<String, Ref<Resource>> int_resources;
 
 	int resources_total = 0;
 	int resource_current = 0;
@@ -76,7 +76,7 @@ class ResourceLoaderText {
 
 	ResourceUID::ID res_uid = ResourceUID::INVALID_ID;
 
-	Map<String, String> remaps;
+	HashMap<String, String> remaps;
 
 	static Error _parse_sub_resources(void *p_self, VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) { return reinterpret_cast<ResourceLoaderText *>(p_self)->_parse_sub_resource(p_stream, r_res, line, r_err_str); }
 	static Error _parse_ext_resources(void *p_self, VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) { return reinterpret_cast<ResourceLoaderText *>(p_self)->_parse_ext_resource(p_stream, r_res, line, r_err_str); }
@@ -90,10 +90,10 @@ class ResourceLoaderText {
 	};
 
 	struct DummyReadData {
-		Map<Ref<Resource>, int> external_resources;
-		Map<String, Ref<Resource>> rev_external_resources;
-		Map<Ref<Resource>, int> resource_index_map;
-		Map<String, Ref<Resource>> resource_map;
+		HashMap<Ref<Resource>, int> external_resources;
+		HashMap<String, Ref<Resource>> rev_external_resources;
+		HashMap<Ref<Resource>, int> resource_index_map;
+		HashMap<String, Ref<Resource>> resource_map;
 	};
 
 	static Error _parse_sub_resource_dummys(void *p_self, VariantParser::Stream *p_stream, Ref<Resource> &r_res, int &line, String &r_err_str) { return _parse_sub_resource_dummy(static_cast<DummyReadData *>(p_self), p_stream, r_res, line, r_err_str); }
@@ -124,7 +124,7 @@ public:
 	String recognize(Ref<FileAccess> p_f);
 	ResourceUID::ID get_uid(Ref<FileAccess> p_f);
 	void get_dependencies(Ref<FileAccess> p_f, List<String> *p_dependencies, bool p_add_types);
-	Error rename_dependencies(Ref<FileAccess> p_f, const String &p_path, const Map<String, String> &p_map);
+	Error rename_dependencies(Ref<FileAccess> p_f, const String &p_path, const HashMap<String, String> &p_map);
 
 	Error save_as_binary(Ref<FileAccess> p_f, const String &p_path);
 	ResourceLoaderText();
@@ -140,7 +140,7 @@ public:
 	virtual String get_resource_type(const String &p_path) const;
 	virtual ResourceUID::ID get_resource_uid(const String &p_path) const;
 	virtual void get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types = false);
-	virtual Error rename_dependencies(const String &p_path, const Map<String, String> &p_map);
+	virtual Error rename_dependencies(const String &p_path, const HashMap<String, String> &p_map);
 
 	static Error convert_file_to_binary(const String &p_src_path, const String &p_dst_path);
 
@@ -163,12 +163,12 @@ class ResourceFormatSaverTextInstance {
 		bool operator<(const NonPersistentKey &p_key) const { return base == p_key.base ? property < p_key.property : base < p_key.base; }
 	};
 
-	Map<NonPersistentKey, Ref<Resource>> non_persistent_map;
+	RBMap<NonPersistentKey, Ref<Resource>> non_persistent_map;
 
-	Set<Ref<Resource>> resource_set;
+	RBSet<Ref<Resource>> resource_set;
 	List<Ref<Resource>> saved_resources;
-	Map<Ref<Resource>, String> external_resources;
-	Map<Ref<Resource>, String> internal_resources;
+	HashMap<Ref<Resource>, String> external_resources;
+	HashMap<Ref<Resource>, String> internal_resources;
 
 	struct ResourceSort {
 		Ref<Resource> resource;
diff --git a/scene/resources/shader.cpp b/scene/resources/shader.cpp
index 6b1f89454f..d49157b1b8 100644
--- a/scene/resources/shader.cpp
+++ b/scene/resources/shader.cpp
@@ -100,7 +100,7 @@ RID Shader::get_rid() const {
 void Shader::set_default_texture_param(const StringName &p_param, const Ref<Texture2D> &p_texture, int p_index) {
 	if (p_texture.is_valid()) {
 		if (!default_textures.has(p_param)) {
-			default_textures[p_param] = Map<int, Ref<Texture2D>>();
+			default_textures[p_param] = HashMap<int, Ref<Texture2D>>();
 		}
 		default_textures[p_param][p_index] = p_texture;
 		RS::get_singleton()->shader_set_default_texture_param(shader, p_param, p_texture->get_rid(), p_index);
@@ -126,7 +126,7 @@ Ref<Texture2D> Shader::get_default_texture_param(const StringName &p_param, int
 }
 
 void Shader::get_default_texture_param_list(List<StringName> *r_textures) const {
-	for (const KeyValue<StringName, Map<int, Ref<Texture2D>>> &E : default_textures) {
+	for (const KeyValue<StringName, HashMap<int, Ref<Texture2D>>> &E : default_textures) {
 		r_textures->push_back(E.key);
 	}
 }
diff --git a/scene/resources/shader.h b/scene/resources/shader.h
index 3212dcd287..11c9f60ce8 100644
--- a/scene/resources/shader.h
+++ b/scene/resources/shader.h
@@ -58,8 +58,8 @@ private:
 	// shaders keep a list of ShaderMaterial -> RenderingServer name translations, to make
 	// conversion fast and save memory.
 	mutable bool params_cache_dirty = true;
-	mutable Map<StringName, StringName> params_cache; //map a shader param to a material param..
-	Map<StringName, Map<int, Ref<Texture2D>>> default_textures;
+	mutable HashMap<StringName, StringName> params_cache; //map a shader param to a material param..
+	HashMap<StringName, HashMap<int, Ref<Texture2D>>> default_textures;
 
 	virtual void _update_shader() const; //used for visual shader
 protected:
@@ -86,9 +86,9 @@ public:
 			get_param_list(nullptr);
 		}
 
-		const Map<StringName, StringName>::Element *E = params_cache.find(p_param);
+		const HashMap<StringName, StringName>::Iterator E = params_cache.find(p_param);
 		if (E) {
-			return E->get();
+			return E->value;
 		}
 		return StringName();
 	}
diff --git a/scene/resources/sprite_frames.cpp b/scene/resources/sprite_frames.cpp
index ff5a85392c..ba21b9fd17 100644
--- a/scene/resources/sprite_frames.cpp
+++ b/scene/resources/sprite_frames.cpp
@@ -33,38 +33,38 @@
 #include "scene/scene_string_names.h"
 
 void SpriteFrames::add_frame(const StringName &p_anim, const Ref<Texture2D> &p_frame, int p_at_pos) {
-	Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 	ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
 
-	if (p_at_pos >= 0 && p_at_pos < E->get().frames.size()) {
-		E->get().frames.insert(p_at_pos, p_frame);
+	if (p_at_pos >= 0 && p_at_pos < E->value.frames.size()) {
+		E->value.frames.insert(p_at_pos, p_frame);
 	} else {
-		E->get().frames.push_back(p_frame);
+		E->value.frames.push_back(p_frame);
 	}
 
 	emit_changed();
 }
 
 int SpriteFrames::get_frame_count(const StringName &p_anim) const {
-	const Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::ConstIterator E = animations.find(p_anim);
 	ERR_FAIL_COND_V_MSG(!E, 0, "Animation '" + String(p_anim) + "' doesn't exist.");
 
-	return E->get().frames.size();
+	return E->value.frames.size();
 }
 
 void SpriteFrames::remove_frame(const StringName &p_anim, int p_idx) {
-	Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 	ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
 
-	E->get().frames.remove_at(p_idx);
+	E->value.frames.remove_at(p_idx);
 	emit_changed();
 }
 
 void SpriteFrames::clear(const StringName &p_anim) {
-	Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 	ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
 
-	E->get().frames.clear();
+	E->value.frames.clear();
 	emit_changed();
 }
 
@@ -124,37 +124,37 @@ Vector<String> SpriteFrames::get_animation_names() const {
 
 void SpriteFrames::set_animation_speed(const StringName &p_anim, double p_fps) {
 	ERR_FAIL_COND_MSG(p_fps < 0, "Animation speed cannot be negative (" + itos(p_fps) + ").");
-	Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 	ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
-	E->get().speed = p_fps;
+	E->value.speed = p_fps;
 }
 
 double SpriteFrames::get_animation_speed(const StringName &p_anim) const {
-	const Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::ConstIterator E = animations.find(p_anim);
 	ERR_FAIL_COND_V_MSG(!E, 0, "Animation '" + String(p_anim) + "' doesn't exist.");
-	return E->get().speed;
+	return E->value.speed;
 }
 
 void SpriteFrames::set_animation_loop(const StringName &p_anim, bool p_loop) {
-	Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 	ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
-	E->get().loop = p_loop;
+	E->value.loop = p_loop;
 }
 
 bool SpriteFrames::get_animation_loop(const StringName &p_anim) const {
-	const Map<StringName, Anim>::Element *E = animations.find(p_anim);
+	HashMap<StringName, Anim>::ConstIterator E = animations.find(p_anim);
 	ERR_FAIL_COND_V_MSG(!E, false, "Animation '" + String(p_anim) + "' doesn't exist.");
-	return E->get().loop;
+	return E->value.loop;
 }
 
 void SpriteFrames::_set_frames(const Array &p_frames) {
 	clear_all();
-	Map<StringName, Anim>::Element *E = animations.find(SceneStringNames::get_singleton()->_default);
+	HashMap<StringName, Anim>::Iterator E = animations.find(SceneStringNames::get_singleton()->_default);
 	ERR_FAIL_COND(!E);
 
-	E->get().frames.resize(p_frames.size());
-	for (int i = 0; i < E->get().frames.size(); i++) {
-		E->get().frames.write[i] = p_frames[i];
+	E->value.frames.resize(p_frames.size());
+	for (int i = 0; i < E->value.frames.size(); i++) {
+		E->value.frames.write[i] = p_frames[i];
 	}
 }
 
diff --git a/scene/resources/sprite_frames.h b/scene/resources/sprite_frames.h
index 12b69afde1..e32ccc1336 100644
--- a/scene/resources/sprite_frames.h
+++ b/scene/resources/sprite_frames.h
@@ -42,7 +42,7 @@ class SpriteFrames : public Resource {
 		Vector<Ref<Texture2D>> frames;
 	};
 
-	Map<StringName, Anim> animations;
+	HashMap<StringName, Anim> animations;
 
 	Array _get_frames() const;
 	void _set_frames(const Array &p_frames);
@@ -73,24 +73,24 @@ public:
 	void add_frame(const StringName &p_anim, const Ref<Texture2D> &p_frame, int p_at_pos = -1);
 	int get_frame_count(const StringName &p_anim) const;
 	_FORCE_INLINE_ Ref<Texture2D> get_frame(const StringName &p_anim, int p_idx) const {
-		const Map<StringName, Anim>::Element *E = animations.find(p_anim);
+		HashMap<StringName, Anim>::ConstIterator E = animations.find(p_anim);
 		ERR_FAIL_COND_V_MSG(!E, Ref<Texture2D>(), "Animation '" + String(p_anim) + "' doesn't exist.");
 		ERR_FAIL_COND_V(p_idx < 0, Ref<Texture2D>());
-		if (p_idx >= E->get().frames.size()) {
+		if (p_idx >= E->value.frames.size()) {
 			return Ref<Texture2D>();
 		}
 
-		return E->get().frames[p_idx];
+		return E->value.frames[p_idx];
 	}
 
 	void set_frame(const StringName &p_anim, int p_idx, const Ref<Texture2D> &p_frame) {
-		Map<StringName, Anim>::Element *E = animations.find(p_anim);
+		HashMap<StringName, Anim>::Iterator E = animations.find(p_anim);
 		ERR_FAIL_COND_MSG(!E, "Animation '" + String(p_anim) + "' doesn't exist.");
 		ERR_FAIL_COND(p_idx < 0);
-		if (p_idx >= E->get().frames.size()) {
+		if (p_idx >= E->value.frames.size()) {
 			return;
 		}
-		E->get().frames.write[p_idx] = p_frame;
+		E->value.frames.write[p_idx] = p_frame;
 	}
 	void remove_frame(const StringName &p_anim, int p_idx);
 	void clear(const StringName &p_anim);
diff --git a/scene/resources/syntax_highlighter.h b/scene/resources/syntax_highlighter.h
index 143f1679c6..1243a9dbf7 100644
--- a/scene/resources/syntax_highlighter.h
+++ b/scene/resources/syntax_highlighter.h
@@ -41,7 +41,7 @@ class SyntaxHighlighter : public Resource {
 	GDCLASS(SyntaxHighlighter, Resource)
 
 private:
-	Map<int, Dictionary> highlighting_cache;
+	RBMap<int, Dictionary> highlighting_cache;
 	void _lines_edited_from(int p_from_line, int p_to_line);
 
 protected:
@@ -83,7 +83,7 @@ private:
 		bool line_only = false;
 	};
 	Vector<ColorRegion> color_regions;
-	Map<int, int> color_region_cache;
+	HashMap<int, int> color_region_cache;
 
 	Dictionary keywords;
 	Dictionary member_keywords;
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index 67b82af617..06c7ecda90 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -1345,19 +1345,19 @@ int TileSet::get_patterns_count() {
 	return patterns.size();
 }
 
-Set<TileSet::TerrainsPattern> TileSet::get_terrains_pattern_set(int p_terrain_set) {
-	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), Set<TileSet::TerrainsPattern>());
+RBSet<TileSet::TerrainsPattern> TileSet::get_terrains_pattern_set(int p_terrain_set) {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet<TileSet::TerrainsPattern>());
 	_update_terrains_cache();
 
-	Set<TileSet::TerrainsPattern> output;
-	for (KeyValue<TileSet::TerrainsPattern, Set<TileMapCell>> kv : per_terrain_pattern_tiles[p_terrain_set]) {
+	RBSet<TileSet::TerrainsPattern> output;
+	for (KeyValue<TileSet::TerrainsPattern, RBSet<TileMapCell>> kv : per_terrain_pattern_tiles[p_terrain_set]) {
 		output.insert(kv.key);
 	}
 	return output;
 }
 
-Set<TileMapCell> TileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) {
-	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), Set<TileMapCell>());
+RBSet<TileMapCell> TileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet<TileMapCell>());
 	_update_terrains_cache();
 	return per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
 }
@@ -1368,8 +1368,8 @@ TileMapCell TileSet::get_random_tile_from_terrains_pattern(int p_terrain_set, Ti
 
 	// Count the sum of probabilities.
 	double sum = 0.0;
-	Set<TileMapCell> set = per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
-	for (Set<TileMapCell>::Element *E = set.front(); E; E = E->next()) {
+	RBSet<TileMapCell> set = per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
+	for (RBSet<TileMapCell>::Element *E = set.front(); E; E = E->next()) {
 		if (E->get().source_id >= 0) {
 			Ref<TileSetSource> source = sources[E->get().source_id];
 			Ref<TileSetAtlasSource> atlas_source = source;
@@ -1389,7 +1389,7 @@ TileMapCell TileSet::get_random_tile_from_terrains_pattern(int p_terrain_set, Ti
 	double picked = Math::random(0.0, sum);
 
 	// Pick the tile.
-	for (Set<TileMapCell>::Element *E = set.front(); E; E = E->next()) {
+	for (RBSet<TileMapCell>::Element *E = set.front(); E; E = E->next()) {
 		if (E->get().source_id >= 0) {
 			Ref<TileSetSource> source = sources[E->get().source_id];
 
@@ -2391,7 +2391,7 @@ void TileSet::_compatibility_conversion() {
 					value_array.push_back(alternative_tile);
 
 					if (!compatibility_tilemap_mapping.has(E.key)) {
-						compatibility_tilemap_mapping[E.key] = Map<Array, Array>();
+						compatibility_tilemap_mapping[E.key] = RBMap<Array, Array>();
 					}
 					compatibility_tilemap_mapping[E.key][key_array] = value_array;
 					compatibility_tilemap_mapping_tile_modes[E.key] = COMPATIBILITY_TILE_MODE_SINGLE_TILE;
@@ -2483,7 +2483,7 @@ void TileSet::_compatibility_conversion() {
 							value_array.push_back(alternative_tile);
 
 							if (!compatibility_tilemap_mapping.has(E.key)) {
-								compatibility_tilemap_mapping[E.key] = Map<Array, Array>();
+								compatibility_tilemap_mapping[E.key] = RBMap<Array, Array>();
 							}
 							compatibility_tilemap_mapping[E.key][key_array] = value_array;
 							compatibility_tilemap_mapping_tile_modes[E.key] = COMPATIBILITY_TILE_MODE_ATLAS_TILE;
@@ -2571,7 +2571,7 @@ void TileSet::_compatibility_conversion() {
 	for (const KeyValue<int, CompatibilityTileData *> &E : compatibility_data) {
 		memdelete(E.value);
 	}
-	compatibility_data = Map<int, CompatibilityTileData *>();
+	compatibility_data = HashMap<int, CompatibilityTileData *>();
 }
 
 Array TileSet::compatibility_tilemap_map(int p_tile_id, Vector2i p_coords, bool p_flip_h, bool p_flip_v, bool p_transpose) {
@@ -2622,12 +2622,12 @@ bool TileSet::_set(const StringName &p_name, const Variant &p_value) {
 
 		// Get or create the compatibility object
 		CompatibilityTileData *ctd;
-		Map<int, CompatibilityTileData *>::Element *E = compatibility_data.find(id);
+		HashMap<int, CompatibilityTileData *>::Iterator E = compatibility_data.find(id);
 		if (!E) {
 			ctd = memnew(CompatibilityTileData);
 			compatibility_data.insert(id, ctd);
 		} else {
-			ctd = E->get();
+			ctd = E->value;
 		}
 
 		if (components.size() < 2) {
diff --git a/scene/resources/tile_set.h b/scene/resources/tile_set.h
index 95de46c9ab..633e1f4bed 100644
--- a/scene/resources/tile_set.h
+++ b/scene/resources/tile_set.h
@@ -69,6 +69,11 @@ union TileMapCell {
 	};
 
 	uint64_t _u64t;
+
+	static uint32_t hash(const TileMapCell &p_hash) {
+		return hash_one_uint64(p_hash._u64t);
+	}
+
 	TileMapCell(int p_source_id = -1, Vector2i p_atlas_coords = Vector2i(-1, -1), int p_alternative_tile = -1) { // default are INVALID_SOURCE, INVALID_ATLAS_COORDS, INVALID_TILE_ALTERNATIVE
 		source_id = p_source_id;
 		set_atlas_coords(p_atlas_coords);
@@ -103,13 +108,16 @@ union TileMapCell {
 	bool operator!=(const TileMapCell &p_other) const {
 		return !(source_id == p_other.source_id && coord_x == p_other.coord_x && coord_y == p_other.coord_y && alternative_tile == p_other.alternative_tile);
 	}
+	bool operator==(const TileMapCell &p_other) const {
+		return source_id == p_other.source_id && coord_x == p_other.coord_x && coord_y == p_other.coord_y && alternative_tile == p_other.alternative_tile;
+	}
 };
 
 class TileMapPattern : public Resource {
 	GDCLASS(TileMapPattern, Resource);
 
 	Vector2i size;
-	Map<Vector2i, TileMapCell> pattern;
+	HashMap<Vector2i, TileMapCell> pattern;
 
 	void _set_tile_data(const Vector<int> &p_data);
 	Vector<int> _get_tile_data() const;
@@ -166,11 +174,11 @@ private:
 		Size2i autotile_tile_size = Size2i(16, 16);
 
 		int autotile_spacing = 0;
-		Map<Vector2i, int> autotile_bitmask_flags;
-		Map<Vector2i, Ref<OccluderPolygon2D>> autotile_occluder_map;
-		Map<Vector2i, Ref<NavigationPolygon>> autotile_navpoly_map;
-		Map<Vector2i, int> autotile_priority_map;
-		Map<Vector2i, int> autotile_z_index_map;
+		HashMap<Vector2i, int> autotile_bitmask_flags;
+		HashMap<Vector2i, Ref<OccluderPolygon2D>> autotile_occluder_map;
+		HashMap<Vector2i, Ref<NavigationPolygon>> autotile_navpoly_map;
+		HashMap<Vector2i, int> autotile_priority_map;
+		HashMap<Vector2i, int> autotile_z_index_map;
 
 		Vector<CompatibilityShapeData> shapes;
 		Ref<OccluderPolygon2D> occluder;
@@ -186,9 +194,9 @@ private:
 		COMPATIBILITY_TILE_MODE_ATLAS_TILE,
 	};
 
-	Map<int, CompatibilityTileData *> compatibility_data;
-	Map<int, int> compatibility_tilemap_mapping_tile_modes;
-	Map<int, Map<Array, Array>> compatibility_tilemap_mapping;
+	HashMap<int, CompatibilityTileData *> compatibility_data;
+	HashMap<int, int> compatibility_tilemap_mapping_tile_modes;
+	HashMap<int, RBMap<Array, Array>> compatibility_tilemap_mapping;
 
 	void _compatibility_conversion();
 
@@ -324,10 +332,10 @@ private:
 	};
 	Vector<TerrainSet> terrain_sets;
 
-	Map<TerrainMode, Map<CellNeighbor, Ref<ArrayMesh>>> terrain_bits_meshes;
+	HashMap<TerrainMode, HashMap<CellNeighbor, Ref<ArrayMesh>>> terrain_bits_meshes;
 	bool terrain_bits_meshes_dirty = true;
 
-	LocalVector<Map<TileSet::TerrainsPattern, Set<TileMapCell>>> per_terrain_pattern_tiles; // Cached data.
+	LocalVector<RBMap<TileSet::TerrainsPattern, RBSet<TileMapCell>>> per_terrain_pattern_tiles; // Cached data.
 	bool terrains_cache_dirty = true;
 	void _update_terrains_cache();
 
@@ -343,10 +351,10 @@ private:
 		Variant::Type type = Variant::NIL;
 	};
 	Vector<CustomDataLayer> custom_data_layers;
-	Map<String, int> custom_data_layers_by_name;
+	HashMap<String, int> custom_data_layers_by_name;
 
 	// Per Atlas source data.
-	Map<int, Ref<TileSetSource>> sources;
+	HashMap<int, Ref<TileSetSource>> sources;
 	Vector<int> source_ids;
 	int next_source_id = 0;
 	// ---------------------
@@ -357,9 +365,9 @@ private:
 	void _source_changed();
 
 	// Tile proxies
-	Map<int, int> source_level_proxies;
-	Map<Array, Array> coords_level_proxies;
-	Map<Array, Array> alternative_level_proxies;
+	RBMap<int, int> source_level_proxies;
+	RBMap<Array, Array> coords_level_proxies;
+	RBMap<Array, Array> alternative_level_proxies;
 
 	// Helpers
 	Vector<Point2> _get_square_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
@@ -499,8 +507,8 @@ public:
 	int get_patterns_count();
 
 	// Terrains.
-	Set<TerrainsPattern> get_terrains_pattern_set(int p_terrain_set);
-	Set<TileMapCell> get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern);
+	RBSet<TerrainsPattern> get_terrains_pattern_set(int p_terrain_set);
+	RBSet<TileMapCell> get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern);
 	TileMapCell get_random_tile_from_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern);
 
 	// Helpers
@@ -579,7 +587,7 @@ private:
 		LocalVector<real_t> animation_frames_durations;
 
 		// Alternatives
-		Map<int, TileData *> alternatives;
+		HashMap<int, TileData *> alternatives;
 		Vector<int> alternatives_ids;
 		int next_alternative_id = 1;
 	};
@@ -589,9 +597,9 @@ private:
 	Vector2i separation;
 	Size2i texture_region_size = Size2i(16, 16);
 
-	Map<Vector2i, TileAlternativesData> tiles;
+	HashMap<Vector2i, TileAlternativesData> tiles;
 	Vector<Vector2i> tiles_ids;
-	Map<Vector2i, Vector2i> _coords_mapping_cache; // Maps any coordinate to the including tile
+	HashMap<Vector2i, Vector2i> _coords_mapping_cache; // Maps any coordinate to the including tile
 
 	TileData *_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile);
 	const TileData *_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) const;
@@ -716,7 +724,7 @@ private:
 		bool display_placeholder = false;
 	};
 	Vector<int> scenes_ids;
-	Map<int, SceneData> scenes;
+	HashMap<int, SceneData> scenes;
 	int next_scene_id = 1;
 
 	void _compute_next_alternative_id();
diff --git a/scene/resources/visual_shader.cpp b/scene/resources/visual_shader.cpp
index 6848011228..3c14e9f950 100644
--- a/scene/resources/visual_shader.cpp
+++ b/scene/resources/visual_shader.cpp
@@ -345,8 +345,8 @@ Vector<StringName> VisualShaderNode::get_editable_properties() const {
 	return Vector<StringName>();
 }
 
-Map<StringName, String> VisualShaderNode::get_editable_properties_names() const {
-	return Map<StringName, String>();
+HashMap<StringName, String> VisualShaderNode::get_editable_properties_names() const {
+	return HashMap<StringName, String>();
 }
 
 Array VisualShaderNode::get_default_input_values() const {
@@ -1178,16 +1178,16 @@ String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port
 
 	StringBuilder global_code;
 	StringBuilder global_code_per_node;
-	Map<Type, StringBuilder> global_code_per_func;
+	HashMap<Type, StringBuilder> global_code_per_func;
 	StringBuilder code;
-	Set<StringName> classes;
+	RBSet<StringName> classes;
 
 	global_code += String() + "shader_type canvas_item;\n";
 
 	String global_expressions;
 	for (int i = 0, index = 0; i < TYPE_MAX; i++) {
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			Ref<VisualShaderNodeGlobalExpression> global_expression = Object::cast_to<VisualShaderNodeGlobalExpression>(E->get().node.ptr());
+		for (const KeyValue<int, Node> &E : graph[i].nodes) {
+			Ref<VisualShaderNodeGlobalExpression> global_expression = E.value.node;
 			if (global_expression.is_valid()) {
 				String expr = "";
 				expr += "// " + global_expression->get_caption() + ":" + itos(index++) + "\n";
@@ -1222,7 +1222,7 @@ String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port
 
 	code += "\nvoid fragment() {\n";
 
-	Set<int> processed;
+	RBSet<int> processed;
 	Error err = _write_node(p_type, &global_code, &global_code_per_node, &global_code_per_func, code, default_tex_params, input_connections, output_connections, p_node, processed, true, classes);
 	ERR_FAIL_COND_V(err != OK, String());
 
@@ -1550,8 +1550,8 @@ void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
 	p_list->push_back(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Node3D,CanvasItem,Particles,Sky,Fog"));
 	//render modes
 
-	Map<String, String> blend_mode_enums;
-	Set<String> toggles;
+	HashMap<String, String> blend_mode_enums;
+	RBSet<String> toggles;
 
 	const Vector<ShaderLanguage::ModeInfo> &rmodes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(shader_mode));
 
@@ -1579,7 +1579,7 @@ void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
 		p_list->push_back(PropertyInfo(Variant::INT, "modes/" + E.key, PROPERTY_HINT_ENUM, E.value));
 	}
 
-	for (Set<String>::Element *E = toggles.front(); E; E = E->next()) {
+	for (RBSet<String>::Element *E = toggles.front(); E; E = E->next()) {
 		p_list->push_back(PropertyInfo(Variant::BOOL, "flags/" + E->get()));
 	}
 
@@ -1611,7 +1611,7 @@ void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
 	}
 }
 
-Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBuilder *global_code_per_node, Map<Type, StringBuilder> *global_code_per_func, StringBuilder &code, Vector<VisualShader::DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, Set<int> &processed, bool for_preview, Set<StringName> &r_classes) const {
+Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBuilder *global_code_per_node, HashMap<Type, StringBuilder> *global_code_per_func, StringBuilder &code, Vector<VisualShader::DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, RBSet<int> &processed, bool for_preview, RBSet<StringName> &r_classes) const {
 	const Ref<VisualShaderNode> vsnode = graph[type].nodes[node].node;
 
 	if (vsnode->is_disabled()) {
@@ -1903,7 +1903,7 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 	int output_count = vsnode->get_output_port_count();
 	int initial_output_count = output_count;
 
-	Map<int, bool> expanded_output_ports;
+	HashMap<int, bool> expanded_output_ports;
 
 	for (int i = 0; i < initial_output_count; i++) {
 		bool expanded = false;
@@ -2133,11 +2133,11 @@ void VisualShader::_update_shader() const {
 
 	StringBuilder global_code;
 	StringBuilder global_code_per_node;
-	Map<Type, StringBuilder> global_code_per_func;
+	HashMap<Type, StringBuilder> global_code_per_func;
 	StringBuilder code;
 	Vector<VisualShader::DefaultTextureParam> default_tex_params;
-	Set<StringName> classes;
-	Map<int, int> insertion_pos;
+	RBSet<StringName> classes;
+	HashMap<int, int> insertion_pos;
 	static const char *shader_mode_str[Shader::MODE_MAX] = { "spatial", "canvas_item", "particles", "sky", "fog" };
 
 	global_code += String() + "shader_type " + shader_mode_str[shader_mode] + ";\n";
@@ -2181,18 +2181,18 @@ void VisualShader::_update_shader() const {
 	static const char *func_name[TYPE_MAX] = { "vertex", "fragment", "light", "start", "process", "collide", "start_custom", "process_custom", "sky", "fog" };
 
 	String global_expressions;
-	Set<String> used_uniform_names;
+	RBSet<String> used_uniform_names;
 	List<VisualShaderNodeUniform *> uniforms;
-	Map<int, List<int>> emitters;
-	Map<int, List<int>> varying_setters;
+	HashMap<int, List<int>> emitters;
+	HashMap<int, List<int>> varying_setters;
 
 	for (int i = 0, index = 0; i < TYPE_MAX; i++) {
 		if (!has_func_name(RenderingServer::ShaderMode(shader_mode), func_name[i])) {
 			continue;
 		}
 
-		for (Map<int, Node>::Element *E = graph[i].nodes.front(); E; E = E->next()) {
-			Ref<VisualShaderNodeGlobalExpression> global_expression = Object::cast_to<VisualShaderNodeGlobalExpression>(E->get().node.ptr());
+		for (const KeyValue<int, Node> &E : graph[i].nodes) {
+			Ref<VisualShaderNodeGlobalExpression> global_expression = E.value.node;
 			if (global_expression.is_valid()) {
 				String expr = "";
 				expr += "// " + global_expression->get_caption() + ":" + itos(index++) + "\n";
@@ -2201,27 +2201,27 @@ void VisualShader::_update_shader() const {
 				expr += "\n";
 				global_expressions += expr;
 			}
-			Ref<VisualShaderNodeUniformRef> uniform_ref = Object::cast_to<VisualShaderNodeUniformRef>(E->get().node.ptr());
+			Ref<VisualShaderNodeUniformRef> uniform_ref = E.value.node;
 			if (uniform_ref.is_valid()) {
 				used_uniform_names.insert(uniform_ref->get_uniform_name());
 			}
-			Ref<VisualShaderNodeUniform> uniform = Object::cast_to<VisualShaderNodeUniform>(E->get().node.ptr());
+			Ref<VisualShaderNodeUniform> uniform = E.value.node;
 			if (uniform.is_valid()) {
 				uniforms.push_back(uniform.ptr());
 			}
-			Ref<VisualShaderNodeVaryingSetter> varying_setter = Object::cast_to<VisualShaderNodeVaryingSetter>(E->get().node.ptr());
+			Ref<VisualShaderNodeVaryingSetter> varying_setter = E.value.node;
 			if (varying_setter.is_valid() && varying_setter->is_input_port_connected(0)) {
 				if (!varying_setters.has(i)) {
 					varying_setters.insert(i, List<int>());
 				}
-				varying_setters[i].push_back(E->key());
+				varying_setters[i].push_back(E.key);
 			}
-			Ref<VisualShaderNodeParticleEmit> emit_particle = Object::cast_to<VisualShaderNodeParticleEmit>(E->get().node.ptr());
+			Ref<VisualShaderNodeParticleEmit> emit_particle = E.value.node;
 			if (emit_particle.is_valid()) {
 				if (!emitters.has(i)) {
 					emitters.insert(i, List<int>());
 				}
-				emitters[i].push_back(E->key());
+				emitters[i].push_back(E.key);
 			}
 		}
 	}
@@ -2269,8 +2269,8 @@ void VisualShader::_update_shader() const {
 		global_code += "\n";
 	}
 
-	Map<int, String> code_map;
-	Set<int> empty_funcs;
+	HashMap<int, String> code_map;
+	RBSet<int> empty_funcs;
 
 	for (int i = 0; i < TYPE_MAX; i++) {
 		if (!has_func_name(RenderingServer::ShaderMode(shader_mode), func_name[i])) {
@@ -2282,7 +2282,7 @@ void VisualShader::_update_shader() const {
 		VMap<ConnectionKey, const List<Connection>::Element *> output_connections;
 
 		StringBuilder func_code;
-		Set<int> processed;
+		RBSet<int> processed;
 
 		bool is_empty_func = false;
 		if (shader_mode != Shader::MODE_PARTICLES && shader_mode != Shader::MODE_SKY && shader_mode != Shader::MODE_FOG) {
diff --git a/scene/resources/visual_shader.h b/scene/resources/visual_shader.h
index aaf570d98c..aa5263943b 100644
--- a/scene/resources/visual_shader.h
+++ b/scene/resources/visual_shader.h
@@ -127,7 +127,7 @@ private:
 	};
 
 	struct Graph {
-		Map<int, Node> nodes;
+		RBMap<int, Node> nodes;
 		List<Connection> connections;
 	} graph[TYPE_MAX];
 
@@ -139,9 +139,9 @@ private:
 	Vector2 graph_offset;
 
 	HashMap<String, int> modes;
-	Set<StringName> flags;
+	RBSet<StringName> flags;
 
-	Map<String, Varying> varyings;
+	HashMap<String, Varying> varyings;
 	List<Varying> varyings_list;
 
 	mutable SafeFlag dirty;
@@ -158,7 +158,7 @@ private:
 		}
 	};
 
-	Error _write_node(Type p_type, StringBuilder *global_code, StringBuilder *global_code_per_node, Map<Type, StringBuilder> *global_code_per_func, StringBuilder &code, Vector<DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, Set<int> &processed, bool for_preview, Set<StringName> &r_classes) const;
+	Error _write_node(Type p_type, StringBuilder *global_code, StringBuilder *global_code_per_node, HashMap<Type, StringBuilder> *global_code_per_func, StringBuilder &code, Vector<DefaultTextureParam> &def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &output_connections, int node, RBSet<int> &processed, bool for_preview, RBSet<StringName> &r_classes) const;
 
 	void _input_type_changed(Type p_type, int p_id);
 	bool has_func_name(RenderingServer::ShaderMode p_mode, const String &p_func_name) const;
@@ -255,10 +255,10 @@ class VisualShaderNode : public Resource {
 
 	int port_preview = -1;
 
-	Map<int, Variant> default_input_values;
-	Map<int, bool> connected_input_ports;
-	Map<int, int> connected_output_ports;
-	Map<int, bool> expanded_output_ports;
+	HashMap<int, Variant> default_input_values;
+	HashMap<int, bool> connected_input_ports;
+	HashMap<int, int> connected_output_ports;
+	HashMap<int, bool> expanded_output_ports;
 
 protected:
 	bool simple_decl = true;
@@ -328,7 +328,7 @@ public:
 	void set_disabled(bool p_disabled = true);
 
 	virtual Vector<StringName> get_editable_properties() const;
-	virtual Map<StringName, String> get_editable_properties_names() const;
+	virtual HashMap<StringName, String> get_editable_properties_names() const;
 
 	virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const;
 	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const;
@@ -680,9 +680,9 @@ protected:
 		String name;
 	};
 
-	Map<int, Port> input_ports;
-	Map<int, Port> output_ports;
-	Map<int, Control *> controls;
+	HashMap<int, Port> input_ports;
+	HashMap<int, Port> output_ports;
+	HashMap<int, Control *> controls;
 
 protected:
 	static void _bind_methods();
diff --git a/scene/resources/visual_shader_nodes.cpp b/scene/resources/visual_shader_nodes.cpp
index 6af34a8a82..dbd45793f9 100644
--- a/scene/resources/visual_shader_nodes.cpp
+++ b/scene/resources/visual_shader_nodes.cpp
@@ -5782,8 +5782,8 @@ bool VisualShaderNodeTextureUniform::is_show_prop_names() const {
 	return true;
 }
 
-Map<StringName, String> VisualShaderNodeTextureUniform::get_editable_properties_names() const {
-	Map<StringName, String> names;
+HashMap<StringName, String> VisualShaderNodeTextureUniform::get_editable_properties_names() const {
+	HashMap<StringName, String> names;
 	names.insert("texture_type", RTR("Type"));
 	names.insert("color_default", RTR("Default Color"));
 	names.insert("texture_filter", RTR("Filter"));
diff --git a/scene/resources/visual_shader_nodes.h b/scene/resources/visual_shader_nodes.h
index 338f1157d3..b159d25eba 100644
--- a/scene/resources/visual_shader_nodes.h
+++ b/scene/resources/visual_shader_nodes.h
@@ -2175,7 +2175,7 @@ public:
 	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
 	virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const override;
 
-	virtual Map<StringName, String> get_editable_properties_names() const override;
+	virtual HashMap<StringName, String> get_editable_properties_names() const override;
 	virtual bool is_show_prop_names() const override;
 
 	Vector<StringName> get_editable_properties() const override;
diff --git a/scene/resources/visual_shader_particle_nodes.cpp b/scene/resources/visual_shader_particle_nodes.cpp
index 0879f2e735..54df935168 100644
--- a/scene/resources/visual_shader_particle_nodes.cpp
+++ b/scene/resources/visual_shader_particle_nodes.cpp
@@ -74,8 +74,8 @@ Vector<StringName> VisualShaderNodeParticleEmitter::get_editable_properties() co
 	return props;
 }
 
-Map<StringName, String> VisualShaderNodeParticleEmitter::get_editable_properties_names() const {
-	Map<StringName, String> names;
+HashMap<StringName, String> VisualShaderNodeParticleEmitter::get_editable_properties_names() const {
+	HashMap<StringName, String> names;
 	names.insert("mode_2d", RTR("2D Mode"));
 	return names;
 }
@@ -704,8 +704,8 @@ Vector<StringName> VisualShaderNodeParticleMeshEmitter::get_editable_properties(
 	return props;
 }
 
-Map<StringName, String> VisualShaderNodeParticleMeshEmitter::get_editable_properties_names() const {
-	Map<StringName, String> names = VisualShaderNodeParticleEmitter::get_editable_properties_names();
+HashMap<StringName, String> VisualShaderNodeParticleMeshEmitter::get_editable_properties_names() const {
+	HashMap<StringName, String> names = VisualShaderNodeParticleEmitter::get_editable_properties_names();
 
 	names.insert("mesh", RTR("Mesh"));
 	names.insert("use_all_surfaces", RTR("Use All Surfaces"));
diff --git a/scene/resources/visual_shader_particle_nodes.h b/scene/resources/visual_shader_particle_nodes.h
index 0b91cba5e0..05a059373b 100644
--- a/scene/resources/visual_shader_particle_nodes.h
+++ b/scene/resources/visual_shader_particle_nodes.h
@@ -52,7 +52,7 @@ public:
 	bool is_mode_2d() const;
 
 	Vector<StringName> get_editable_properties() const override;
-	virtual Map<StringName, String> get_editable_properties_names() const override;
+	virtual HashMap<StringName, String> get_editable_properties_names() const override;
 	bool is_show_prop_names() const override;
 
 	VisualShaderNodeParticleEmitter();
@@ -153,7 +153,7 @@ public:
 	int get_surface_index() const;
 
 	Vector<StringName> get_editable_properties() const override;
-	Map<StringName, String> get_editable_properties_names() const override;
+	HashMap<StringName, String> get_editable_properties_names() const override;
 	Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
 
 	VisualShaderNodeParticleMeshEmitter();
diff --git a/scene/resources/world_2d.h b/scene/resources/world_2d.h
index 4a277c3d84..71ae40ec82 100644
--- a/scene/resources/world_2d.h
+++ b/scene/resources/world_2d.h
@@ -46,7 +46,7 @@ class World2D : public Resource {
 	RID space;
 	RID navigation_map;
 
-	Set<Viewport *> viewports;
+	RBSet<Viewport *> viewports;
 
 protected:
 	static void _bind_methods();
@@ -62,7 +62,7 @@ public:
 
 	PhysicsDirectSpaceState2D *get_direct_space_state();
 
-	_FORCE_INLINE_ const Set<Viewport *> &get_viewports() { return viewports; }
+	_FORCE_INLINE_ const RBSet<Viewport *> &get_viewports() { return viewports; }
 
 	World2D();
 	~World2D();
diff --git a/scene/resources/world_3d.h b/scene/resources/world_3d.h
index b34b7a2bfb..18d28e812f 100644
--- a/scene/resources/world_3d.h
+++ b/scene/resources/world_3d.h
@@ -53,7 +53,7 @@ private:
 	Ref<Environment> fallback_environment;
 	Ref<CameraEffects> camera_effects;
 
-	Set<Camera3D *> cameras;
+	RBSet<Camera3D *> cameras;
 
 protected:
 	static void _bind_methods();
@@ -77,7 +77,7 @@ public:
 	void set_camera_effects(const Ref<CameraEffects> &p_camera_effects);
 	Ref<CameraEffects> get_camera_effects() const;
 
-	_FORCE_INLINE_ const Set<Camera3D *> &get_cameras() const { return cameras; }
+	_FORCE_INLINE_ const RBSet<Camera3D *> &get_cameras() const { return cameras; }
 
 	PhysicsDirectSpaceState3D *get_direct_space_state();