Add a new HashSet template

* Intended to replace RBSet in most cases. * Optimized for iteration speed
author: reduz <reduzio@gmail.com> 2022-05-19 17:00:06 +0200
committer: reduz <reduzio@gmail.com> 2022-05-20 22:40:38 +0200
commit: 45af29da8095af16729955117a165d23e77cd740 (patch)
tree: 0436c59187702466a73d05caf9688a58e5935afd
parent: 410893ad0fb6f0d7d774b6529581d886defd6cf0 (diff)
243 files changed, 1400 insertions, 662 deletions
diff --git a/core/config/project_settings.h b/core/config/project_settings.h
index bacc8adc54..d9b1a9b81b 100644
--- a/core/config/project_settings.h
+++ b/core/config/project_settings.h
@@ -91,7 +91,7 @@ protected:
 	bool using_datapack = false;
 	List<String> input_presets;
 
-	RBSet<String> custom_features;
+	HashSet<String> custom_features;
 	HashMap<StringName, StringName> feature_overrides;
 
 	HashMap<StringName, AutoloadInfo> autoloads;
diff --git a/core/debugger/local_debugger.cpp b/core/debugger/local_debugger.cpp
index f378ba94c3..06e08081e9 100644
--- a/core/debugger/local_debugger.cpp
+++ b/core/debugger/local_debugger.cpp
@@ -241,15 +241,15 @@ void LocalDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 
 		} else if (line.begins_with("br") || line.begins_with("break")) {
 			if (line.get_slice_count(" ") <= 1) {
-				const HashMap<int, RBSet<StringName>> &breakpoints = script_debugger->get_breakpoints();
+				const HashMap<int, HashSet<StringName>> &breakpoints = script_debugger->get_breakpoints();
 				if (breakpoints.size() == 0) {
 					print_line("No Breakpoints.");
 					continue;
 				}
 
 				print_line("Breakpoint(s): " + itos(breakpoints.size()));
-				for (const KeyValue<int, RBSet<StringName>> &E : breakpoints) {
-					print_line("\t" + String(E.value.front()->get()) + ":" + itos(E.key));
+				for (const KeyValue<int, HashSet<StringName>> &E : breakpoints) {
+					print_line("\t" + String(*E.value.begin()) + ":" + itos(E.key));
 				}
 
 			} else {
diff --git a/core/debugger/script_debugger.cpp b/core/debugger/script_debugger.cpp
index 1efa7f7690..e30f3e7886 100644
--- a/core/debugger/script_debugger.cpp
+++ b/core/debugger/script_debugger.cpp
@@ -50,7 +50,7 @@ int ScriptDebugger::get_depth() const {
 
 void ScriptDebugger::insert_breakpoint(int p_line, const StringName &p_source) {
 	if (!breakpoints.has(p_line)) {
-		breakpoints[p_line] = RBSet<StringName>();
+		breakpoints[p_line] = HashSet<StringName>();
 	}
 	breakpoints[p_line].insert(p_source);
 }
diff --git a/core/debugger/script_debugger.h b/core/debugger/script_debugger.h
index a5a72d7c54..5124b357a5 100644
--- a/core/debugger/script_debugger.h
+++ b/core/debugger/script_debugger.h
@@ -33,8 +33,8 @@
 
 #include "core/object/script_language.h"
 #include "core/string/string_name.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/rb_map.h"
-#include "core/templates/rb_set.h"
 #include "core/templates/vector.h"
 
 class ScriptDebugger {
@@ -44,7 +44,7 @@ class ScriptDebugger {
 	int depth = -1;
 	bool skip_breakpoints = false;
 
-	HashMap<int, RBSet<StringName>> breakpoints;
+	HashMap<int, HashSet<StringName>> breakpoints;
 
 	ScriptLanguage *break_lang = nullptr;
 	Vector<StackInfo> error_stack_info;
@@ -66,7 +66,7 @@ public:
 	bool is_breakpoint(int p_line, const StringName &p_source) const;
 	bool is_breakpoint_line(int p_line) const;
 	void clear_breakpoints();
-	const HashMap<int, RBSet<StringName>> &get_breakpoints() const { return breakpoints; }
+	const HashMap<int, HashSet<StringName>> &get_breakpoints() const { return breakpoints; }
 
 	void debug(ScriptLanguage *p_lang, bool p_can_continue = true, bool p_is_error_breakpoint = false);
 	ScriptLanguage *get_break_language() const;
diff --git a/core/input/input.h b/core/input/input.h
index 7bb7889a43..9a5b8e6e06 100644
--- a/core/input/input.h
+++ b/core/input/input.h
@@ -35,6 +35,7 @@
 #include "core/object/object.h"
 #include "core/os/keyboard.h"
 #include "core/os/thread_safe.h"
+#include "core/templates/rb_set.h"
 
 class Input : public Object {
 	GDCLASS(Input, Object);
diff --git a/core/io/file_access_pack.h b/core/io/file_access_pack.h
index 404ad38c96..19a0cce796 100644
--- a/core/io/file_access_pack.h
+++ b/core/io/file_access_pack.h
@@ -34,9 +34,9 @@
 #include "core/io/dir_access.h"
 #include "core/io/file_access.h"
 #include "core/string/print_string.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/list.h"
 #include "core/templates/rb_map.h"
-#include "core/templates/rb_set.h"
 
 // Godot's packed file magic header ("GDPC" in ASCII).
 #define PACK_HEADER_MAGIC 0x43504447
@@ -73,7 +73,7 @@ private:
 		PackedDir *parent = nullptr;
 		String name;
 		HashMap<String, PackedDir *> subdirs;
-		RBSet<String> files;
+		HashSet<String> files;
 	};
 
 	struct PathMD5 {
diff --git a/core/io/json.cpp b/core/io/json.cpp
index b3a9762e75..4c4d91f851 100644
--- a/core/io/json.cpp
+++ b/core/io/json.cpp
@@ -55,7 +55,7 @@ String JSON::_make_indent(const String &p_indent, int p_size) {
 	return indent_text;
 }
 
-String JSON::_stringify(const Variant &p_var, const String &p_indent, int p_cur_indent, bool p_sort_keys, RBSet<const void *> &p_markers, bool p_full_precision) {
+String JSON::_stringify(const Variant &p_var, const String &p_indent, int p_cur_indent, bool p_sort_keys, HashSet<const void *> &p_markers, bool p_full_precision) {
 	String colon = ":";
 	String end_statement = "";
 
@@ -529,7 +529,7 @@ Error JSON::_parse_string(const String &p_json, Variant &r_ret, String &r_err_st
 }
 
 String JSON::stringify(const Variant &p_var, const String &p_indent, bool p_sort_keys, bool p_full_precision) {
-	RBSet<const void *> markers;
+	HashSet<const void *> markers;
 	return _stringify(p_var, p_indent, 0, p_sort_keys, markers, p_full_precision);
 }
 
diff --git a/core/io/json.h b/core/io/json.h
index f883d3963a..6ba0a8c76b 100644
--- a/core/io/json.h
+++ b/core/io/json.h
@@ -70,7 +70,7 @@ class JSON : public RefCounted {
 	static const char *tk_name[];
 
 	static String _make_indent(const String &p_indent, int p_size);
-	static String _stringify(const Variant &p_var, const String &p_indent, int p_cur_indent, bool p_sort_keys, RBSet<const void *> &p_markers, bool p_full_precision = false);
+	static String _stringify(const Variant &p_var, const String &p_indent, int p_cur_indent, bool p_sort_keys, HashSet<const void *> &p_markers, bool p_full_precision = false);
 	static Error _get_token(const char32_t *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str);
 	static Error _parse_value(Variant &value, Token &token, const char32_t *p_str, int &index, int p_len, int &line, String &r_err_str);
 	static Error _parse_array(Array &array, const char32_t *p_str, int &index, int p_len, int &line, String &r_err_str);
diff --git a/core/io/logger.cpp b/core/io/logger.cpp
index 925bfdbd02..0418825009 100644
--- a/core/io/logger.cpp
+++ b/core/io/logger.cpp
@@ -128,7 +128,7 @@ void RotatedFileLogger::clear_old_backups() {
 
 	da->list_dir_begin();
 	String f = da->get_next();
-	RBSet<String> backups;
+	HashSet<String> backups;
 	while (!f.is_empty()) {
 		if (!da->current_is_dir() && f.begins_with(basename) && f.get_extension() == extension && f != base_path.get_file()) {
 			backups.insert(f);
@@ -137,12 +137,12 @@ void RotatedFileLogger::clear_old_backups() {
 	}
 	da->list_dir_end();
 
-	if (backups.size() > max_backups) {
+	if (backups.size() > (uint32_t)max_backups) {
 		// since backups are appended with timestamp and Set iterates them in sorted order,
 		// first backups are the oldest
 		int to_delete = backups.size() - max_backups;
-		for (RBSet<String>::Element *E = backups.front(); E && to_delete > 0; E = E->next(), --to_delete) {
-			da->remove(E->get());
+		for (HashSet<String>::Iterator E = backups.begin(); E && to_delete > 0; ++E, --to_delete) {
+			da->remove(*E);
 		}
 	}
 }
diff --git a/core/io/resource.h b/core/io/resource.h
index 53c828f9cd..a45bc6e1e4 100644
--- a/core/io/resource.h
+++ b/core/io/resource.h
@@ -54,7 +54,7 @@ public:
 	virtual String get_base_extension() const { return "res"; }
 
 private:
-	RBSet<ObjectID> owners;
+	HashSet<ObjectID> owners;
 
 	friend class ResBase;
 	friend class ResourceCache;
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index cf87869a32..cb634632c8 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -2022,7 +2022,7 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const Ref<Re
 	// save internal resource table
 	f->store_32(saved_resources.size()); //amount of internal resources
 	Vector<uint64_t> ofs_pos;
-	RBSet<String> used_unique_ids;
+	HashSet<String> used_unique_ids;
 
 	for (Ref<Resource> &r : saved_resources) {
 		if (r->is_built_in()) {
diff --git a/core/io/resource_format_binary.h b/core/io/resource_format_binary.h
index db29909dd5..5da880ddb8 100644
--- a/core/io/resource_format_binary.h
+++ b/core/io/resource_format_binary.h
@@ -127,7 +127,7 @@ class ResourceFormatSaverBinaryInstance {
 	bool big_endian;
 	bool takeover_paths;
 	String magic;
-	RBSet<Ref<Resource>> resource_set;
+	HashSet<Ref<Resource>> resource_set;
 
 	struct NonPersistentKey { //for resource properties generated on the fly
 		Ref<Resource> base;
diff --git a/core/io/resource_importer.cpp b/core/io/resource_importer.cpp
index 5deee9721b..934cb780e6 100644
--- a/core/io/resource_importer.cpp
+++ b/core/io/resource_importer.cpp
@@ -139,7 +139,7 @@ Ref<Resource> ResourceFormatImporter::load(const String &p_path, const String &p
 }
 
 void ResourceFormatImporter::get_recognized_extensions(List<String> *p_extensions) const {
-	RBSet<String> found;
+	HashSet<String> found;
 
 	for (int i = 0; i < importers.size(); i++) {
 		List<String> local_exts;
@@ -159,7 +159,7 @@ void ResourceFormatImporter::get_recognized_extensions_for_type(const String &p_
 		return;
 	}
 
-	RBSet<String> found;
+	HashSet<String> found;
 
 	for (int i = 0; i < importers.size(); i++) {
 		String res_type = importers[i]->get_resource_type();
diff --git a/core/io/resource_loader.h b/core/io/resource_loader.h
index e189ad1dff..815dd1dd72 100644
--- a/core/io/resource_loader.h
+++ b/core/io/resource_loader.h
@@ -145,7 +145,7 @@ private:
 		bool start_next = true;
 		int requests = 0;
 		int poll_requests = 0;
-		RBSet<String> sub_tasks;
+		HashSet<String> sub_tasks;
 	};
 
 	static void _thread_load_function(void *p_userdata);
diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp
index 29aa959e54..efa970c681 100644
--- a/core/math/a_star.cpp
+++ b/core/math/a_star.cpp
@@ -151,15 +151,15 @@ void AStar3D::connect_points(int p_id, int p_with_id, bool bidirectional) {
 		s.direction = Segment::BIDIRECTIONAL;
 	}
 
-	RBSet<Segment>::Element *element = segments.find(s);
-	if (element != nullptr) {
-		s.direction |= element->get().direction;
+	HashSet<Segment, Segment>::Iterator element = segments.find(s);
+	if (element) {
+		s.direction |= element->direction;
 		if (s.direction == Segment::BIDIRECTIONAL) {
 			// Both are neighbours of each other now
 			a->unlinked_neighbours.remove(b->id);
 			b->unlinked_neighbours.remove(a->id);
 		}
-		segments.erase(element);
+		segments.remove(element);
 	}
 
 	segments.insert(s);
@@ -177,16 +177,16 @@ void AStar3D::disconnect_points(int p_id, int p_with_id, bool bidirectional) {
 	Segment s(p_id, p_with_id);
 	int remove_direction = bidirectional ? (int)Segment::BIDIRECTIONAL : s.direction;
 
-	RBSet<Segment>::Element *element = segments.find(s);
-	if (element != nullptr) {
+	HashSet<Segment, Segment>::Iterator element = segments.find(s);
+	if (element) {
 		// s is the new segment
 		// Erase the directions to be removed
-		s.direction = (element->get().direction & ~remove_direction);
+		s.direction = (element->direction & ~remove_direction);
 
 		a->neighbours.remove(b->id);
 		if (bidirectional) {
 			b->neighbours.remove(a->id);
-			if (element->get().direction != Segment::BIDIRECTIONAL) {
+			if (element->direction != Segment::BIDIRECTIONAL) {
 				a->unlinked_neighbours.remove(b->id);
 				b->unlinked_neighbours.remove(a->id);
 			}
@@ -198,7 +198,7 @@ void AStar3D::disconnect_points(int p_id, int p_with_id, bool bidirectional) {
 			}
 		}
 
-		segments.erase(element);
+		segments.remove(element);
 		if (s.direction != Segment::NONE) {
 			segments.insert(s);
 		}
@@ -235,10 +235,10 @@ Vector<int> AStar3D::get_point_connections(int p_id) {
 
 bool AStar3D::are_points_connected(int p_id, int p_with_id, bool bidirectional) const {
 	Segment s(p_id, p_with_id);
-	const RBSet<Segment>::Element *element = segments.find(s);
+	const HashSet<Segment, Segment>::Iterator element = segments.find(s);
 
-	return element != nullptr &&
-			(bidirectional || (element->get().direction & s.direction) == s.direction);
+	return element &&
+			(bidirectional || (element->direction & s.direction) == s.direction);
 }
 
 void AStar3D::clear() {
diff --git a/core/math/a_star.h b/core/math/a_star.h
index 086be839b5..e2f75ad18c 100644
--- a/core/math/a_star.h
+++ b/core/math/a_star.h
@@ -92,7 +92,10 @@ class AStar3D : public RefCounted {
 		};
 		unsigned char direction = NONE;
 
-		bool operator<(const Segment &p_s) const { return key < p_s.key; }
+		static uint32_t hash(const Segment &p_seg) {
+			return hash_one_uint64(p_seg.key);
+		}
+		bool operator==(const Segment &p_s) const { return key == p_s.key; }
 
 		Segment() {}
 		Segment(int p_from, int p_to) {
@@ -112,7 +115,7 @@ class AStar3D : public RefCounted {
 	uint64_t pass = 1;
 
 	OAHashMap<int, Point *> points;
-	RBSet<Segment> segments;
+	HashSet<Segment, Segment> segments;
 
 	bool _solve(Point *begin_point, Point *end_point);
 
diff --git a/core/math/quick_hull.cpp b/core/math/quick_hull.cpp
index 43744deeb0..c7727a44a1 100644
--- a/core/math/quick_hull.cpp
+++ b/core/math/quick_hull.cpp
@@ -52,7 +52,7 @@ Error QuickHull::build(const Vector<Vector3> &p_points, Geometry3D::MeshData &r_
 
 	Vector<bool> valid_points;
 	valid_points.resize(p_points.size());
-	RBSet<Vector3> valid_cache;
+	HashSet<Vector3> valid_cache;
 
 	for (int i = 0; i < p_points.size(); i++) {
 		Vector3 sp = p_points[i].snapped(Vector3(0.0001, 0.0001, 0.0001));
diff --git a/core/math/quick_hull.h b/core/math/quick_hull.h
index 1c354880b4..6783743fc2 100644
--- a/core/math/quick_hull.h
+++ b/core/math/quick_hull.h
@@ -33,8 +33,8 @@
 
 #include "core/math/aabb.h"
 #include "core/math/geometry_3d.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/list.h"
-#include "core/templates/rb_set.h"
 
 class QuickHull {
 public:
diff --git a/core/math/static_raycaster.h b/core/math/static_raycaster.h
index adc81906d7..bc6511c073 100644
--- a/core/math/static_raycaster.h
+++ b/core/math/static_raycaster.h
@@ -102,7 +102,7 @@ public:
 	virtual void add_mesh(const PackedVector3Array &p_vertices, const PackedInt32Array &p_indices, unsigned int p_id) = 0;
 	virtual void commit() = 0;
 
-	virtual void set_mesh_filter(const RBSet<int> &p_mesh_ids) = 0;
+	virtual void set_mesh_filter(const HashSet<int> &p_mesh_ids) = 0;
 	virtual void clear_mesh_filter() = 0;
 
 	static Ref<StaticRaycaster> create();
diff --git a/core/multiplayer/multiplayer_api.h b/core/multiplayer/multiplayer_api.h
index b93f2acbd3..cc7743ccf8 100644
--- a/core/multiplayer/multiplayer_api.h
+++ b/core/multiplayer/multiplayer_api.h
@@ -113,7 +113,7 @@ public:
 
 private:
 	Ref<MultiplayerPeer> multiplayer_peer;
-	RBSet<int> connected_peers;
+	HashSet<int> connected_peers;
 	int remote_sender_id = 0;
 	int remote_sender_override = 0;
 
@@ -172,7 +172,7 @@ public:
 
 	bool has_multiplayer_peer() const { return multiplayer_peer.is_valid(); }
 	Vector<int> get_peer_ids() const;
-	const RBSet<int> get_connected_peers() const { return connected_peers; }
+	const HashSet<int> get_connected_peers() const { return connected_peers; }
 	int get_remote_sender_id() const { return remote_sender_override ? remote_sender_override : remote_sender_id; }
 	void set_remote_sender_override(int p_id) { remote_sender_override = p_id; }
 	int get_unique_id() const;
diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp
index d19cbf2642..f61bd24efd 100644
--- a/core/object/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -1390,7 +1390,7 @@ void ClassDB::get_extensions_for_type(const StringName &p_class, List<String> *p
 }
 
 HashMap<StringName, HashMap<StringName, Variant>> ClassDB::default_values;
-RBSet<StringName> ClassDB::default_values_cached;
+HashSet<StringName> ClassDB::default_values_cached;
 
 Variant ClassDB::class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid) {
 	if (!default_values_cached.has(p_class)) {
diff --git a/core/object/class_db.h b/core/object/class_db.h
index 67b71ab058..2448a86e33 100644
--- a/core/object/class_db.h
+++ b/core/object/class_db.h
@@ -38,6 +38,7 @@
 // Makes callable_mp readily available in all classes connecting signals.
 // Needs to come after method_bind and object have been included.
 #include "core/object/callable_method_pointer.h"
+#include "core/templates/hash_set.h"
 
 #define DEFVAL(m_defval) (m_defval)
 
@@ -110,7 +111,7 @@ public:
 #ifdef DEBUG_METHODS_ENABLED
 		List<StringName> constant_order;
 		List<StringName> method_order;
-		RBSet<StringName> methods_in_properties;
+		HashSet<StringName> methods_in_properties;
 		List<MethodInfo> virtual_methods;
 		HashMap<StringName, MethodInfo> virtual_methods_map;
 		HashMap<StringName, Vector<Error>> method_error_values;
@@ -149,7 +150,7 @@ public:
 	static void _add_class2(const StringName &p_class, const StringName &p_inherits);
 
 	static HashMap<StringName, HashMap<StringName, Variant>> default_values;
-	static RBSet<StringName> default_values_cached;
+	static HashSet<StringName> default_values_cached;
 
 	// Native structs, used by binder
 	struct NativeStruct {
diff --git a/core/object/object.h b/core/object/object.h
index ca7b9965f1..988d261d77 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -37,9 +37,9 @@
 #include "core/os/rw_lock.h"
 #include "core/os/spin_lock.h"
 #include "core/templates/hash_map.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/list.h"
 #include "core/templates/rb_map.h"
-#include "core/templates/rb_set.h"
 #include "core/templates/safe_refcount.h"
 #include "core/templates/vmap.h"
 #include "core/variant/callable_bind.h"
@@ -510,7 +510,7 @@ private:
 #ifdef TOOLS_ENABLED
 	bool _edited = false;
 	uint32_t _edited_version = 0;
-	RBSet<String> editor_section_folding;
+	HashSet<String> editor_section_folding;
 #endif
 	ScriptInstance *script_instance = nullptr;
 	Variant script; // Reference does not exist yet, store it in a Variant.
@@ -815,7 +815,7 @@ public:
 #ifdef TOOLS_ENABLED
 	void editor_set_section_unfold(const String &p_section, bool p_unfolded);
 	bool editor_is_section_unfolded(const String &p_section);
-	const RBSet<String> &editor_get_section_folding() const { return editor_section_folding; }
+	const HashSet<String> &editor_get_section_folding() const { return editor_section_folding; }
 	void editor_clear_section_folding() { editor_section_folding.clear(); }
 
 #endif
diff --git a/core/object/script_language.cpp b/core/object/script_language.cpp
index 1546d52fd2..66c9a80193 100644
--- a/core/object/script_language.cpp
+++ b/core/object/script_language.cpp
@@ -475,7 +475,7 @@ bool PlaceHolderScriptInstance::has_method(const StringName &p_method) const {
 }
 
 void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, const HashMap<StringName, Variant> &p_values) {
-	RBSet<StringName> new_values;
+	HashSet<StringName> new_values;
 	for (const PropertyInfo &E : p_properties) {
 		StringName n = E.name;
 		new_values.insert(n);
diff --git a/core/object/script_language.h b/core/object/script_language.h
index b1481a372e..0a8e79a24e 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -155,7 +155,7 @@ public:
 	virtual int get_member_line(const StringName &p_member) const { return -1; }
 
 	virtual void get_constants(HashMap<StringName, Variant> *p_constants) {}
-	virtual void get_members(RBSet<StringName> *p_constants) {}
+	virtual void get_members(HashSet<StringName> *p_constants) {}
 
 	virtual bool is_placeholder_fallback_enabled() const { return false; }
 
@@ -283,7 +283,7 @@ public:
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const { return Ref<Script>(); }
 	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) { return Vector<ScriptTemplate>(); }
 	virtual bool is_using_templates() { return false; }
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const = 0;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const = 0;
 	virtual String validate_path(const String &p_path) const { return ""; }
 	virtual Script *create_script() const = 0;
 	virtual bool has_named_classes() const = 0;
diff --git a/core/object/script_language_extension.h b/core/object/script_language_extension.h
index 5ffa6c5a70..406a431a11 100644
--- a/core/object/script_language_extension.h
+++ b/core/object/script_language_extension.h
@@ -163,7 +163,7 @@ public:
 		}
 	}
 	GDVIRTUAL0RC(TypedArray<StringName>, _get_members)
-	virtual void get_members(RBSet<StringName> *p_members) override {
+	virtual void get_members(HashSet<StringName> *p_members) override {
 		TypedArray<StringName> members;
 		GDVIRTUAL_REQUIRED_CALL(_get_members, members);
 		for (int i = 0; i < members.size(); i++) {
@@ -282,7 +282,7 @@ public:
 	EXBIND0R(bool, is_using_templates)
 
 	GDVIRTUAL6RC(Dictionary, _validate, const String &, const String &, bool, bool, bool, bool)
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const override {
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override {
 		Dictionary ret;
 		GDVIRTUAL_REQUIRED_CALL(_validate, p_script, p_path, r_functions != nullptr, r_errors != nullptr, r_warnings != nullptr, r_safe_lines != nullptr, ret);
 		if (!ret.has("valid")) {
diff --git a/core/string/translation.h b/core/string/translation.h
index f58f6f91a2..20c6ebd5a5 100644
--- a/core/string/translation.h
+++ b/core/string/translation.h
@@ -74,7 +74,7 @@ class TranslationServer : public Object {
 	String locale = "en";
 	String fallback;
 
-	RBSet<Ref<Translation>> translations;
+	HashSet<Ref<Translation>> translations;
 	Ref<Translation> tool_translation;
 	Ref<Translation> doc_translation;
 
@@ -111,7 +111,7 @@ class TranslationServer : public Object {
 		String name;
 		String script;
 		String default_country;
-		RBSet<String> supported_countries;
+		HashSet<String> supported_countries;
 	};
 	static Vector<LocaleScriptInfo> locale_script_info;
 
diff --git a/core/templates/hash_set.h b/core/templates/hash_set.h
new file mode 100644
index 0000000000..2318067dcc
--- /dev/null
+++ b/core/templates/hash_set.h
@@ -0,0 +1,473 @@
+/*************************************************************************/
+/*  hash_set.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef HASH_SET_H
+#define HASH_SET_H
+
+#include "core/math/math_funcs.h"
+#include "core/os/memory.h"
+#include "core/templates/hash_map.h"
+#include "core/templates/hashfuncs.h"
+#include "core/templates/paged_allocator.h"
+
+/**
+ * Implementation of Set using a bidi indexed hash map.
+ * Use RBSet instead of this only if the following conditions are met:
+ *
+ * - You need to keep an iterator or const pointer to Key and you intend to add/remove elements in the meantime.
+ * - Iteration order does matter (via operator<)
+ *
+ */
+
+template <class TKey,
+		class Hasher = HashMapHasherDefault,
+		class Comparator = HashMapComparatorDefault<TKey>>
+class HashSet {
+public:
+	static constexpr uint32_t MIN_CAPACITY_INDEX = 2; // Use a prime.
+	static constexpr float MAX_OCCUPANCY = 0.75;
+	static constexpr uint32_t EMPTY_HASH = 0;
+
+private:
+	TKey *keys = nullptr;
+	uint32_t *hash_to_key = nullptr;
+	uint32_t *key_to_hash = nullptr;
+	uint32_t *hashes = nullptr;
+
+	uint32_t capacity_index = 0;
+	uint32_t num_elements = 0;
+
+	_FORCE_INLINE_ uint32_t _hash(const TKey &p_key) const {
+		uint32_t hash = Hasher::hash(p_key);
+
+		if (unlikely(hash == EMPTY_HASH)) {
+			hash = EMPTY_HASH + 1;
+		}
+
+		return hash;
+	}
+
+	_FORCE_INLINE_ uint32_t _get_probe_length(uint32_t p_pos, uint32_t p_hash, uint32_t p_capacity) const {
+		uint32_t original_pos = p_hash % p_capacity;
+		return (p_pos - original_pos + p_capacity) % p_capacity;
+	}
+
+	bool _lookup_pos(const TKey &p_key, uint32_t &r_pos) const {
+		if (keys == nullptr) {
+			return false; // Failed lookups, no elements
+		}
+
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+		uint32_t hash = _hash(p_key);
+		uint32_t pos = hash % capacity;
+		uint32_t distance = 0;
+
+		while (true) {
+			if (hashes[pos] == EMPTY_HASH) {
+				return false;
+			}
+
+			if (distance > _get_probe_length(pos, hashes[pos], capacity)) {
+				return false;
+			}
+
+			if (hashes[pos] == hash && Comparator::compare(keys[hash_to_key[pos]], p_key)) {
+				r_pos = hash_to_key[pos];
+				return true;
+			}
+
+			pos = (pos + 1) % capacity;
+			distance++;
+		}
+	}
+
+	uint32_t _insert_with_hash(uint32_t p_hash, uint32_t p_index) {
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+		uint32_t hash = p_hash;
+		uint32_t index = p_index;
+		uint32_t distance = 0;
+		uint32_t pos = hash % capacity;
+
+		while (true) {
+			if (hashes[pos] == EMPTY_HASH) {
+				hashes[pos] = hash;
+				key_to_hash[index] = pos;
+				hash_to_key[pos] = index;
+				return pos;
+			}
+
+			// Not an empty slot, let's check the probing length of the existing one.
+			uint32_t existing_probe_len = _get_probe_length(pos, hashes[pos], capacity);
+			if (existing_probe_len < distance) {
+				key_to_hash[index] = pos;
+				SWAP(hash, hashes[pos]);
+				SWAP(index, hash_to_key[pos]);
+				distance = existing_probe_len;
+			}
+
+			pos = (pos + 1) % capacity;
+			distance++;
+		}
+	}
+
+	void _resize_and_rehash(uint32_t p_new_capacity_index) {
+		// Capacity can't be 0.
+		capacity_index = MAX((uint32_t)MIN_CAPACITY_INDEX, p_new_capacity_index);
+
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+
+		uint32_t *old_hashes = hashes;
+		uint32_t *old_key_to_hash = key_to_hash;
+
+		hashes = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+		keys = reinterpret_cast<TKey *>(Memory::realloc_static(keys, sizeof(TKey) * capacity));
+		key_to_hash = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+		hash_to_key = reinterpret_cast<uint32_t *>(Memory::realloc_static(hash_to_key, sizeof(uint32_t) * capacity));
+
+		for (uint32_t i = 0; i < capacity; i++) {
+			hashes[i] = EMPTY_HASH;
+		}
+
+		for (uint32_t i = 0; i < num_elements; i++) {
+			uint32_t h = old_hashes[old_key_to_hash[i]];
+			_insert_with_hash(h, i);
+		}
+
+		Memory::free_static(old_hashes);
+		Memory::free_static(old_key_to_hash);
+	}
+
+	_FORCE_INLINE_ int32_t _insert(const TKey &p_key) {
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+		if (unlikely(keys == nullptr)) {
+			// Allocate on demand to save memory.
+
+			hashes = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+			keys = reinterpret_cast<TKey *>(Memory::alloc_static(sizeof(TKey) * capacity));
+			key_to_hash = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+			hash_to_key = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+
+			for (uint32_t i = 0; i < capacity; i++) {
+				hashes[i] = EMPTY_HASH;
+			}
+		}
+
+		uint32_t pos = 0;
+		bool exists = _lookup_pos(p_key, pos);
+
+		if (exists) {
+			return pos;
+		} else {
+			if (num_elements + 1 > MAX_OCCUPANCY * capacity) {
+				ERR_FAIL_COND_V_MSG(capacity_index + 1 == HASH_TABLE_SIZE_MAX, -1, "Hash table maximum capacity reached, aborting insertion.");
+				_resize_and_rehash(capacity_index + 1);
+			}
+
+			uint32_t hash = _hash(p_key);
+			memnew_placement(&keys[num_elements], TKey(p_key));
+			_insert_with_hash(hash, num_elements);
+			num_elements++;
+			return num_elements - 1;
+		}
+	}
+
+	void _init_from(const HashSet &p_other) {
+		capacity_index = p_other.capacity_index;
+		num_elements = p_other.num_elements;
+
+		if (p_other.num_elements == 0) {
+			return;
+		}
+
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+
+		hashes = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+		keys = reinterpret_cast<TKey *>(Memory::alloc_static(sizeof(TKey) * capacity));
+		key_to_hash = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+		hash_to_key = reinterpret_cast<uint32_t *>(Memory::alloc_static(sizeof(uint32_t) * capacity));
+
+		for (uint32_t i = 0; i < num_elements; i++) {
+			memnew_placement(&keys[i], TKey(p_other.keys[i]));
+			key_to_hash[i] = p_other.key_to_hash[i];
+		}
+
+		for (uint32_t i = 0; i < capacity; i++) {
+			hashes[i] = p_other.hashes[i];
+			hash_to_key[i] = p_other.hash_to_key[i];
+		}
+	}
+
+public:
+	_FORCE_INLINE_ uint32_t get_capacity() const { return hash_table_size_primes[capacity_index]; }
+	_FORCE_INLINE_ uint32_t size() const { return num_elements; }
+
+	/* Standard Godot Container API */
+
+	bool is_empty() const {
+		return num_elements == 0;
+	}
+
+	void clear() {
+		if (keys == nullptr) {
+			return;
+		}
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+		for (uint32_t i = 0; i < capacity; i++) {
+			hashes[i] = EMPTY_HASH;
+		}
+		for (uint32_t i = 0; i < num_elements; i++) {
+			keys[i].~TKey();
+		}
+
+		num_elements = 0;
+	}
+
+	_FORCE_INLINE_ bool has(const TKey &p_key) const {
+		uint32_t _pos = 0;
+		return _lookup_pos(p_key, _pos);
+	}
+
+	bool erase(const TKey &p_key) {
+		uint32_t pos = 0;
+		bool exists = _lookup_pos(p_key, pos);
+
+		if (!exists) {
+			return false;
+		}
+
+		uint32_t key_pos = pos;
+		pos = key_to_hash[pos]; //make hash pos
+
+		uint32_t capacity = hash_table_size_primes[capacity_index];
+		uint32_t next_pos = (pos + 1) % capacity;
+		while (hashes[next_pos] != EMPTY_HASH && _get_probe_length(next_pos, hashes[next_pos], capacity) != 0) {
+			uint32_t kpos = hash_to_key[pos];
+			uint32_t kpos_next = hash_to_key[next_pos];
+			SWAP(key_to_hash[kpos], key_to_hash[kpos_next]);
+			SWAP(hashes[next_pos], hashes[pos]);
+			SWAP(hash_to_key[next_pos], hash_to_key[pos]);
+
+			pos = next_pos;
+			next_pos = (pos + 1) % capacity;
+		}
+
+		hashes[pos] = EMPTY_HASH;
+		keys[key_pos].~TKey();
+		num_elements--;
+		if (key_pos < num_elements) {
+			// Not the last key, move the last one here to keep keys lineal
+			memnew_placement(&keys[key_pos], TKey(keys[num_elements]));
+			keys[num_elements].~TKey();
+			key_to_hash[key_pos] = key_to_hash[num_elements];
+			hash_to_key[key_to_hash[num_elements]] = key_pos;
+		}
+
+		return true;
+	}
+
+	// Reserves space for a number of elements, useful to avoid many resizes and rehashes.
+	// If adding a known (possibly large) number of elements at once, must be larger than old capacity.
+	void reserve(uint32_t p_new_capacity) {
+		uint32_t new_index = capacity_index;
+
+		while (hash_table_size_primes[new_index] < p_new_capacity) {
+			ERR_FAIL_COND_MSG(new_index + 1 == (uint32_t)HASH_TABLE_SIZE_MAX, nullptr);
+			new_index++;
+		}
+
+		if (new_index == capacity_index) {
+			return;
+		}
+
+		if (keys == nullptr) {
+			capacity_index = new_index;
+			return; // Unallocated yet.
+		}
+		_resize_and_rehash(new_index);
+	}
+
+	/** Iterator API **/
+
+	struct Iterator {
+		_FORCE_INLINE_ const TKey &operator*() const {
+			return keys[index];
+		}
+		_FORCE_INLINE_ const TKey *operator->() const {
+			return &keys[index];
+		}
+		_FORCE_INLINE_ Iterator &operator++() {
+			index++;
+			if (index >= (int32_t)num_keys) {
+				index = -1;
+				keys = nullptr;
+				num_keys = 0;
+			}
+			return *this;
+		}
+		_FORCE_INLINE_ Iterator &operator--() {
+			index--;
+			if (index < 0) {
+				index = -1;
+				keys = nullptr;
+				num_keys = 0;
+			}
+			return *this;
+		}
+
+		_FORCE_INLINE_ bool operator==(const Iterator &b) const { return keys == b.keys && index == b.index; }
+		_FORCE_INLINE_ bool operator!=(const Iterator &b) const { return keys != b.keys || index != b.index; }
+
+		_FORCE_INLINE_ explicit operator bool() const {
+			return keys != nullptr;
+		}
+
+		_FORCE_INLINE_ Iterator(const TKey *p_keys, uint32_t p_num_keys, int32_t p_index = -1) {
+			keys = p_keys;
+			num_keys = p_num_keys;
+			index = p_index;
+		}
+		_FORCE_INLINE_ Iterator() {}
+		_FORCE_INLINE_ Iterator(const Iterator &p_it) {
+			keys = p_it.keys;
+			num_keys = p_it.num_keys;
+			index = p_it.index;
+		}
+		_FORCE_INLINE_ void operator=(const Iterator &p_it) {
+			keys = p_it.keys;
+			num_keys = p_it.num_keys;
+			index = p_it.index;
+		}
+
+	private:
+		const TKey *keys = nullptr;
+		uint32_t num_keys = 0;
+		int32_t index = -1;
+	};
+
+	_FORCE_INLINE_ Iterator begin() const {
+		return num_elements ? Iterator(keys, num_elements, 0) : Iterator();
+	}
+	_FORCE_INLINE_ Iterator end() const {
+		return Iterator();
+	}
+	_FORCE_INLINE_ Iterator last() const {
+		if (num_elements == 0) {
+			return Iterator();
+		}
+		return Iterator(keys, num_elements, num_elements - 1);
+	}
+
+	_FORCE_INLINE_ Iterator find(const TKey &p_key) const {
+		uint32_t pos = 0;
+		bool exists = _lookup_pos(p_key, pos);
+		if (!exists) {
+			return end();
+		}
+		return Iterator(keys, num_elements, pos);
+	}
+
+	_FORCE_INLINE_ void remove(const Iterator &p_iter) {
+		if (p_iter) {
+			erase(*p_iter);
+		}
+	}
+
+	/* Insert */
+
+	Iterator insert(const TKey &p_key) {
+		uint32_t pos = _insert(p_key);
+		return Iterator(keys, num_elements, pos);
+	}
+
+	/* Constructors */
+
+	HashSet(const HashSet &p_other) {
+		_init_from(p_other);
+	}
+
+	void operator=(const HashSet &p_other) {
+		if (this == &p_other) {
+			return; // Ignore self assignment.
+		}
+
+		clear();
+
+		if (keys != nullptr) {
+			Memory::free_static(keys);
+			Memory::free_static(key_to_hash);
+			Memory::free_static(hash_to_key);
+			Memory::free_static(hashes);
+			keys = nullptr;
+			hashes = nullptr;
+			hash_to_key = nullptr;
+			key_to_hash = nullptr;
+		}
+
+		_init_from(p_other);
+	}
+
+	HashSet(uint32_t p_initial_capacity) {
+		// Capacity can't be 0.
+		capacity_index = 0;
+		reserve(p_initial_capacity);
+	}
+	HashSet() {
+		capacity_index = MIN_CAPACITY_INDEX;
+	}
+
+	void reset() {
+		clear();
+
+		if (keys != nullptr) {
+			Memory::free_static(keys);
+			Memory::free_static(key_to_hash);
+			Memory::free_static(hash_to_key);
+			Memory::free_static(hashes);
+			keys = nullptr;
+			hashes = nullptr;
+			hash_to_key = nullptr;
+			key_to_hash = nullptr;
+		}
+		capacity_index = MIN_CAPACITY_INDEX;
+	}
+
+	~HashSet() {
+		clear();
+
+		if (keys != nullptr) {
+			Memory::free_static(keys);
+			Memory::free_static(key_to_hash);
+			Memory::free_static(hash_to_key);
+			Memory::free_static(hashes);
+		}
+	}
+};
+
+#endif // HASH_SET_H
diff --git a/core/templates/rb_set.h b/core/templates/rb_set.h
index 2de816769c..226ea979c9 100644
--- a/core/templates/rb_set.h
+++ b/core/templates/rb_set.h
@@ -99,6 +99,7 @@ public:
 		_FORCE_INLINE_ bool operator==(const Iterator &b) const { return E == b.E; }
 		_FORCE_INLINE_ bool operator!=(const Iterator &b) const { return E != b.E; }
 
+		explicit operator bool() const { return E != nullptr; }
 		Iterator(Element *p_E) { E = p_E; }
 		Iterator() {}
 		Iterator(const Iterator &p_it) { E = p_it.E; }
@@ -128,6 +129,8 @@ public:
 		_FORCE_INLINE_ ConstIterator() {}
 		_FORCE_INLINE_ ConstIterator(const ConstIterator &p_it) { E = p_it.E; }
 
+		explicit operator bool() const { return E != nullptr; }
+
 	private:
 		const Element *E = nullptr;
 	};
diff --git a/core/templates/rid_owner.h b/core/templates/rid_owner.h
index d26977380e..9c74b41818 100644
--- a/core/templates/rid_owner.h
+++ b/core/templates/rid_owner.h
@@ -34,9 +34,9 @@
 #include "core/os/memory.h"
 #include "core/os/spin_lock.h"
 #include "core/string/print_string.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/list.h"
 #include "core/templates/oa_hash_map.h"
-#include "core/templates/rb_set.h"
 #include "core/templates/rid.h"
 #include "core/templates/safe_refcount.h"
 
diff --git a/doc/classes/CodeEdit.xml b/doc/classes/CodeEdit.xml
index ab55aeba05..7ca27a35fe 100644
--- a/doc/classes/CodeEdit.xml
+++ b/doc/classes/CodeEdit.xml
@@ -478,7 +478,7 @@
 		<member name="indent_automatic" type="bool" setter="set_auto_indent_enabled" getter="is_auto_indent_enabled" default="false">
 			Sets whether automatic indent are enabled, this will add an extra indent if a prefix or brace is found.
 		</member>
-		<member name="indent_automatic_prefixes" type="String[]" setter="set_auto_indent_prefixes" getter="get_auto_indent_prefixes" default="[&quot;(&quot;, &quot;:&quot;, &quot;[&quot;, &quot;{&quot;]">
+		<member name="indent_automatic_prefixes" type="String[]" setter="set_auto_indent_prefixes" getter="get_auto_indent_prefixes" default="[&quot;:&quot;, &quot;{&quot;, &quot;[&quot;, &quot;(&quot;]">
 			Prefixes to trigger an automatic indent.
 		</member>
 		<member name="indent_size" type="int" setter="set_indent_size" getter="get_indent_size" default="4">
diff --git a/drivers/gles3/storage/config.h b/drivers/gles3/storage/config.h
index 975508b555..c93c030498 100644
--- a/drivers/gles3/storage/config.h
+++ b/drivers/gles3/storage/config.h
@@ -34,7 +34,7 @@
 #ifdef GLES3_ENABLED
 
 #include "core/string/ustring.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 
 // This must come first to avoid windows.h mess
 #include "platform_config.h"
@@ -65,7 +65,7 @@ public:
 	// TODO implement wireframe in OpenGL
 	// bool generate_wireframes;
 
-	RBSet<String> extensions;
+	HashSet<String> extensions;
 
 	bool float_texture_supported = false;
 	bool s3tc_supported = false;
diff --git a/drivers/gles3/storage/material_storage.cpp b/drivers/gles3/storage/material_storage.cpp
index 7b18376a2a..ca62b0ca1f 100644
--- a/drivers/gles3/storage/material_storage.cpp
+++ b/drivers/gles3/storage/material_storage.cpp
@@ -2381,7 +2381,7 @@ void MaterialStorage::shader_free(RID p_rid) {
 
 	//make material unreference this
 	while (shader->owners.size()) {
-		material_set_shader(shader->owners.front()->get()->self, RID());
+		material_set_shader((*shader->owners.begin())->self, RID());
 	}
 
 	//clear data if exists
diff --git a/drivers/gles3/storage/material_storage.h b/drivers/gles3/storage/material_storage.h
index 6a11a10d76..053dbacc05 100644
--- a/drivers/gles3/storage/material_storage.h
+++ b/drivers/gles3/storage/material_storage.h
@@ -89,7 +89,7 @@ struct Shader {
 	String code;
 	RS::ShaderMode mode;
 	HashMap<StringName, HashMap<int, RID>> default_texture_parameter;
-	RBSet<Material *> owners;
+	HashSet<Material *> owners;
 };
 
 /* Material structs */
@@ -384,7 +384,7 @@ struct GlobalVariables {
 		BUFFER_DIRTY_REGION_SIZE = 1024
 	};
 	struct Variable {
-		RBSet<RID> texture_materials; // materials using this
+		HashSet<RID> texture_materials; // materials using this
 
 		RS::GlobalVariableType type;
 		Variant value;
diff --git a/drivers/gles3/storage/mesh_storage.h b/drivers/gles3/storage/mesh_storage.h
index 856463d45e..991777842f 100644
--- a/drivers/gles3/storage/mesh_storage.h
+++ b/drivers/gles3/storage/mesh_storage.h
@@ -123,7 +123,7 @@ struct Mesh {
 	List<MeshInstance *> instances;
 
 	RID shadow_mesh;
-	RBSet<Mesh *> shadow_owners;
+	HashSet<Mesh *> shadow_owners;
 
 	RendererStorage::Dependency dependency;
 };
diff --git a/drivers/vulkan/rendering_device_vulkan.cpp b/drivers/vulkan/rendering_device_vulkan.cpp
index 1a60ca0647..77aab72d40 100644
--- a/drivers/vulkan/rendering_device_vulkan.cpp
+++ b/drivers/vulkan/rendering_device_vulkan.cpp
@@ -132,13 +132,13 @@ static void update_external_dependency_for_store(VkSubpassDependency &dependency
 
 void RenderingDeviceVulkan::_add_dependency(RID p_id, RID p_depends_on) {
 	if (!dependency_map.has(p_depends_on)) {
-		dependency_map[p_depends_on] = RBSet<RID>();
+		dependency_map[p_depends_on] = HashSet<RID>();
 	}
 
 	dependency_map[p_depends_on].insert(p_id);
 
 	if (!reverse_dependency_map.has(p_id)) {
-		reverse_dependency_map[p_id] = RBSet<RID>();
+		reverse_dependency_map[p_id] = HashSet<RID>();
 	}
 
 	reverse_dependency_map[p_id].insert(p_depends_on);
@@ -147,10 +147,10 @@ void RenderingDeviceVulkan::_add_dependency(RID p_id, RID p_depends_on) {
 void RenderingDeviceVulkan::_free_dependencies(RID p_id) {
 	//direct dependencies must be freed
 
-	HashMap<RID, RBSet<RID>>::Iterator E = dependency_map.find(p_id);
+	HashMap<RID, HashSet<RID>>::Iterator E = dependency_map.find(p_id);
 	if (E) {
 		while (E->value.size()) {
-			free(E->value.front()->get());
+			free(*E->value.begin());
 		}
 		dependency_map.remove(E);
 	}
@@ -160,7 +160,7 @@ void RenderingDeviceVulkan::_free_dependencies(RID p_id) {
 
 	if (E) {
 		for (const RID &F : E->value) {
-			HashMap<RID, RBSet<RID>>::Iterator G = dependency_map.find(F);
+			HashMap<RID, HashSet<RID>>::Iterator G = dependency_map.find(F);
 			ERR_CONTINUE(!G);
 			ERR_CONTINUE(!G->value.has(p_id));
 			G->value.erase(p_id);
@@ -4138,7 +4138,7 @@ RenderingDevice::VertexFormatID RenderingDeviceVulkan::vertex_format_create(cons
 	vdcache.bindings = memnew_arr(VkVertexInputBindingDescription, p_vertex_formats.size());
 	vdcache.attributes = memnew_arr(VkVertexInputAttributeDescription, p_vertex_formats.size());
 
-	RBSet<int> used_locations;
+	HashSet<int> used_locations;
 	for (int i = 0; i < p_vertex_formats.size(); i++) {
 		ERR_CONTINUE(p_vertex_formats[i].format >= DATA_FORMAT_MAX);
 		ERR_FAIL_COND_V(used_locations.has(p_vertex_formats[i].location), INVALID_ID);
@@ -5468,7 +5468,7 @@ RID RenderingDeviceVulkan::texture_buffer_create(uint32_t p_size_elements, DataF
 
 RenderingDeviceVulkan::DescriptorPool *RenderingDeviceVulkan::_descriptor_pool_allocate(const DescriptorPoolKey &p_key) {
 	if (!descriptor_pools.has(p_key)) {
-		descriptor_pools[p_key] = RBSet<DescriptorPool *>();
+		descriptor_pools[p_key] = HashSet<DescriptorPool *>();
 	}
 
 	DescriptorPool *pool = nullptr;
diff --git a/drivers/vulkan/rendering_device_vulkan.h b/drivers/vulkan/rendering_device_vulkan.h
index 601c44c728..903a39b3d0 100644
--- a/drivers/vulkan/rendering_device_vulkan.h
+++ b/drivers/vulkan/rendering_device_vulkan.h
@@ -101,8 +101,8 @@ class RenderingDeviceVulkan : public RenderingDevice {
 
 	VkDevice device = VK_NULL_HANDLE;
 
-	HashMap<RID, RBSet<RID>> dependency_map; //IDs to IDs that depend on it
-	HashMap<RID, RBSet<RID>> reverse_dependency_map; //same as above, but in reverse
+	HashMap<RID, HashSet<RID>> dependency_map; //IDs to IDs that depend on it
+	HashMap<RID, HashSet<RID>> reverse_dependency_map; //same as above, but in reverse
 
 	void _add_dependency(RID p_id, RID p_depends_on);
 	void _free_dependencies(RID p_id);
@@ -702,7 +702,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		uint32_t usage;
 	};
 
-	RBMap<DescriptorPoolKey, RBSet<DescriptorPool *>> descriptor_pools;
+	RBMap<DescriptorPoolKey, HashSet<DescriptorPool *>> descriptor_pools;
 	uint32_t max_descriptors_per_pool = 0;
 
 	DescriptorPool *_descriptor_pool_allocate(const DescriptorPoolKey &p_key);
@@ -923,7 +923,7 @@ class RenderingDeviceVulkan : public RenderingDevice {
 		};
 
 		struct State {
-			RBSet<Texture *> textures_to_sampled_layout;
+			HashSet<Texture *> textures_to_sampled_layout;
 			SetState sets[MAX_UNIFORM_SETS];
 			uint32_t set_count = 0;
 			RID pipeline;
diff --git a/editor/animation_bezier_editor.cpp b/editor/animation_bezier_editor.cpp
index c5f800b17a..f0650ee446 100644
--- a/editor/animation_bezier_editor.cpp
+++ b/editor/animation_bezier_editor.cpp
@@ -792,8 +792,8 @@ void AnimationBezierTrackEdit::_clear_selection() {
 void AnimationBezierTrackEdit::_change_selected_keys_handle_mode(Animation::HandleMode p_mode) {
 	undo_redo->create_action(TTR("Update Selected Key Handles"));
 	double ratio = timeline->get_zoom_scale() * v_zoom;
-	for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
-		const IntPair track_key_pair = E->get();
+	for (const IntPair &E : selection) {
+		const IntPair track_key_pair = E;
 		undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_handle_mode", track_key_pair.first, track_key_pair.second, animation->bezier_track_get_key_handle_mode(track_key_pair.first, track_key_pair.second), ratio);
 		undo_redo->add_do_method(animation.ptr(), "bezier_track_set_key_handle_mode", track_key_pair.first, track_key_pair.second, p_mode, ratio);
 	}
@@ -851,14 +851,14 @@ void AnimationBezierTrackEdit::gui_input(const Ref<InputEvent> &p_event) {
 					focused_keys.insert(key_pair);
 				}
 			} else {
-				for (SelectionSet::Element *E = selection.front(); E; E = E->next()) {
-					focused_keys.insert(E->get());
-					if (E->get().second > 0) {
-						IntPair previous_key = IntPair(E->get().first, E->get().second - 1);
+				for (const IntPair &E : selection) {
+					focused_keys.insert(E);
+					if (E.second > 0) {
+						IntPair previous_key = IntPair(E.first, E.second - 1);
 						focused_keys.insert(previous_key);
 					}
-					if (E->get().second < animation->track_get_key_count(E->get().first) - 1) {
-						IntPair next_key = IntPair(E->get().first, E->get().second + 1);
+					if (E.second < animation->track_get_key_count(E.first) - 1) {
+						IntPair next_key = IntPair(E.first, E.second + 1);
 						focused_keys.insert(next_key);
 					}
 				}
@@ -873,8 +873,8 @@ void AnimationBezierTrackEdit::gui_input(const Ref<InputEvent> &p_event) {
 			float minimum_value = INFINITY;
 			float maximum_value = -INFINITY;
 
-			for (SelectionSet::Element *E = focused_keys.front(); E; E = E->next()) {
-				IntPair key_pair = E->get();
+			for (const IntPair &E : selection) {
+				IntPair key_pair = E;
 
 				float time = animation->track_get_key_time(key_pair.first, key_pair.second);
 				float value = animation->bezier_track_get_key_value(key_pair.first, key_pair.second);
diff --git a/editor/animation_bezier_editor.h b/editor/animation_bezier_editor.h
index cbbc3cc32a..22b58a6703 100644
--- a/editor/animation_bezier_editor.h
+++ b/editor/animation_bezier_editor.h
@@ -32,6 +32,7 @@
 #define ANIMATION_BEZIER_EDITOR_H
 
 #include "animation_track_editor.h"
+#include "core/templates/rb_set.h"
 
 class ViewPanner;
 
@@ -71,8 +72,8 @@ class AnimationBezierTrackEdit : public Control {
 	};
 
 	RBMap<int, RBMap<int, Rect2>> subtrack_icons;
-	RBSet<int> locked_tracks;
-	RBSet<int> hidden_tracks;
+	HashSet<int> locked_tracks;
+	HashSet<int> hidden_tracks;
 	int solo_track = -1;
 	bool is_filtered = false;
 
diff --git a/editor/animation_track_editor.cpp b/editor/animation_track_editor.cpp
index ad4b7b7d95..fa4f32a351 100644
--- a/editor/animation_track_editor.cpp
+++ b/editor/animation_track_editor.cpp
@@ -5906,7 +5906,7 @@ void AnimationTrackEditor::_edit_menu_pressed(int p_option) {
 			undo_redo->create_action(TTR("Anim Add RESET Keys"));
 			Ref<Animation> reset = _create_and_get_reset_animation();
 			int reset_tracks = reset->get_track_count();
-			RBSet<int> tracks_added;
+			HashSet<int> tracks_added;
 
 			for (const KeyValue<SelectedKey, KeyInfo> &E : selection) {
 				const SelectedKey &sk = E.key;
diff --git a/editor/create_dialog.h b/editor/create_dialog.h
index 6526116b09..3ab27ea58c 100644
--- a/editor/create_dialog.h
+++ b/editor/create_dialog.h
@@ -64,7 +64,7 @@ class CreateDialog : public ConfirmationDialog {
 	HashMap<String, String> custom_type_parents;
 	HashMap<String, int> custom_type_indices;
 	List<StringName> type_list;
-	RBSet<StringName> type_blacklist;
+	HashSet<StringName> type_blacklist;
 
 	void _update_search();
 	bool _should_hide_type(const String &p_type) const;
diff --git a/editor/debugger/editor_debugger_inspector.cpp b/editor/debugger/editor_debugger_inspector.cpp
index 0dd7b44b68..c5093494c6 100644
--- a/editor/debugger/editor_debugger_inspector.cpp
+++ b/editor/debugger/editor_debugger_inspector.cpp
@@ -146,7 +146,7 @@ ObjectID EditorDebuggerInspector::add_object(const Array &p_arr) {
 
 	debugObj->prop_list.clear();
 	int new_props_added = 0;
-	RBSet<String> changed;
+	HashSet<String> changed;
 	for (int i = 0; i < obj.properties.size(); i++) {
 		PropertyInfo &pinfo = obj.properties[i].first;
 		Variant &var = obj.properties[i].second;
diff --git a/editor/debugger/editor_debugger_inspector.h b/editor/debugger/editor_debugger_inspector.h
index 72b259c8b5..0e73928558 100644
--- a/editor/debugger/editor_debugger_inspector.h
+++ b/editor/debugger/editor_debugger_inspector.h
@@ -69,7 +69,7 @@ class EditorDebuggerInspector : public EditorInspector {
 private:
 	ObjectID inspected_object_id;
 	HashMap<ObjectID, EditorDebuggerRemoteObject *> remote_objects;
-	RBSet<Ref<Resource>> remote_dependencies;
+	HashSet<Ref<Resource>> remote_dependencies;
 	EditorDebuggerRemoteObject *variables = nullptr;
 
 	void _object_selected(ObjectID p_object);
diff --git a/editor/debugger/editor_debugger_node.h b/editor/debugger/editor_debugger_node.h
index 40e9cf47f9..87457fc09a 100644
--- a/editor/debugger/editor_debugger_node.h
+++ b/editor/debugger/editor_debugger_node.h
@@ -112,7 +112,7 @@ private:
 	CameraOverride camera_override = OVERRIDE_NONE;
 	HashMap<Breakpoint, bool, Breakpoint> breakpoints;
 
-	RBSet<Ref<Script>> debugger_plugins;
+	HashSet<Ref<Script>> debugger_plugins;
 
 	ScriptEditorDebugger *_add_debugger();
 	EditorDebuggerRemoteObject *get_inspected_remote_object();
diff --git a/editor/debugger/editor_debugger_tree.h b/editor/debugger/editor_debugger_tree.h
index 8ba03367c9..4e38f00ffa 100644
--- a/editor/debugger/editor_debugger_tree.h
+++ b/editor/debugger/editor_debugger_tree.h
@@ -48,7 +48,7 @@ private:
 	ObjectID inspected_object_id;
 	int debugger_id = 0;
 	bool updating_scene_tree = false;
-	RBSet<ObjectID> unfold_cache;
+	HashSet<ObjectID> unfold_cache;
 	PopupMenu *item_menu = nullptr;
 	EditorFileDialog *file_dialog = nullptr;
 	String last_filter;
diff --git a/editor/debugger/editor_performance_profiler.cpp b/editor/debugger/editor_performance_profiler.cpp
index 897c5ae7da..ed451ed68e 100644
--- a/editor/debugger/editor_performance_profiler.cpp
+++ b/editor/debugger/editor_performance_profiler.cpp
@@ -203,7 +203,7 @@ void EditorPerformanceProfiler::_monitor_draw() {
 }
 
 void EditorPerformanceProfiler::_build_monitor_tree() {
-	RBSet<StringName> monitor_checked;
+	HashSet<StringName> monitor_checked;
 	for (KeyValue<StringName, Monitor> &E : monitors) {
 		if (E.value.item && E.value.item->is_checked(0)) {
 			monitor_checked.insert(E.key);
diff --git a/editor/debugger/editor_profiler.cpp b/editor/debugger/editor_profiler.cpp
index 9899e91c5a..f2bb63e528 100644
--- a/editor/debugger/editor_profiler.cpp
+++ b/editor/debugger/editor_profiler.cpp
@@ -515,7 +515,7 @@ Vector<Vector<String>> EditorProfiler::get_data_as_csv() const {
 	}
 
 	// Different metrics may contain different number of categories.
-	RBSet<StringName> possible_signatures;
+	HashSet<StringName> possible_signatures;
 	for (int i = 0; i < frame_metrics.size(); i++) {
 		const Metric &m = frame_metrics[i];
 		if (!m.valid) {
diff --git a/editor/debugger/editor_profiler.h b/editor/debugger/editor_profiler.h
index 77fbb254dc..cb01a1819f 100644
--- a/editor/debugger/editor_profiler.h
+++ b/editor/debugger/editor_profiler.h
@@ -98,7 +98,7 @@ private:
 	Tree *variables = nullptr;
 	HSplitContainer *h_split = nullptr;
 
-	RBSet<StringName> plot_sigs;
+	HashSet<StringName> plot_sigs;
 
 	OptionButton *display_mode = nullptr;
 	OptionButton *display_time = nullptr;
diff --git a/editor/doc_tools.cpp b/editor/doc_tools.cpp
index 65216d7664..e6cd1e0b48 100644
--- a/editor/doc_tools.cpp
+++ b/editor/doc_tools.cpp
@@ -331,7 +331,7 @@ void DocTools::generate(bool p_basic_types) {
 	bool skip_setter_getter_methods = true;
 
 	while (classes.size()) {
-		RBSet<StringName> setters_getters;
+		HashSet<StringName> setters_getters;
 
 		String name = classes.front()->get();
 		if (!ClassDB::is_class_exposed(name)) {
diff --git a/editor/editor_asset_installer.cpp b/editor/editor_asset_installer.cpp
index b696bc3ac6..ef29448854 100644
--- a/editor/editor_asset_installer.cpp
+++ b/editor/editor_asset_installer.cpp
@@ -62,7 +62,7 @@ void EditorAssetInstaller::_check_propagated_to_item(Object *p_obj, int column)
 
 void EditorAssetInstaller::open(const String &p_path, int p_depth) {
 	package_path = p_path;
-	RBSet<String> files_sorted;
+	HashSet<String> files_sorted;
 
 	Ref<FileAccess> io_fa;
 	zlib_filefunc_def io = zipio_create_io(&io_fa);
diff --git a/editor/editor_data.cpp b/editor/editor_data.cpp
index 0bb48db09e..64c234a07c 100644
--- a/editor/editor_data.cpp
+++ b/editor/editor_data.cpp
@@ -549,7 +549,7 @@ void EditorData::remove_scene(int p_idx) {
 	edited_scene.remove_at(p_idx);
 }
 
-bool EditorData::_find_updated_instances(Node *p_root, Node *p_node, RBSet<String> &checked_paths) {
+bool EditorData::_find_updated_instances(Node *p_root, Node *p_node, HashSet<String> &checked_paths) {
 	Ref<SceneState> ss;
 
 	if (p_node == p_root) {
@@ -587,7 +587,7 @@ bool EditorData::check_and_update_scene(int p_idx) {
 		return false;
 	}
 
-	RBSet<String> checked_scenes;
+	HashSet<String> checked_scenes;
 
 	bool must_reload = _find_updated_instances(edited_scene[p_idx].root, edited_scene[p_idx].root, checked_scenes);
 
diff --git a/editor/editor_data.h b/editor/editor_data.h
index b9eb199c37..351c63f4b9 100644
--- a/editor/editor_data.h
+++ b/editor/editor_data.h
@@ -139,7 +139,7 @@ private:
 	Vector<EditedScene> edited_scene;
 	int current_edited_scene;
 
-	bool _find_updated_instances(Node *p_root, Node *p_node, RBSet<String> &checked_paths);
+	bool _find_updated_instances(Node *p_root, Node *p_node, HashSet<String> &checked_paths);
 
 	HashMap<StringName, String> _script_class_icon_paths;
 	HashMap<String, StringName> _script_class_file_to_path;
diff --git a/editor/editor_dir_dialog.h b/editor/editor_dir_dialog.h
index 60abfeb66f..95ca0d32b9 100644
--- a/editor/editor_dir_dialog.h
+++ b/editor/editor_dir_dialog.h
@@ -44,7 +44,7 @@ class EditorDirDialog : public ConfirmationDialog {
 	AcceptDialog *mkdirerr = nullptr;
 
 	Button *makedir = nullptr;
-	RBSet<String> opened_paths;
+	HashSet<String> opened_paths;
 
 	Tree *tree = nullptr;
 	bool updating = false;
diff --git a/editor/editor_export.cpp b/editor/editor_export.cpp
index 586ffa418c..f4a81521df 100644
--- a/editor/editor_export.cpp
+++ b/editor/editor_export.cpp
@@ -446,7 +446,7 @@ Ref<EditorExportPreset> EditorExportPlatform::create_preset() {
 	return preset;
 }
 
-void EditorExportPlatform::_export_find_resources(EditorFileSystemDirectory *p_dir, RBSet<String> &p_paths) {
+void EditorExportPlatform::_export_find_resources(EditorFileSystemDirectory *p_dir, HashSet<String> &p_paths) {
 	for (int i = 0; i < p_dir->get_subdir_count(); i++) {
 		_export_find_resources(p_dir->get_subdir(i), p_paths);
 	}
@@ -459,7 +459,7 @@ void EditorExportPlatform::_export_find_resources(EditorFileSystemDirectory *p_d
 	}
 }
 
-void EditorExportPlatform::_export_find_dependencies(const String &p_path, RBSet<String> &p_paths) {
+void EditorExportPlatform::_export_find_dependencies(const String &p_path, HashSet<String> &p_paths) {
 	if (p_paths.has(p_path)) {
 		return;
 	}
@@ -480,7 +480,7 @@ void EditorExportPlatform::_export_find_dependencies(const String &p_path, RBSet
 	}
 }
 
-void EditorExportPlatform::_edit_files_with_filter(Ref<DirAccess> &da, const Vector<String> &p_filters, RBSet<String> &r_list, bool exclude) {
+void EditorExportPlatform::_edit_files_with_filter(Ref<DirAccess> &da, const Vector<String> &p_filters, HashSet<String> &r_list, bool exclude) {
 	da->list_dir_begin();
 	String cur_dir = da->get_current_dir().replace("\\", "/");
 	if (!cur_dir.ends_with("/")) {
@@ -528,7 +528,7 @@ void EditorExportPlatform::_edit_files_with_filter(Ref<DirAccess> &da, const Vec
 	}
 }
 
-void EditorExportPlatform::_edit_filter_list(RBSet<String> &r_list, const String &p_filter, bool exclude) {
+void EditorExportPlatform::_edit_filter_list(HashSet<String> &r_list, const String &p_filter, bool exclude) {
 	if (p_filter.is_empty()) {
 		return;
 	}
@@ -648,10 +648,10 @@ void EditorExportPlugin::_export_end_script() {
 	GDVIRTUAL_CALL(_export_end);
 }
 
-void EditorExportPlugin::_export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) {
+void EditorExportPlugin::_export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
 }
 
-void EditorExportPlugin::_export_begin(const RBSet<String> &p_features, bool p_debug, const String &p_path, int p_flags) {
+void EditorExportPlugin::_export_begin(const HashSet<String> &p_features, bool p_debug, const String &p_path, int p_flags) {
 }
 
 void EditorExportPlugin::skip() {
@@ -739,7 +739,7 @@ EditorExportPlatform::ExportNotifier::~ExportNotifier() {
 
 Error EditorExportPlatform::export_project_files(const Ref<EditorExportPreset> &p_preset, bool p_debug, EditorExportSaveFunction p_func, void *p_udata, EditorExportSaveSharedObject p_so_func) {
 	//figure out paths of files that will be exported
-	RBSet<String> paths;
+	HashSet<String> paths;
 	Vector<String> path_remaps;
 
 	if (p_preset->get_export_filter() == EditorExportPreset::EXPORT_ALL_RESOURCES) {
@@ -872,7 +872,7 @@ Error EditorExportPlatform::export_project_files(const Ref<EditorExportPreset> &
 	}
 
 	FeatureContainers feature_containers = get_feature_containers(p_preset, p_debug);
-	RBSet<String> &features = feature_containers.features;
+	HashSet<String> &features = feature_containers.features;
 	Vector<String> &features_pv = feature_containers.features_pv;
 
 	//store everything in the export medium
@@ -910,7 +910,7 @@ Error EditorExportPlatform::export_project_files(const Ref<EditorExportPreset> &
 			List<String> remaps;
 			config->get_section_keys("remap", &remaps);
 
-			RBSet<String> remap_features;
+			HashSet<String> remap_features;
 
 			for (const String &F : remaps) {
 				String remap = F;
@@ -1934,7 +1934,7 @@ void EditorExportPlatformPC::get_platform_features(List<String> *r_features) {
 	r_features->push_back(get_os_name().to_lower()); //OS name is a feature
 }
 
-void EditorExportPlatformPC::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) {
+void EditorExportPlatformPC::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) {
 	if (p_features.has("bptc")) {
 		if (p_preset->has("texture_format/no_bptc_fallbacks")) {
 			p_features.erase("s3tc");
@@ -1952,7 +1952,7 @@ void EditorExportPlatformPC::set_chmod_flags(int p_flags) {
 
 ///////////////////////
 
-void EditorExportTextSceneToBinaryPlugin::_export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) {
+void EditorExportTextSceneToBinaryPlugin::_export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
 	String extension = p_path.get_extension().to_lower();
 	if (extension != "tres" && extension != "tscn") {
 		return;
diff --git a/editor/editor_export.h b/editor/editor_export.h
index 3b8ff0f686..daf6d8ef23 100644
--- a/editor/editor_export.h
+++ b/editor/editor_export.h
@@ -66,7 +66,7 @@ private:
 	String export_path;
 
 	String exporter;
-	RBSet<String> selected_files;
+	HashSet<String> selected_files;
 	bool runnable = false;
 
 	friend class EditorExport;
@@ -196,19 +196,19 @@ private:
 	};
 
 	struct FeatureContainers {
-		RBSet<String> features;
+		HashSet<String> features;
 		Vector<String> features_pv;
 	};
 
-	void _export_find_resources(EditorFileSystemDirectory *p_dir, RBSet<String> &p_paths);
-	void _export_find_dependencies(const String &p_path, RBSet<String> &p_paths);
+	void _export_find_resources(EditorFileSystemDirectory *p_dir, HashSet<String> &p_paths);
+	void _export_find_dependencies(const String &p_path, HashSet<String> &p_paths);
 
 	void gen_debug_flags(Vector<String> &r_flags, int p_flags);
 	static Error _save_pack_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total, const Vector<String> &p_enc_in_filters, const Vector<String> &p_enc_ex_filters, const Vector<uint8_t> &p_key);
 	static Error _save_zip_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total, const Vector<String> &p_enc_in_filters, const Vector<String> &p_enc_ex_filters, const Vector<uint8_t> &p_key);
 
-	void _edit_files_with_filter(Ref<DirAccess> &da, const Vector<String> &p_filters, RBSet<String> &r_list, bool exclude);
-	void _edit_filter_list(RBSet<String> &r_list, const String &p_filter, bool exclude);
+	void _edit_files_with_filter(Ref<DirAccess> &da, const Vector<String> &p_filters, HashSet<String> &r_list, bool exclude);
+	void _edit_filter_list(HashSet<String> &r_list, const String &p_filter, bool exclude);
 
 	static Error _add_shared_object(void *p_userdata, const SharedObject &p_so);
 
@@ -279,7 +279,7 @@ public:
 	virtual Error export_pack(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0);
 	virtual Error export_zip(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0);
 	virtual void get_platform_features(List<String> *r_features) = 0;
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) = 0;
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) = 0;
 	virtual String get_debug_protocol() const { return "tcp://"; }
 
 	EditorExportPlatform();
@@ -349,8 +349,8 @@ protected:
 
 	void skip();
 
-	virtual void _export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features);
-	virtual void _export_begin(const RBSet<String> &p_features, bool p_debug, const String &p_path, int p_flags);
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features);
+	virtual void _export_begin(const HashSet<String> &p_features, bool p_debug, const String &p_path, int p_flags);
 
 	static void _bind_methods();
 
@@ -454,7 +454,7 @@ public:
 
 	void add_platform_feature(const String &p_feature);
 	virtual void get_platform_features(List<String> *r_features) override;
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override;
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override;
 
 	int get_chmod_flags() const;
 	void set_chmod_flags(int p_flags);
@@ -468,7 +468,7 @@ class EditorExportTextSceneToBinaryPlugin : public EditorExportPlugin {
 	GDCLASS(EditorExportTextSceneToBinaryPlugin, EditorExportPlugin);
 
 public:
-	virtual void _export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) override;
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override;
 	EditorExportTextSceneToBinaryPlugin();
 };
 
diff --git a/editor/editor_feature_profile.cpp b/editor/editor_feature_profile.cpp
index 670f193326..f8fc28c31c 100644
--- a/editor/editor_feature_profile.cpp
+++ b/editor/editor_feature_profile.cpp
@@ -101,7 +101,7 @@ bool EditorFeatureProfile::is_class_editor_disabled(const StringName &p_class) c
 void EditorFeatureProfile::set_disable_class_property(const StringName &p_class, const StringName &p_property, bool p_disabled) {
 	if (p_disabled) {
 		if (!disabled_properties.has(p_class)) {
-			disabled_properties[p_class] = RBSet<StringName>();
+			disabled_properties[p_class] = HashSet<StringName>();
 		}
 
 		disabled_properties[p_class].insert(p_property);
@@ -181,7 +181,7 @@ Error EditorFeatureProfile::save_to_file(const String &p_path) {
 
 	Array dis_props;
 
-	for (KeyValue<StringName, RBSet<StringName>> &E : disabled_properties) {
+	for (KeyValue<StringName, HashSet<StringName>> &E : disabled_properties) {
 		for (const StringName &F : E.value) {
 			dis_props.push_back(String(E.key) + ":" + String(F));
 		}
diff --git a/editor/editor_feature_profile.h b/editor/editor_feature_profile.h
index 479baf5205..dab6c951e4 100644
--- a/editor/editor_feature_profile.h
+++ b/editor/editor_feature_profile.h
@@ -56,11 +56,11 @@ public:
 	};
 
 private:
-	RBSet<StringName> disabled_classes;
-	RBSet<StringName> disabled_editors;
-	HashMap<StringName, RBSet<StringName>> disabled_properties;
+	HashSet<StringName> disabled_classes;
+	HashSet<StringName> disabled_editors;
+	HashMap<StringName, HashSet<StringName>> disabled_properties;
 
-	RBSet<StringName> collapsed_classes;
+	HashSet<StringName> collapsed_classes;
 
 	bool features_disabled[FEATURE_MAX];
 	static const char *feature_names[FEATURE_MAX];
diff --git a/editor/editor_file_system.cpp b/editor/editor_file_system.cpp
index e37bfa32bc..f9a4c14c48 100644
--- a/editor/editor_file_system.cpp
+++ b/editor/editor_file_system.cpp
@@ -1636,7 +1636,7 @@ void EditorFileSystem::update_file(const String &p_file) {
 	_queue_update_script_classes();
 }
 
-RBSet<String> EditorFileSystem::get_valid_extensions() const {
+HashSet<String> EditorFileSystem::get_valid_extensions() const {
 	return valid_extensions;
 }
 
@@ -2047,7 +2047,7 @@ void EditorFileSystem::_reimport_file(const String &p_file, const HashMap<String
 	EditorResourcePreview::get_singleton()->check_for_invalidation(p_file);
 }
 
-void EditorFileSystem::_find_group_files(EditorFileSystemDirectory *efd, HashMap<String, Vector<String>> &group_files, RBSet<String> &groups_to_reimport) {
+void EditorFileSystem::_find_group_files(EditorFileSystemDirectory *efd, HashMap<String, Vector<String>> &group_files, HashSet<String> &groups_to_reimport) {
 	int fc = efd->files.size();
 	const EditorFileSystemDirectory::FileInfo *const *files = efd->files.ptr();
 	for (int i = 0; i < fc; i++) {
@@ -2079,7 +2079,7 @@ void EditorFileSystem::reimport_files(const Vector<String> &p_files) {
 
 	Vector<ImportFile> reimport_files;
 
-	RBSet<String> groups_to_reimport;
+	HashSet<String> groups_to_reimport;
 
 	for (int i = 0; i < p_files.size(); i++) {
 		String file = p_files[i];
@@ -2290,7 +2290,7 @@ ResourceUID::ID EditorFileSystem::_resource_saver_get_resource_id_for_path(const
 	}
 }
 
-static void _scan_extensions_dir(EditorFileSystemDirectory *d, RBSet<String> &extensions) {
+static void _scan_extensions_dir(EditorFileSystemDirectory *d, HashSet<String> &extensions) {
 	int fc = d->get_file_count();
 	for (int i = 0; i < fc; i++) {
 		if (d->get_file_type(i) == SNAME("NativeExtension")) {
@@ -2304,7 +2304,7 @@ static void _scan_extensions_dir(EditorFileSystemDirectory *d, RBSet<String> &ex
 }
 bool EditorFileSystem::_scan_extensions() {
 	EditorFileSystemDirectory *d = get_filesystem();
-	RBSet<String> extensions;
+	HashSet<String> extensions;
 
 	_scan_extensions_dir(d, extensions);
 
diff --git a/editor/editor_file_system.h b/editor/editor_file_system.h
index 743684a9ca..07b1132046 100644
--- a/editor/editor_file_system.h
+++ b/editor/editor_file_system.h
@@ -34,7 +34,7 @@
 #include "core/io/dir_access.h"
 #include "core/os/thread.h"
 #include "core/os/thread_safe.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/safe_refcount.h"
 #include "core/templates/thread_work_pool.h"
 #include "scene/main/node.h"
@@ -180,7 +180,7 @@ class EditorFileSystem : public Node {
 
 	void _scan_filesystem();
 
-	RBSet<String> late_update_files;
+	HashSet<String> late_update_files;
 
 	void _save_late_updated_files();
 
@@ -221,9 +221,9 @@ class EditorFileSystem : public Node {
 
 	void _delete_internal_files(String p_file);
 
-	RBSet<String> textfile_extensions;
-	RBSet<String> valid_extensions;
-	RBSet<String> import_extensions;
+	HashSet<String> textfile_extensions;
+	HashSet<String> valid_extensions;
+	HashSet<String> import_extensions;
 
 	void _scan_new_dir(EditorFileSystemDirectory *p_dir, Ref<DirAccess> &da, const ScanProgress &p_progress);
 
@@ -269,11 +269,11 @@ class EditorFileSystem : public Node {
 
 	bool using_fat32_or_exfat; // Workaround for projects in FAT32 or exFAT filesystem (pendrives, most of the time)
 
-	void _find_group_files(EditorFileSystemDirectory *efd, HashMap<String, Vector<String>> &group_files, RBSet<String> &groups_to_reimport);
+	void _find_group_files(EditorFileSystemDirectory *efd, HashMap<String, Vector<String>> &group_files, HashSet<String> &groups_to_reimport);
 
 	void _move_group_files(EditorFileSystemDirectory *efd, const String &p_group_file, const String &p_new_location);
 
-	RBSet<String> group_file_cache;
+	HashSet<String> group_file_cache;
 
 	ThreadWorkPool import_threads;
 
@@ -306,7 +306,7 @@ public:
 	void scan();
 	void scan_changes();
 	void update_file(const String &p_file);
-	RBSet<String> get_valid_extensions() const;
+	HashSet<String> get_valid_extensions() const;
 
 	EditorFileSystemDirectory *get_filesystem_path(const String &p_path);
 	String get_file_type(const String &p_file) const;
diff --git a/editor/editor_folding.cpp b/editor/editor_folding.cpp
index ad8aaf324c..9e1b361f64 100644
--- a/editor/editor_folding.cpp
+++ b/editor/editor_folding.cpp
@@ -87,7 +87,7 @@ void EditorFolding::load_resource_folding(Ref<Resource> p_resource, const String
 	_set_unfolds(p_resource.ptr(), unfolds);
 }
 
-void EditorFolding::_fill_folds(const Node *p_root, const Node *p_node, Array &p_folds, Array &resource_folds, Array &nodes_folded, RBSet<Ref<Resource>> &resources) {
+void EditorFolding::_fill_folds(const Node *p_root, const Node *p_node, Array &p_folds, Array &resource_folds, Array &nodes_folded, HashSet<Ref<Resource>> &resources) {
 	if (p_root != p_node) {
 		if (!p_node->get_owner()) {
 			return; //not owned, bye
@@ -140,7 +140,7 @@ void EditorFolding::save_scene_folding(const Node *p_scene, const String &p_path
 	config.instantiate();
 
 	Array unfolds, res_unfolds;
-	RBSet<Ref<Resource>> resources;
+	HashSet<Ref<Resource>> resources;
 	Array nodes_folded;
 	_fill_folds(p_scene, p_scene, unfolds, res_unfolds, nodes_folded, resources);
 
@@ -220,13 +220,13 @@ bool EditorFolding::has_folding_data(const String &p_path) {
 	return FileAccess::exists(file);
 }
 
-void EditorFolding::_do_object_unfolds(Object *p_object, RBSet<Ref<Resource>> &resources) {
+void EditorFolding::_do_object_unfolds(Object *p_object, HashSet<Ref<Resource>> &resources) {
 	List<PropertyInfo> plist;
 	p_object->get_property_list(&plist);
 	String group_base;
 	String group;
 
-	RBSet<String> unfold_group;
+	HashSet<String> unfold_group;
 
 	for (const PropertyInfo &E : plist) {
 		if (E.usage & PROPERTY_USAGE_CATEGORY) {
@@ -275,7 +275,7 @@ void EditorFolding::_do_object_unfolds(Object *p_object, RBSet<Ref<Resource>> &r
 	}
 }
 
-void EditorFolding::_do_node_unfolds(Node *p_root, Node *p_node, RBSet<Ref<Resource>> &resources) {
+void EditorFolding::_do_node_unfolds(Node *p_root, Node *p_node, HashSet<Ref<Resource>> &resources) {
 	if (p_root != p_node) {
 		if (!p_node->get_owner()) {
 			return; //not owned, bye
@@ -293,7 +293,7 @@ void EditorFolding::_do_node_unfolds(Node *p_root, Node *p_node, RBSet<Ref<Resou
 }
 
 void EditorFolding::unfold_scene(Node *p_scene) {
-	RBSet<Ref<Resource>> resources;
+	HashSet<Ref<Resource>> resources;
 	_do_node_unfolds(p_scene, p_scene, resources);
 }
 
diff --git a/editor/editor_folding.h b/editor/editor_folding.h
index 22df06280a..9a2aa37b80 100644
--- a/editor/editor_folding.h
+++ b/editor/editor_folding.h
@@ -37,10 +37,10 @@ class EditorFolding {
 	Vector<String> _get_unfolds(const Object *p_object);
 	void _set_unfolds(Object *p_object, const Vector<String> &p_unfolds);
 
-	void _fill_folds(const Node *p_root, const Node *p_node, Array &p_folds, Array &resource_folds, Array &nodes_folded, RBSet<Ref<Resource>> &resources);
+	void _fill_folds(const Node *p_root, const Node *p_node, Array &p_folds, Array &resource_folds, Array &nodes_folded, HashSet<Ref<Resource>> &resources);
 
-	void _do_object_unfolds(Object *p_object, RBSet<Ref<Resource>> &resources);
-	void _do_node_unfolds(Node *p_root, Node *p_node, RBSet<Ref<Resource>> &resources);
+	void _do_object_unfolds(Object *p_object, HashSet<Ref<Resource>> &resources);
+	void _do_node_unfolds(Node *p_root, Node *p_node, HashSet<Ref<Resource>> &resources);
 
 public:
 	void save_resource_folding(const Ref<Resource> &p_resource, const String &p_path);
diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp
index d6278a63fe..77c4fc71a4 100644
--- a/editor/editor_help.cpp
+++ b/editor/editor_help.cpp
@@ -648,7 +648,7 @@ void EditorHelp::_update_doc() {
 	}
 
 	// Properties overview
-	RBSet<String> skip_methods;
+	HashSet<String> skip_methods;
 	bool property_descr = false;
 
 	bool has_properties = cd.properties.size() != 0;
diff --git a/editor/editor_inspector.cpp b/editor/editor_inspector.cpp
index f534130735..4bc37456d5 100644
--- a/editor/editor_inspector.cpp
+++ b/editor/editor_inspector.cpp
@@ -839,7 +839,7 @@ void EditorProperty::_update_pin_flags() {
 		}
 		pin_hidden = false;
 		{
-			RBSet<StringName> storable_properties;
+			HashSet<StringName> storable_properties;
 			node->get_storable_properties(storable_properties);
 			if (storable_properties.has(node->get_property_store_alias(property))) {
 				can_pin = true;
@@ -3543,7 +3543,7 @@ void EditorInspector::_notification(int p_what) {
 
 			} else {
 				while (pending.size()) {
-					StringName prop = pending.front()->get();
+					StringName prop = *pending.begin();
 					if (editor_property_map.has(prop)) {
 						for (EditorProperty *E : editor_property_map[prop]) {
 							E->update_property();
@@ -3551,7 +3551,7 @@ void EditorInspector::_notification(int p_what) {
 							E->update_cache();
 						}
 					}
-					pending.erase(pending.front());
+					pending.remove(pending.begin());
 				}
 			}
 
@@ -3638,7 +3638,7 @@ void EditorInspector::_update_script_class_properties(const Object &p_object, Li
 		break;
 	}
 
-	RBSet<StringName> added;
+	HashSet<StringName> added;
 	for (const Ref<Script> &s : classes) {
 		String path = s->get_path();
 		String name = EditorNode::get_editor_data().script_class_get_name(path);
diff --git a/editor/editor_inspector.h b/editor/editor_inspector.h
index 7609f4fdcc..30c0cffe40 100644
--- a/editor/editor_inspector.h
+++ b/editor/editor_inspector.h
@@ -437,7 +437,7 @@ class EditorInspector : public ScrollContainer {
 	//map use to cache the instantiated editors
 	HashMap<StringName, List<EditorProperty *>> editor_property_map;
 	List<EditorInspectorSection *> sections;
-	RBSet<StringName> pending;
+	HashSet<StringName> pending;
 
 	void _clear();
 	Object *object = nullptr;
@@ -470,7 +470,7 @@ class EditorInspector : public ScrollContainer {
 
 	HashMap<StringName, HashMap<StringName, String>> descr_cache;
 	HashMap<StringName, String> class_descr_cache;
-	RBSet<StringName> restart_request_props;
+	HashSet<StringName> restart_request_props;
 
 	HashMap<ObjectID, int> scroll_cache;
 
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index f2baaf8b5c..4998cc82e8 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -800,7 +800,7 @@ void EditorNode::_notification(int p_what) {
 				main_editor_buttons.write[i]->add_theme_font_size_override("font_size", gui_base->get_theme_font_size(SNAME("main_button_font_size"), SNAME("EditorFonts")));
 			}
 
-			RBSet<String> updated_textfile_extensions;
+			HashSet<String> updated_textfile_extensions;
 			bool extensions_match = true;
 			const Vector<String> textfile_ext = ((String)(EditorSettings::get_singleton()->get("docks/filesystem/textfile_extensions"))).split(",", false);
 			for (const String &E : textfile_ext) {
@@ -1622,7 +1622,7 @@ bool EditorNode::_validate_scene_recursive(const String &p_filename, Node *p_nod
 	return false;
 }
 
-static bool _find_edited_resources(const Ref<Resource> &p_resource, RBSet<Ref<Resource>> &edited_resources) {
+static bool _find_edited_resources(const Ref<Resource> &p_resource, HashSet<Ref<Resource>> &edited_resources) {
 	if (p_resource->is_edited()) {
 		edited_resources.insert(p_resource);
 		return true;
@@ -1659,7 +1659,7 @@ int EditorNode::_save_external_resources() {
 	}
 	flg |= ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;
 
-	RBSet<Ref<Resource>> edited_subresources;
+	HashSet<Ref<Resource>> edited_subresources;
 	int saved = 0;
 	List<Ref<Resource>> cached;
 	ResourceCache::get_cached_resources(&cached);
@@ -3678,7 +3678,7 @@ Error EditorNode::load_scene(const String &p_scene, bool p_ignore_broken_deps, b
 
 	dependency_errors.erase(lpath); // At least not self path.
 
-	for (KeyValue<String, RBSet<String>> &E : dependency_errors) {
+	for (KeyValue<String, HashSet<String>> &E : dependency_errors) {
 		String txt = vformat(TTR("Scene '%s' has broken dependencies:"), E.key) + "\n";
 		for (const String &F : E.value) {
 			txt += "\t" + F + "\n";
diff --git a/editor/editor_node.h b/editor/editor_node.h
index 9cd96050e3..48df767562 100644
--- a/editor/editor_node.h
+++ b/editor/editor_node.h
@@ -394,7 +394,7 @@ private:
 	BackgroundProgress *progress_hb = nullptr;
 
 	DependencyErrorDialog *dependency_error = nullptr;
-	HashMap<String, RBSet<String>> dependency_errors;
+	HashMap<String, HashSet<String>> dependency_errors;
 	DependencyEditor *dependency_fixer = nullptr;
 	OrphanResourcesDialog *orphan_resources = nullptr;
 	ConfirmationDialog *open_imported = nullptr;
@@ -470,9 +470,9 @@ private:
 
 	String import_reload_fn;
 
-	RBSet<String> textfile_extensions;
-	RBSet<FileDialog *> file_dialogs;
-	RBSet<EditorFileDialog *> editor_file_dialogs;
+	HashSet<String> textfile_extensions;
+	HashSet<FileDialog *> file_dialogs;
+	HashSet<EditorFileDialog *> editor_file_dialogs;
 
 	Vector<Ref<EditorResourceConversionPlugin>> resource_conversion_plugins;
 	PrintHandlerList print_handler;
@@ -489,7 +489,7 @@ private:
 	static void _dependency_error_report(void *ud, const String &p_path, const String &p_dep, const String &p_type) {
 		EditorNode *en = static_cast<EditorNode *>(ud);
 		if (!en->dependency_errors.has(p_path)) {
-			en->dependency_errors[p_path] = RBSet<String>();
+			en->dependency_errors[p_path] = HashSet<String>();
 		}
 		en->dependency_errors[p_path].insert(p_dep + "::" + p_type);
 	}
diff --git a/editor/editor_resource_picker.cpp b/editor/editor_resource_picker.cpp
index cb3000ee88..34aa7217fa 100644
--- a/editor/editor_resource_picker.cpp
+++ b/editor/editor_resource_picker.cpp
@@ -240,7 +240,7 @@ void EditorResourcePicker::_edit_menu_cbk(int p_which) {
 				ResourceLoader::get_recognized_extensions_for_type(base, &extensions);
 			}
 
-			RBSet<String> valid_extensions;
+			HashSet<String> valid_extensions;
 			for (const String &E : extensions) {
 				valid_extensions.insert(E);
 			}
@@ -409,7 +409,7 @@ void EditorResourcePicker::set_create_options(Object *p_menu_node) {
 	if (!base_type.is_empty()) {
 		int idx = 0;
 
-		RBSet<String> allowed_types;
+		HashSet<String> allowed_types;
 		_get_allowed_types(false, &allowed_types);
 
 		Vector<EditorData::CustomType> custom_resources;
@@ -491,7 +491,7 @@ void EditorResourcePicker::_button_input(const Ref<InputEvent> &p_event) {
 	}
 }
 
-void EditorResourcePicker::_get_allowed_types(bool p_with_convert, RBSet<String> *p_vector) const {
+void EditorResourcePicker::_get_allowed_types(bool p_with_convert, HashSet<String> *p_vector) const {
 	Vector<String> allowed_types = base_type.split(",");
 	int size = allowed_types.size();
 
@@ -568,7 +568,7 @@ bool EditorResourcePicker::_is_drop_valid(const Dictionary &p_drag_data) const {
 		res = drag_data["resource"];
 	}
 
-	RBSet<String> allowed_types;
+	HashSet<String> allowed_types;
 	_get_allowed_types(true, &allowed_types);
 
 	if (res.is_valid() && _is_type_valid(res->get_class(), allowed_types)) {
@@ -598,7 +598,7 @@ bool EditorResourcePicker::_is_drop_valid(const Dictionary &p_drag_data) const {
 	return false;
 }
 
-bool EditorResourcePicker::_is_type_valid(const String p_type_name, RBSet<String> p_allowed_types) const {
+bool EditorResourcePicker::_is_type_valid(const String p_type_name, HashSet<String> p_allowed_types) const {
 	for (const String &E : p_allowed_types) {
 		String at = E.strip_edges();
 		if (p_type_name == at || ClassDB::is_parent_class(p_type_name, at) || EditorNode::get_editor_data().script_class_is_parent(p_type_name, at)) {
@@ -646,7 +646,7 @@ void EditorResourcePicker::drop_data_fw(const Point2 &p_point, const Variant &p_
 	}
 
 	if (dropped_resource.is_valid()) {
-		RBSet<String> allowed_types;
+		HashSet<String> allowed_types;
 		_get_allowed_types(false, &allowed_types);
 
 		// If the accepted dropped resource is from the extended list, it requires conversion.
@@ -768,7 +768,7 @@ void EditorResourcePicker::set_base_type(const String &p_base_type) {
 	// There is a possibility that the new base type is conflicting with the existing value.
 	// Keep the value, but warn the user that there is a potential mistake.
 	if (!base_type.is_empty() && edited_resource.is_valid()) {
-		RBSet<String> allowed_types;
+		HashSet<String> allowed_types;
 		_get_allowed_types(true, &allowed_types);
 
 		StringName custom_class;
@@ -784,7 +784,7 @@ void EditorResourcePicker::set_base_type(const String &p_base_type) {
 		}
 	} else {
 		// Call the method to build the cache immediately.
-		RBSet<String> allowed_types;
+		HashSet<String> allowed_types;
 		_get_allowed_types(false, &allowed_types);
 	}
 }
@@ -794,7 +794,7 @@ String EditorResourcePicker::get_base_type() const {
 }
 
 Vector<String> EditorResourcePicker::get_allowed_types() const {
-	RBSet<String> allowed_types;
+	HashSet<String> allowed_types;
 	_get_allowed_types(false, &allowed_types);
 
 	Vector<String> types;
@@ -802,8 +802,9 @@ Vector<String> EditorResourcePicker::get_allowed_types() const {
 
 	int i = 0;
 	String *w = types.ptrw();
-	for (RBSet<String>::Element *E = allowed_types.front(); E; E = E->next(), i++) {
-		w[i] = E->get();
+	for (const String &E : allowed_types) {
+		w[i] = E;
+		i++;
 	}
 
 	return types;
@@ -817,7 +818,7 @@ void EditorResourcePicker::set_edited_resource(Ref<Resource> p_resource) {
 	}
 
 	if (!base_type.is_empty()) {
-		RBSet<String> allowed_types;
+		HashSet<String> allowed_types;
 		_get_allowed_types(true, &allowed_types);
 
 		StringName custom_class;
diff --git a/editor/editor_resource_picker.h b/editor/editor_resource_picker.h
index f2dc45513d..8e26e1f4c0 100644
--- a/editor/editor_resource_picker.h
+++ b/editor/editor_resource_picker.h
@@ -89,9 +89,9 @@ class EditorResourcePicker : public HBoxContainer {
 	void _button_draw();
 	void _button_input(const Ref<InputEvent> &p_event);
 
-	void _get_allowed_types(bool p_with_convert, RBSet<String> *p_vector) const;
+	void _get_allowed_types(bool p_with_convert, HashSet<String> *p_vector) const;
 	bool _is_drop_valid(const Dictionary &p_drag_data) const;
-	bool _is_type_valid(const String p_type_name, RBSet<String> p_allowed_types) const;
+	bool _is_type_valid(const String p_type_name, HashSet<String> p_allowed_types) const;
 
 	Variant get_drag_data_fw(const Point2 &p_point, Control *p_from);
 	bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const;
diff --git a/editor/editor_settings.h b/editor/editor_settings.h
index e270a882e2..43f90f9258 100644
--- a/editor/editor_settings.h
+++ b/editor/editor_settings.h
@@ -34,6 +34,7 @@
 #include "core/io/config_file.h"
 #include "core/io/resource.h"
 #include "core/os/thread_safe.h"
+#include "core/templates/rb_set.h"
 
 class EditorPlugin;
 class InputEvent;
@@ -77,7 +78,7 @@ private:
 
 	static Ref<EditorSettings> singleton;
 
-	RBSet<String> changed_settings;
+	HashSet<String> changed_settings;
 
 	HashMap<String, PropertyInfo> hints;
 	HashMap<String, VariantContainer> props;
diff --git a/editor/editor_themes.cpp b/editor/editor_themes.cpp
index 567865d4f1..11fe62b84f 100644
--- a/editor/editor_themes.cpp
+++ b/editor/editor_themes.cpp
@@ -148,7 +148,7 @@ void editor_register_and_generate_icons(Ref<Theme> p_theme, bool p_dark_theme =
 
 	// The names of the icons to never convert, even if one of their colors
 	// are contained in the dictionary above.
-	RBSet<StringName> exceptions;
+	HashSet<StringName> exceptions;
 
 	// Some of the colors below are listed for completeness sake.
 	// This can be a basis for proper palette validation later.
@@ -290,7 +290,7 @@ void editor_register_and_generate_icons(Ref<Theme> p_theme, bool p_dark_theme =
 
 	// Use the accent color for some icons (checkbox, radio, toggle, etc.).
 	Dictionary accent_color_icon_color_dictionary;
-	RBSet<StringName> accent_color_icons;
+	HashSet<StringName> accent_color_icons;
 
 	const Color accent_color = p_theme->get_color(SNAME("accent_color"), SNAME("Editor"));
 	accent_color_icon_color_dictionary[Color::html("699ce8")] = accent_color;
diff --git a/editor/editor_translation_parser.cpp b/editor/editor_translation_parser.cpp
index ddb084e19b..eb4df3b630 100644
--- a/editor/editor_translation_parser.cpp
+++ b/editor/editor_translation_parser.cpp
@@ -33,7 +33,7 @@
 #include "core/error/error_macros.h"
 #include "core/io/file_access.h"
 #include "core/object/script_language.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 
 EditorTranslationParser *EditorTranslationParser::singleton = nullptr;
 
@@ -84,7 +84,7 @@ void EditorTranslationParserPlugin::_bind_methods() {
 /////////////////////////
 
 void EditorTranslationParser::get_recognized_extensions(List<String> *r_extensions) const {
-	RBSet<String> extensions;
+	HashSet<String> extensions;
 	List<String> temp;
 	for (int i = 0; i < standard_parsers.size(); i++) {
 		standard_parsers[i]->get_recognized_extensions(&temp);
diff --git a/editor/export_template_manager.cpp b/editor/export_template_manager.cpp
index 50f03652ee..c6d3843b06 100644
--- a/editor/export_template_manager.cpp
+++ b/editor/export_template_manager.cpp
@@ -35,6 +35,7 @@
 #include "core/io/json.h"
 #include "core/io/zip_io.h"
 #include "core/os/keyboard.h"
+#include "core/templates/rb_set.h"
 #include "core/version.h"
 #include "editor/editor_node.h"
 #include "editor/editor_paths.h"
@@ -694,7 +695,7 @@ Error ExportTemplateManager::install_android_template_from_file(const String &p_
 
 	ProgressDialog::get_singleton()->add_task("uncompress_src", TTR("Uncompressing Android Build Sources"), total_files);
 
-	RBSet<String> dirs_tested;
+	HashSet<String> dirs_tested;
 	int idx = 0;
 	while (ret == UNZ_OK) {
 		// Get file path.
diff --git a/editor/fileserver/editor_file_server.cpp b/editor/fileserver/editor_file_server.cpp
index eed3917845..718bcb24cc 100644
--- a/editor/fileserver/editor_file_server.cpp
+++ b/editor/fileserver/editor_file_server.cpp
@@ -282,7 +282,7 @@ void EditorFileServer::_thread_start(void *s) {
 
 		self->wait_mutex.lock();
 		while (self->to_wait.size()) {
-			Thread *w = self->to_wait.front()->get();
+			Thread *w = *self->to_wait.begin();
 			self->to_wait.erase(w);
 			self->wait_mutex.unlock();
 			w->wait_to_finish();
diff --git a/editor/fileserver/editor_file_server.h b/editor/fileserver/editor_file_server.h
index 21abbc3f8c..03b6ededab 100644
--- a/editor/fileserver/editor_file_server.h
+++ b/editor/fileserver/editor_file_server.h
@@ -55,7 +55,7 @@ class EditorFileServer : public Object {
 	};
 
 	Ref<TCPServer> server;
-	RBSet<Thread *> to_wait;
+	HashSet<Thread *> to_wait;
 
 	static void _close_client(ClientData *cd);
 	static void _subthread_start(void *s);
diff --git a/editor/filesystem_dock.cpp b/editor/filesystem_dock.cpp
index 4c4d38c074..8a995eaa8f 100644
--- a/editor/filesystem_dock.cpp
+++ b/editor/filesystem_dock.cpp
@@ -726,7 +726,7 @@ void FileSystemDock::_sort_file_info_list(List<FileSystemDock::FileInfo> &r_file
 
 void FileSystemDock::_update_file_list(bool p_keep_selection) {
 	// Register the previously selected items.
-	RBSet<String> cselection;
+	HashSet<String> cselection;
 	if (p_keep_selection) {
 		for (int i = 0; i < files->get_item_count(); i++) {
 			if (files->is_selected(i)) {
diff --git a/editor/filesystem_dock.h b/editor/filesystem_dock.h
index df3dd3fd69..40e8b1b7c8 100644
--- a/editor/filesystem_dock.h
+++ b/editor/filesystem_dock.h
@@ -108,7 +108,7 @@ private:
 	VSplitContainer *split_box = nullptr;
 	VBoxContainer *file_list_vb = nullptr;
 
-	RBSet<String> favorites;
+	HashSet<String> favorites;
 
 	Button *button_toggle_display_mode = nullptr;
 	Button *button_reload = nullptr;
diff --git a/editor/find_in_files.cpp b/editor/find_in_files.cpp
index aafaccf5be..d60e336f0f 100644
--- a/editor/find_in_files.cpp
+++ b/editor/find_in_files.cpp
@@ -99,7 +99,7 @@ void FindInFiles::set_folder(String folder) {
 	_root_dir = folder;
 }
 
-void FindInFiles::set_filter(const RBSet<String> &exts) {
+void FindInFiles::set_filter(const HashSet<String> &exts) {
 	_extension_filter = exts;
 }
 
@@ -443,9 +443,9 @@ String FindInFilesDialog::get_folder() const {
 	return text.strip_edges();
 }
 
-RBSet<String> FindInFilesDialog::get_filter() const {
+HashSet<String> FindInFilesDialog::get_filter() const {
 	// Could check the _filters_preferences but it might not have been generated yet.
-	RBSet<String> filters;
+	HashSet<String> filters;
 	for (int i = 0; i < _filters_container->get_child_count(); ++i) {
 		CheckBox *cb = static_cast<CheckBox *>(_filters_container->get_child(i));
 		if (cb->is_pressed()) {
diff --git a/editor/find_in_files.h b/editor/find_in_files.h
index 8bc7b506d0..c57a084779 100644
--- a/editor/find_in_files.h
+++ b/editor/find_in_files.h
@@ -46,7 +46,7 @@ public:
 	void set_whole_words(bool p_whole_word);
 	void set_match_case(bool p_match_case);
 	void set_folder(String folder);
-	void set_filter(const RBSet<String> &exts);
+	void set_filter(const HashSet<String> &exts);
 
 	String get_search_text() const { return _pattern; }
 
@@ -72,7 +72,7 @@ private:
 
 	// Config
 	String _pattern;
-	RBSet<String> _extension_filter;
+	HashSet<String> _extension_filter;
 	String _root_dir;
 	bool _whole_words = true;
 	bool _match_case = true;
@@ -115,7 +115,7 @@ public:
 	bool is_match_case() const;
 	bool is_whole_words() const;
 	String get_folder() const;
-	RBSet<String> get_filter() const;
+	HashSet<String> get_filter() const;
 
 protected:
 	void _notification(int p_what);
diff --git a/editor/import/collada.cpp b/editor/import/collada.cpp
index 71b5ddc216..f4d19fe8b6 100644
--- a/editor/import/collada.cpp
+++ b/editor/import/collada.cpp
@@ -2029,7 +2029,7 @@ void Collada::_merge_skeletons(VisualScene *p_vscene, Node *p_node) {
 		NodeGeometry *gnode = static_cast<NodeGeometry *>(p_node);
 		if (gnode->controller) {
 			// recount skeletons used
-			RBSet<NodeSkeleton *> skeletons;
+			HashSet<NodeSkeleton *> skeletons;
 
 			for (int i = 0; i < gnode->skeletons.size(); i++) {
 				String nodeid = gnode->skeletons[i];
@@ -2049,11 +2049,11 @@ void Collada::_merge_skeletons(VisualScene *p_vscene, Node *p_node) {
 
 			if (skeletons.size() > 1) {
 				//do the merger!!
-				RBSet<NodeSkeleton *>::Element *E = skeletons.front();
-				NodeSkeleton *base = E->get();
+				HashSet<NodeSkeleton *>::Iterator E = skeletons.begin();
+				NodeSkeleton *base = *E;
 
-				for (E = E->next(); E; E = E->next()) {
-					NodeSkeleton *merged = E->get();
+				for (++E; E; ++E) {
+					NodeSkeleton *merged = *E;
 					_remove_node(p_vscene, merged);
 					for (int i = 0; i < merged->children.size(); i++) {
 						_joint_set_owner(merged->children[i], base);
diff --git a/editor/import/collada.h b/editor/import/collada.h
index 6ac6181769..f1d9c5593f 100644
--- a/editor/import/collada.h
+++ b/editor/import/collada.h
@@ -493,7 +493,7 @@ public:
 
 		HashMap<String, VisualScene> visual_scene_map;
 		HashMap<String, Node *> scene_map;
-		RBSet<String> idref_joints;
+		HashSet<String> idref_joints;
 		HashMap<String, String> sid_to_node_map;
 		//RBMap<String,NodeJoint*> bone_map;
 
diff --git a/editor/import/dynamic_font_import_settings.h b/editor/import/dynamic_font_import_settings.h
index 4e2135a13c..154f347b77 100644
--- a/editor/import/dynamic_font_import_settings.h
+++ b/editor/import/dynamic_font_import_settings.h
@@ -33,6 +33,7 @@
 
 #include "editor/import/resource_importer_dynamic_font.h"
 
+#include "core/templates/rb_set.h"
 #include "scene/gui/dialogs.h"
 #include "scene/gui/item_list.h"
 #include "scene/gui/option_button.h"
diff --git a/editor/import/editor_import_collada.cpp b/editor/import/editor_import_collada.cpp
index 03fda0a1c3..8d44329022 100644
--- a/editor/import/editor_import_collada.cpp
+++ b/editor/import/editor_import_collada.cpp
@@ -76,12 +76,12 @@ struct ColladaImport {
 
 	HashMap<Skeleton3D *, HashMap<String, int>> skeleton_bone_map;
 
-	RBSet<String> valid_animated_nodes;
+	HashSet<String> valid_animated_nodes;
 	Vector<int> valid_animated_properties;
 	HashMap<String, bool> bones_with_animation;
 
-	RBSet<String> mesh_unique_names;
-	RBSet<String> material_unique_names;
+	HashSet<String> mesh_unique_names;
+	HashSet<String> material_unique_names;
 
 	Error _populate_skeleton(Skeleton3D *p_skeleton, Collada::Node *p_node, int &r_bone, int p_parent);
 	Error _create_scene_skeletons(Collada::Node *p_node);
@@ -94,7 +94,7 @@ struct ColladaImport {
 	void create_animation(int p_clip, bool p_import_value_tracks);
 	void create_animations(bool p_import_value_tracks);
 
-	RBSet<String> tracks_in_clips;
+	HashSet<String> tracks_in_clips;
 	Vector<String> missing_textures;
 
 	void _pre_process_lights(Collada::Node *p_node);
@@ -875,7 +875,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<ImporterMesh> &p
 		Vector<Collada::Vertex> vertex_array; //there we go, vertex array
 
 		vertex_array.resize(vertex_set.size());
-		for (Collada::Vertex &F : vertex_set) {
+		for (const Collada::Vertex &F : vertex_set) {
 			vertex_array.write[F.idx] = F;
 		}
 
@@ -1452,7 +1452,7 @@ void ColladaImport::create_animation(int p_clip, bool p_import_value_tracks) {
 		//main anim
 	}
 
-	RBSet<int> track_filter;
+	HashSet<int> track_filter;
 
 	if (p_clip == -1) {
 		for (int i = 0; i < collada.state.animation_clips.size(); i++) {
diff --git a/editor/import/resource_importer_scene.cpp b/editor/import/resource_importer_scene.cpp
index 4f666730d5..80230bc316 100644
--- a/editor/import/resource_importer_scene.cpp
+++ b/editor/import/resource_importer_scene.cpp
@@ -704,7 +704,7 @@ Node *ResourceImporterScene::_pre_fix_node(Node *p_node, Node *p_root, HashMap<R
 	return p_node;
 }
 
-Node *ResourceImporterScene::_post_fix_node(Node *p_node, Node *p_root, HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> &collision_map, Pair<PackedVector3Array, PackedInt32Array> &r_occluder_arrays, RBSet<Ref<ImporterMesh>> &r_scanned_meshes, const Dictionary &p_node_data, const Dictionary &p_material_data, const Dictionary &p_animation_data, float p_animation_fps) {
+Node *ResourceImporterScene::_post_fix_node(Node *p_node, Node *p_root, HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> &collision_map, Pair<PackedVector3Array, PackedInt32Array> &r_occluder_arrays, HashSet<Ref<ImporterMesh>> &r_scanned_meshes, const Dictionary &p_node_data, const Dictionary &p_material_data, const Dictionary &p_animation_data, float p_animation_fps) {
 	// children first
 	for (int i = 0; i < p_node->get_child_count(); i++) {
 		Node *r = _post_fix_node(p_node->get_child(i), p_root, collision_map, r_occluder_arrays, r_scanned_meshes, p_node_data, p_material_data, p_animation_data, p_animation_fps);
@@ -1994,7 +1994,7 @@ Error ResourceImporterScene::import(const String &p_source_file, const String &p
 		animation_data = subresources["animations"];
 	}
 
-	RBSet<Ref<ImporterMesh>> scanned_meshes;
+	HashSet<Ref<ImporterMesh>> scanned_meshes;
 	HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> collision_map;
 	Pair<PackedVector3Array, PackedInt32Array> occluder_arrays;
 	List<Pair<NodePath, Node *>> node_renames;
diff --git a/editor/import/resource_importer_scene.h b/editor/import/resource_importer_scene.h
index 92bd267216..16cf3d651d 100644
--- a/editor/import/resource_importer_scene.h
+++ b/editor/import/resource_importer_scene.h
@@ -272,7 +272,7 @@ public:
 	virtual int get_import_order() const override { return ResourceImporter::IMPORT_ORDER_SCENE; }
 
 	Node *_pre_fix_node(Node *p_node, Node *p_root, HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> &r_collision_map, Pair<PackedVector3Array, PackedInt32Array> *r_occluder_arrays, List<Pair<NodePath, Node *>> &r_node_renames);
-	Node *_post_fix_node(Node *p_node, Node *p_root, HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> &collision_map, Pair<PackedVector3Array, PackedInt32Array> &r_occluder_arrays, RBSet<Ref<ImporterMesh>> &r_scanned_meshes, const Dictionary &p_node_data, const Dictionary &p_material_data, const Dictionary &p_animation_data, float p_animation_fps);
+	Node *_post_fix_node(Node *p_node, Node *p_root, HashMap<Ref<ImporterMesh>, Vector<Ref<Shape3D>>> &collision_map, Pair<PackedVector3Array, PackedInt32Array> &r_occluder_arrays, HashSet<Ref<ImporterMesh>> &r_scanned_meshes, const Dictionary &p_node_data, const Dictionary &p_material_data, const Dictionary &p_animation_data, float p_animation_fps);
 
 	Ref<Animation> _save_animation_to_file(Ref<Animation> anim, bool p_save_to_file, String p_save_to_path, bool p_keep_custom_tracks);
 	void _create_clips(AnimationPlayer *anim, const Array &p_clips, bool p_bake_all);
diff --git a/editor/import/scene_import_settings.h b/editor/import/scene_import_settings.h
index cbd105045a..a4008582ce 100644
--- a/editor/import/scene_import_settings.h
+++ b/editor/import/scene_import_settings.h
@@ -139,8 +139,8 @@ class SceneImportSettings : public ConfirmationDialog {
 	void _fill_animation(Tree *p_tree, const Ref<Animation> &p_anim, const String &p_name, TreeItem *p_parent);
 	void _fill_scene(Node *p_node, TreeItem *p_parent_item);
 
-	RBSet<Ref<Mesh>> mesh_set;
-	RBSet<Ref<Material>> material_set;
+	HashSet<Ref<Mesh>> mesh_set;
+	HashSet<Ref<Material>> material_set;
 
 	String selected_type;
 	String selected_id;
diff --git a/editor/import_dock.cpp b/editor/import_dock.cpp
index 56b15c3b1a..9eb2706d8a 100644
--- a/editor/import_dock.cpp
+++ b/editor/import_dock.cpp
@@ -43,7 +43,7 @@ public:
 	List<PropertyInfo> properties;
 	Ref<ResourceImporter> importer;
 	Vector<String> paths;
-	RBSet<StringName> checked;
+	HashSet<StringName> checked;
 	bool checking;
 	String base_options_path;
 
@@ -194,7 +194,7 @@ void ImportDock::set_edit_multiple_paths(const Vector<String> &p_paths) {
 
 	// Use the value that is repeated the most.
 	HashMap<String, Dictionary> value_frequency;
-	RBSet<String> extensions;
+	HashSet<String> extensions;
 
 	for (int i = 0; i < p_paths.size(); i++) {
 		Ref<ConfigFile> config;
diff --git a/editor/inspector_dock.cpp b/editor/inspector_dock.cpp
index c5dacd8d21..934d3a82b4 100644
--- a/editor/inspector_dock.cpp
+++ b/editor/inspector_dock.cpp
@@ -307,7 +307,7 @@ void InspectorDock::_prepare_history() {
 	history_menu->get_popup()->clear();
 
 	Ref<Texture2D> base_icon = get_theme_icon(SNAME("Object"), SNAME("EditorIcons"));
-	RBSet<ObjectID> already;
+	HashSet<ObjectID> already;
 	for (int i = editor_history->get_history_len() - 1; i >= history_to; i--) {
 		ObjectID id = editor_history->get_history_obj(i);
 		Object *obj = ObjectDB::get_instance(id);
diff --git a/editor/plugins/animation_blend_tree_editor_plugin.cpp b/editor/plugins/animation_blend_tree_editor_plugin.cpp
index 715b1725e0..8c8505283c 100644
--- a/editor/plugins/animation_blend_tree_editor_plugin.cpp
+++ b/editor/plugins/animation_blend_tree_editor_plugin.cpp
@@ -563,7 +563,7 @@ bool AnimationNodeBlendTreeEditor::_update_filters(const Ref<AnimationNode> &ano
 
 	updating = true;
 
-	RBSet<String> paths;
+	HashSet<String> paths;
 	HashMap<String, RBSet<String>> types;
 	{
 		List<StringName> animations;
@@ -698,11 +698,12 @@ bool AnimationNodeBlendTreeEditor::_update_filters(const Ref<AnimationNode> &ano
 				//just a node, not a property track
 				String types_text = "[";
 				if (types.has(path)) {
-					RBSet<String>::Element *F = types[path].front();
-					types_text += F->get();
-					while (F->next()) {
-						F = F->next();
-						types_text += " / " + F->get();
+					RBSet<String>::Iterator F = types[path].begin();
+					types_text += *F;
+					while (F) {
+						types_text += " / " + *F;
+						;
+						++F;
 					}
 				}
 				types_text += "]";
diff --git a/editor/plugins/animation_state_machine_editor.cpp b/editor/plugins/animation_state_machine_editor.cpp
index 2b90b4cdd6..bd9b89cbb7 100644
--- a/editor/plugins/animation_state_machine_editor.cpp
+++ b/editor/plugins/animation_state_machine_editor.cpp
@@ -494,7 +494,7 @@ Control::CursorShape AnimationNodeStateMachineEditor::get_cursor_shape(const Poi
 
 void AnimationNodeStateMachineEditor::_group_selected_nodes() {
 	if (!selected_nodes.is_empty()) {
-		if (selected_nodes.size() == 1 && (selected_nodes.front()->get() == state_machine->start_node || selected_nodes.front()->get() == state_machine->end_node))
+		if (selected_nodes.size() == 1 && (*selected_nodes.begin() == state_machine->start_node || *selected_nodes.begin() == state_machine->end_node))
 			return;
 
 		Ref<AnimationNodeStateMachine> group_sm = memnew(AnimationNodeStateMachine);
@@ -609,7 +609,7 @@ void AnimationNodeStateMachineEditor::_group_selected_nodes() {
 
 void AnimationNodeStateMachineEditor::_ungroup_selected_nodes() {
 	bool find = false;
-	RBSet<StringName> new_selected_nodes;
+	HashSet<StringName> new_selected_nodes;
 
 	for (const StringName &E : selected_nodes) {
 		Ref<AnimationNodeStateMachine> group_sm = state_machine->get_node(E);
@@ -1846,7 +1846,7 @@ void AnimationNodeStateMachineEditor::_update_mode() {
 	if (tool_select->is_pressed()) {
 		tool_erase_hb->show();
 		bool nothing_selected = selected_nodes.is_empty() && selected_transition_from == StringName() && selected_transition_to == StringName();
-		bool start_end_selected = selected_nodes.size() == 1 && (selected_nodes.front()->get() == state_machine->start_node || selected_nodes.front()->get() == state_machine->end_node);
+		bool start_end_selected = selected_nodes.size() == 1 && (*selected_nodes.begin() == state_machine->start_node || *selected_nodes.begin() == state_machine->end_node);
 		tool_erase->set_disabled(nothing_selected || start_end_selected);
 
 		if (selected_nodes.is_empty() || start_end_selected) {
@@ -1854,7 +1854,7 @@ void AnimationNodeStateMachineEditor::_update_mode() {
 			tool_group->set_visible(true);
 			tool_ungroup->set_visible(false);
 		} else {
-			Ref<AnimationNodeStateMachine> ansm = state_machine->get_node(selected_nodes.front()->get());
+			Ref<AnimationNodeStateMachine> ansm = state_machine->get_node(*selected_nodes.begin());
 
 			if (selected_nodes.size() == 1 && ansm.is_valid()) {
 				tool_group->set_disabled(true);
diff --git a/editor/plugins/animation_state_machine_editor.h b/editor/plugins/animation_state_machine_editor.h
index 3db4d91367..ea16abd64c 100644
--- a/editor/plugins/animation_state_machine_editor.h
+++ b/editor/plugins/animation_state_machine_editor.h
@@ -64,7 +64,7 @@ class AnimationNodeStateMachineEditor : public AnimationTreeNodeEditorPlugin {
 	PanelContainer *panel = nullptr;
 
 	StringName selected_node;
-	RBSet<StringName> selected_nodes;
+	HashSet<StringName> selected_nodes;
 
 	HScrollBar *h_scroll = nullptr;
 	VScrollBar *v_scroll = nullptr;
@@ -105,7 +105,7 @@ class AnimationNodeStateMachineEditor : public AnimationTreeNodeEditorPlugin {
 	Point2 box_selecting_from;
 	Point2 box_selecting_to;
 	Rect2 box_selecting_rect;
-	RBSet<StringName> previous_selected;
+	HashSet<StringName> previous_selected;
 
 	bool dragging_selected_attempt = false;
 	bool dragging_selected = false;
diff --git a/editor/plugins/editor_preview_plugins.cpp b/editor/plugins/editor_preview_plugins.cpp
index 0560365a58..bb0cfcba25 100644
--- a/editor/plugins/editor_preview_plugins.cpp
+++ b/editor/plugins/editor_preview_plugins.cpp
@@ -481,8 +481,8 @@ Ref<Texture2D> EditorScriptPreviewPlugin::generate(const Ref<Resource> &p_from,
 	List<String> kwors;
 	scr->get_language()->get_reserved_words(&kwors);
 
-	RBSet<String> control_flow_keywords;
-	RBSet<String> keywords;
+	HashSet<String> control_flow_keywords;
+	HashSet<String> keywords;
 
 	for (const String &E : kwors) {
 		if (scr->get_language()->is_control_flow_keyword(E)) {
diff --git a/editor/plugins/gdextension_export_plugin.h b/editor/plugins/gdextension_export_plugin.h
index 28c37fed52..c17e02e1fd 100644
--- a/editor/plugins/gdextension_export_plugin.h
+++ b/editor/plugins/gdextension_export_plugin.h
@@ -35,10 +35,10 @@
 
 class GDExtensionExportPlugin : public EditorExportPlugin {
 protected:
-	virtual void _export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features);
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features);
 };
 
-void GDExtensionExportPlugin::_export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) {
+void GDExtensionExportPlugin::_export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
 	if (p_type != "NativeExtension") {
 		return;
 	}
diff --git a/editor/plugins/mesh_instance_3d_editor_plugin.cpp b/editor/plugins/mesh_instance_3d_editor_plugin.cpp
index 3094e24659..d85087b5ea 100644
--- a/editor/plugins/mesh_instance_3d_editor_plugin.cpp
+++ b/editor/plugins/mesh_instance_3d_editor_plugin.cpp
@@ -349,12 +349,13 @@ struct MeshInstance3DEditorEdgeSort {
 	Vector2 a;
 	Vector2 b;
 
-	bool operator<(const MeshInstance3DEditorEdgeSort &p_b) const {
-		if (a == p_b.a) {
-			return b < p_b.b;
-		} else {
-			return a < p_b.a;
-		}
+	static uint32_t hash(const MeshInstance3DEditorEdgeSort &p_edge) {
+		uint32_t h = hash_djb2_one_32(HashMapHasherDefault::hash(p_edge.a));
+		return hash_djb2_one_32(HashMapHasherDefault::hash(p_edge.b), h);
+	}
+
+	bool operator==(const MeshInstance3DEditorEdgeSort &p_b) const {
+		return a == p_b.a && b == p_b.b;
 	}
 
 	MeshInstance3DEditorEdgeSort() {}
@@ -373,7 +374,7 @@ void MeshInstance3DEditor::_create_uv_lines(int p_layer) {
 	Ref<Mesh> mesh = node->get_mesh();
 	ERR_FAIL_COND(!mesh.is_valid());
 
-	RBSet<MeshInstance3DEditorEdgeSort> edges;
+	HashSet<MeshInstance3DEditorEdgeSort, MeshInstance3DEditorEdgeSort> edges;
 	uv_lines.clear();
 	for (int i = 0; i < mesh->get_surface_count(); i++) {
 		if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
diff --git a/editor/plugins/node_3d_editor_gizmos.cpp b/editor/plugins/node_3d_editor_gizmos.cpp
index 58cdf3533c..37922dd5c9 100644
--- a/editor/plugins/node_3d_editor_gizmos.cpp
+++ b/editor/plugins/node_3d_editor_gizmos.cpp
@@ -3799,7 +3799,7 @@ void LightmapGIGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
 	p_gizmo->clear();
 
 	Vector<Vector3> lines;
-	RBSet<Vector2i> lines_found;
+	HashSet<Vector2i> lines_found;
 
 	Vector<Vector3> points = data->get_capture_points();
 	if (points.size() == 0) {
diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp
index e7b4bac8ab..cbdb1e520a 100644
--- a/editor/plugins/node_3d_editor_plugin.cpp
+++ b/editor/plugins/node_3d_editor_plugin.cpp
@@ -518,7 +518,7 @@ ObjectID Node3DEditorViewport::_select_ray(const Point2 &p_pos) {
 	}
 
 	Vector<ObjectID> instances = RenderingServer::get_singleton()->instances_cull_ray(pos, pos + ray * camera->get_far(), get_tree()->get_root()->get_world_3d()->get_scenario());
-	RBSet<Ref<EditorNode3DGizmo>> found_gizmos;
+	HashSet<Ref<EditorNode3DGizmo>> found_gizmos;
 
 	Node *edited_scene = get_tree()->get_edited_scene_root();
 	ObjectID closest;
@@ -581,7 +581,7 @@ void Node3DEditorViewport::_find_items_at_pos(const Point2 &p_pos, Vector<_RayRe
 	Vector3 pos = _get_ray_pos(p_pos);
 
 	Vector<ObjectID> instances = RenderingServer::get_singleton()->instances_cull_ray(pos, pos + ray * camera->get_far(), get_tree()->get_root()->get_world_3d()->get_scenario());
-	RBSet<Node3D *> found_nodes;
+	HashSet<Node3D *> found_nodes;
 
 	for (int i = 0; i < instances.size(); i++) {
 		Node3D *spat = Object::cast_to<Node3D>(ObjectDB::get_instance(instances[i]));
@@ -764,7 +764,7 @@ void Node3DEditorViewport::_select_region() {
 	}
 
 	Vector<ObjectID> instances = RenderingServer::get_singleton()->instances_cull_convex(frustum, get_tree()->get_root()->get_world_3d()->get_scenario());
-	RBSet<Node3D *> found_nodes;
+	HashSet<Node3D *> found_nodes;
 	Vector<Node *> selected;
 
 	Node *edited_scene = get_tree()->get_edited_scene_root();
@@ -6685,8 +6685,8 @@ void Node3DEditor::_refresh_menu_icons() {
 }
 
 template <typename T>
-RBSet<T *> _get_child_nodes(Node *parent_node) {
-	RBSet<T *> nodes = RBSet<T *>();
+HashSet<T *> _get_child_nodes(Node *parent_node) {
+	HashSet<T *> nodes = HashSet<T *>();
 	T *node = Node::cast_to<T>(parent_node);
 	if (node) {
 		nodes.insert(node);
@@ -6694,22 +6694,22 @@ RBSet<T *> _get_child_nodes(Node *parent_node) {
 
 	for (int i = 0; i < parent_node->get_child_count(); i++) {
 		Node *child_node = parent_node->get_child(i);
-		RBSet<T *> child_nodes = _get_child_nodes<T>(child_node);
-		for (typename RBSet<T *>::Element *I = child_nodes.front(); I; I = I->next()) {
-			nodes.insert(I->get());
+		HashSet<T *> child_nodes = _get_child_nodes<T>(child_node);
+		for (T *I : child_nodes) {
+			nodes.insert(I);
 		}
 	}
 
 	return nodes;
 }
 
-RBSet<RID> _get_physics_bodies_rid(Node *node) {
-	RBSet<RID> rids = RBSet<RID>();
+HashSet<RID> _get_physics_bodies_rid(Node *node) {
+	HashSet<RID> rids = HashSet<RID>();
 	PhysicsBody3D *pb = Node::cast_to<PhysicsBody3D>(node);
 	if (pb) {
 		rids.insert(pb->get_rid());
 	}
-	RBSet<PhysicsBody3D *> child_nodes = _get_child_nodes<PhysicsBody3D>(node);
+	HashSet<PhysicsBody3D *> child_nodes = _get_child_nodes<PhysicsBody3D>(node);
 	for (const PhysicsBody3D *I : child_nodes) {
 		rids.insert(I->get_rid());
 	}
@@ -6728,20 +6728,21 @@ void Node3DEditor::snap_selected_nodes_to_floor() {
 			Vector3 position_offset = Vector3();
 
 			// Priorities for snapping to floor are CollisionShapes, VisualInstances and then origin
-			RBSet<VisualInstance3D *> vi = _get_child_nodes<VisualInstance3D>(sp);
-			RBSet<CollisionShape3D *> cs = _get_child_nodes<CollisionShape3D>(sp);
+			HashSet<VisualInstance3D *> vi = _get_child_nodes<VisualInstance3D>(sp);
+			HashSet<CollisionShape3D *> cs = _get_child_nodes<CollisionShape3D>(sp);
 			bool found_valid_shape = false;
 
 			if (cs.size()) {
 				AABB aabb;
-				RBSet<CollisionShape3D *>::Element *I = cs.front();
-				if (I->get()->get_shape().is_valid()) {
-					CollisionShape3D *collision_shape = cs.front()->get();
+				HashSet<CollisionShape3D *>::Iterator I = cs.begin();
+				if ((*I)->get_shape().is_valid()) {
+					CollisionShape3D *collision_shape = *cs.begin();
 					aabb = collision_shape->get_global_transform().xform(collision_shape->get_shape()->get_debug_mesh()->get_aabb());
 					found_valid_shape = true;
 				}
-				for (I = I->next(); I; I = I->next()) {
-					CollisionShape3D *col_shape = I->get();
+
+				for (++I; I; ++I) {
+					CollisionShape3D *col_shape = *I;
 					if (col_shape->get_shape().is_valid()) {
 						aabb.merge_with(col_shape->get_global_transform().xform(col_shape->get_shape()->get_debug_mesh()->get_aabb()));
 						found_valid_shape = true;
@@ -6754,7 +6755,7 @@ void Node3DEditor::snap_selected_nodes_to_floor() {
 				}
 			}
 			if (!found_valid_shape && vi.size()) {
-				AABB aabb = vi.front()->get()->get_transformed_aabb();
+				AABB aabb = (*vi.begin())->get_transformed_aabb();
 				for (const VisualInstance3D *I : vi) {
 					aabb.merge_with(I->get_transformed_aabb());
 				}
@@ -6798,7 +6799,7 @@ void Node3DEditor::snap_selected_nodes_to_floor() {
 			Dictionary d = snap_data[node];
 			Vector3 from = d["from"];
 			Vector3 to = from - Vector3(0.0, max_snap_height, 0.0);
-			RBSet<RID> excluded = _get_physics_bodies_rid(sp);
+			HashSet<RID> excluded = _get_physics_bodies_rid(sp);
 
 			PhysicsDirectSpaceState3D::RayParameters ray_params;
 			ray_params.from = from;
@@ -6820,7 +6821,7 @@ void Node3DEditor::snap_selected_nodes_to_floor() {
 				Dictionary d = snap_data[node];
 				Vector3 from = d["from"];
 				Vector3 to = from - Vector3(0.0, max_snap_height, 0.0);
-				RBSet<RID> excluded = _get_physics_bodies_rid(sp);
+				HashSet<RID> excluded = _get_physics_bodies_rid(sp);
 
 				PhysicsDirectSpaceState3D::RayParameters ray_params;
 				ray_params.from = from;
diff --git a/editor/plugins/packed_scene_translation_parser_plugin.h b/editor/plugins/packed_scene_translation_parser_plugin.h
index 9135498333..1bfb500933 100644
--- a/editor/plugins/packed_scene_translation_parser_plugin.h
+++ b/editor/plugins/packed_scene_translation_parser_plugin.h
@@ -37,7 +37,7 @@ class PackedSceneEditorTranslationParserPlugin : public EditorTranslationParserP
 	GDCLASS(PackedSceneEditorTranslationParserPlugin, EditorTranslationParserPlugin);
 
 	// Scene Node's properties that contain translation strings.
-	RBSet<String> lookup_properties;
+	HashSet<String> lookup_properties;
 	// Properties from specific Nodes that should be ignored.
 	HashMap<String, Vector<String>> exception_list;
 
diff --git a/editor/plugins/root_motion_editor_plugin.cpp b/editor/plugins/root_motion_editor_plugin.cpp
index bebc0e9d54..681dd476e3 100644
--- a/editor/plugins/root_motion_editor_plugin.cpp
+++ b/editor/plugins/root_motion_editor_plugin.cpp
@@ -65,7 +65,7 @@ void EditorPropertyRootMotion::_node_assign() {
 		return;
 	}
 
-	RBSet<String> paths;
+	HashSet<String> paths;
 	{
 		List<StringName> animations;
 		player->get_animation_list(&animations);
diff --git a/editor/plugins/script_editor_plugin.cpp b/editor/plugins/script_editor_plugin.cpp
index 115c6f43dd..99b810be44 100644
--- a/editor/plugins/script_editor_plugin.cpp
+++ b/editor/plugins/script_editor_plugin.cpp
@@ -1715,7 +1715,7 @@ void ScriptEditor::notify_script_changed(const Ref<Script> &p_script) {
 }
 
 void ScriptEditor::get_breakpoints(List<String> *p_breakpoints) {
-	RBSet<String> loaded_scripts;
+	HashSet<String> loaded_scripts;
 	for (int i = 0; i < tab_container->get_tab_count(); i++) {
 		ScriptEditorBase *se = Object::cast_to<ScriptEditorBase>(tab_container->get_tab_control(i));
 		if (!se) {
@@ -1800,7 +1800,7 @@ void ScriptEditor::ensure_select_current() {
 	_update_selected_editor_menu();
 }
 
-void ScriptEditor::_find_scripts(Node *p_base, Node *p_current, RBSet<Ref<Script>> &used) {
+void ScriptEditor::_find_scripts(Node *p_base, Node *p_current, HashSet<Ref<Script>> &used) {
 	if (p_current != p_base && p_current->get_owner() != p_base) {
 		return;
 	}
@@ -1980,7 +1980,7 @@ void ScriptEditor::_update_script_names() {
 		return;
 	}
 
-	RBSet<Ref<Script>> used;
+	HashSet<Ref<Script>> used;
 	Node *edited = EditorNode::get_singleton()->get_edited_scene();
 	if (edited) {
 		_find_scripts(edited, edited, used);
@@ -3143,7 +3143,7 @@ void ScriptEditor::set_window_layout(Ref<ConfigFile> p_layout) {
 
 	restoring_layout = true;
 
-	RBSet<String> loaded_scripts;
+	HashSet<String> loaded_scripts;
 	List<String> extensions;
 	ResourceLoader::get_recognized_extensions_for_type("Script", &extensions);
 
diff --git a/editor/plugins/script_editor_plugin.h b/editor/plugins/script_editor_plugin.h
index ff71c8b484..9f088aac49 100644
--- a/editor/plugins/script_editor_plugin.h
+++ b/editor/plugins/script_editor_plugin.h
@@ -414,7 +414,7 @@ class ScriptEditor : public PanelContainer {
 	void _update_help_overview();
 	void _help_overview_selected(int p_idx);
 
-	void _find_scripts(Node *p_base, Node *p_current, RBSet<Ref<Script>> &used);
+	void _find_scripts(Node *p_base, Node *p_current, HashSet<Ref<Script>> &used);
 
 	void _tree_changed();
 
@@ -454,7 +454,7 @@ class ScriptEditor : public PanelContainer {
 	Ref<Script> _get_current_script();
 	Array _get_open_scripts() const;
 
-	RBSet<String> textfile_extensions;
+	HashSet<String> textfile_extensions;
 	Ref<TextFile> _load_text_file(const String &p_path, Error *r_error) const;
 	Error _save_text_file(Ref<TextFile> p_text_file, const String &p_path);
 
diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp
index f666ac0649..a4bccf30e3 100644
--- a/editor/plugins/script_text_editor.cpp
+++ b/editor/plugins/script_text_editor.cpp
@@ -664,7 +664,7 @@ static Node *_find_node_for_script(Node *p_base, Node *p_current, const Ref<Scri
 	return nullptr;
 }
 
-static void _find_changed_scripts_for_external_editor(Node *p_base, Node *p_current, RBSet<Ref<Script>> &r_scripts) {
+static void _find_changed_scripts_for_external_editor(Node *p_base, Node *p_current, HashSet<Ref<Script>> &r_scripts) {
 	if (p_current->get_owner() != p_base && p_base != p_current) {
 		return;
 	}
@@ -686,7 +686,7 @@ void ScriptEditor::_update_modified_scripts_for_external_editor(Ref<Script> p_fo
 
 	ERR_FAIL_COND(!get_tree());
 
-	RBSet<Ref<Script>> scripts;
+	HashSet<Ref<Script>> scripts;
 
 	Node *base = get_tree()->get_edited_scene_root();
 	if (base) {
@@ -970,7 +970,7 @@ void ScriptTextEditor::_update_connected_methods() {
 	}
 
 	Vector<Node *> nodes = _find_all_node_for_script(base, base, script);
-	RBSet<StringName> methods_found;
+	HashSet<StringName> methods_found;
 	for (int i = 0; i < nodes.size(); i++) {
 		List<Connection> connections;
 		nodes[i]->get_signals_connected_to_this(&connections);
diff --git a/editor/plugins/script_text_editor.h b/editor/plugins/script_text_editor.h
index ff13b38832..fc87c84a2c 100644
--- a/editor/plugins/script_text_editor.h
+++ b/editor/plugins/script_text_editor.h
@@ -64,7 +64,7 @@ class ScriptTextEditor : public ScriptEditorBase {
 	Vector<String> functions;
 	List<ScriptLanguage::Warning> warnings;
 	List<ScriptLanguage::ScriptError> errors;
-	RBSet<int> safe_lines;
+	HashSet<int> safe_lines;
 
 	List<Connection> missing_connections;
 
diff --git a/editor/plugins/sprite_frames_editor_plugin.h b/editor/plugins/sprite_frames_editor_plugin.h
index 6f16ff2bd1..f7985aba18 100644
--- a/editor/plugins/sprite_frames_editor_plugin.h
+++ b/editor/plugins/sprite_frames_editor_plugin.h
@@ -103,8 +103,8 @@ class SpriteFramesEditor : public HSplitContainer {
 	Button *split_sheet_zoom_reset = nullptr;
 	Button *split_sheet_zoom_in = nullptr;
 	EditorFileDialog *file_split_sheet = nullptr;
-	RBSet<int> frames_selected;
-	RBSet<int> frames_toggled_by_mouse_hover;
+	HashSet<int> frames_selected;
+	HashSet<int> frames_toggled_by_mouse_hover;
 	int last_frame_selected = 0;
 
 	float scale_ratio;
diff --git a/editor/plugins/visual_shader_editor_plugin.cpp b/editor/plugins/visual_shader_editor_plugin.cpp
index 0595357926..f8797ded66 100644
--- a/editor/plugins/visual_shader_editor_plugin.cpp
+++ b/editor/plugins/visual_shader_editor_plugin.cpp
@@ -1670,7 +1670,7 @@ void VisualShaderEditor::_update_uniforms(bool p_update_refs) {
 	}
 }
 
-void VisualShaderEditor::_update_uniform_refs(RBSet<String> &p_deleted_names) {
+void VisualShaderEditor::_update_uniform_refs(HashSet<String> &p_deleted_names) {
 	for (int i = 0; i < VisualShader::TYPE_MAX; i++) {
 		VisualShader::Type type = VisualShader::Type(i);
 
@@ -2288,7 +2288,7 @@ void VisualShaderEditor::_uniform_line_edit_changed(const String &p_text, int p_
 	undo_redo->add_do_method(this, "_update_uniforms", true);
 	undo_redo->add_undo_method(this, "_update_uniforms", true);
 
-	RBSet<String> changed_names;
+	HashSet<String> changed_names;
 	changed_names.insert(node->get_uniform_name());
 	_update_uniform_refs(changed_names);
 
@@ -3108,7 +3108,7 @@ void VisualShaderEditor::_delete_nodes(int p_type, const List<int> &p_nodes) {
 		}
 	}
 
-	RBSet<String> uniform_names;
+	HashSet<String> uniform_names;
 
 	for (const int &F : p_nodes) {
 		Ref<VisualShaderNode> node = visual_shader->get_node(type, F);
@@ -3212,8 +3212,8 @@ void VisualShaderEditor::_convert_constants_to_uniforms(bool p_vice_versa) {
 		undo_redo->create_action(TTR("Convert Uniform Node(s) To Constant(s)"));
 	}
 
-	const RBSet<int> &current_set = p_vice_versa ? selected_uniforms : selected_constants;
-	RBSet<String> deleted_names;
+	const HashSet<int> &current_set = p_vice_versa ? selected_uniforms : selected_constants;
+	HashSet<String> deleted_names;
 
 	for (const int &E : current_set) {
 		int node_id = E;
@@ -3789,7 +3789,7 @@ void VisualShaderEditor::_dup_copy_nodes(int p_type, List<CopyItem> &r_items, Li
 	selection_center.x = 0.0f;
 	selection_center.y = 0.0f;
 
-	RBSet<int> nodes;
+	HashSet<int> nodes;
 
 	for (int i = 0; i < graph->get_child_count(); i++) {
 		GraphNode *gn = Object::cast_to<GraphNode>(graph->get_child(i));
@@ -3869,8 +3869,8 @@ void VisualShaderEditor::_dup_paste_nodes(int p_type, List<CopyItem> &r_items, c
 	int base_id = visual_shader->get_valid_node_id(type);
 	int id_from = base_id;
 	HashMap<int, int> connection_remap;
-	RBSet<int> unsupported_set;
-	RBSet<int> added_set;
+	HashSet<int> unsupported_set;
+	HashSet<int> added_set;
 
 	for (CopyItem &item : r_items) {
 		if (item.disabled) {
diff --git a/editor/plugins/visual_shader_editor_plugin.h b/editor/plugins/visual_shader_editor_plugin.h
index 003c8b15a8..1b56892ebf 100644
--- a/editor/plugins/visual_shader_editor_plugin.h
+++ b/editor/plugins/visual_shader_editor_plugin.h
@@ -358,8 +358,8 @@ class VisualShaderEditor : public VBoxContainer {
 	int from_node = -1;
 	int from_slot = -1;
 
-	RBSet<int> selected_constants;
-	RBSet<int> selected_uniforms;
+	HashSet<int> selected_constants;
+	HashSet<int> selected_uniforms;
 	int selected_comment = -1;
 	int selected_float_constant = -1;
 
@@ -468,7 +468,7 @@ class VisualShaderEditor : public VBoxContainer {
 	bool _is_available(int p_mode);
 	void _update_created_node(GraphNode *node);
 	void _update_uniforms(bool p_update_refs);
-	void _update_uniform_refs(RBSet<String> &p_names);
+	void _update_uniform_refs(HashSet<String> &p_names);
 	void _update_varyings();
 
 	void _visibility_changed();
diff --git a/editor/pot_generator.cpp b/editor/pot_generator.cpp
index bfc58db2ad..a00df0ef40 100644
--- a/editor/pot_generator.cpp
+++ b/editor/pot_generator.cpp
@@ -127,7 +127,7 @@ void POTGenerator::_write_to_pot(const String &p_file) {
 		for (int i = 0; i < v_msgid_data.size(); i++) {
 			String context = v_msgid_data[i].ctx;
 			String plural = v_msgid_data[i].plural;
-			const RBSet<String> &locations = v_msgid_data[i].locations;
+			const HashSet<String> &locations = v_msgid_data[i].locations;
 
 			// Put the blank line at the start, to avoid a double at the end when closing the file.
 			file->store_line("");
diff --git a/editor/pot_generator.h b/editor/pot_generator.h
index b24eadfd95..7b14eb027e 100644
--- a/editor/pot_generator.h
+++ b/editor/pot_generator.h
@@ -33,7 +33,7 @@
 
 #include "core/io/file_access.h"
 #include "core/templates/hash_map.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 
 //#define DEBUG_POT
 
@@ -43,7 +43,7 @@ class POTGenerator {
 	struct MsgidData {
 		String ctx;
 		String plural;
-		RBSet<String> locations;
+		HashSet<String> locations;
 	};
 	// Store msgid as key and the additional data around the msgid - if it's under a context, has plurals and its file locations.
 	HashMap<String, Vector<MsgidData>> all_translation_strings;
diff --git a/editor/project_export.cpp b/editor/project_export.cpp
index 839378dad2..503eb5000b 100644
--- a/editor/project_export.cpp
+++ b/editor/project_export.cpp
@@ -366,10 +366,13 @@ void ProjectExportDialog::_update_feature_list() {
 	}
 
 	custom_feature_display->clear();
-	for (RBSet<String>::Element *E = fset.front(); E; E = E->next()) {
-		String f = E->get();
-		if (E->next()) {
+	bool first = true;
+	for (const String &E : fset) {
+		String f = E;
+		if (!first) {
 			f += ", ";
+		} else {
+			first = false;
 		}
 		custom_feature_display->add_text(f);
 	}
diff --git a/editor/project_manager.cpp b/editor/project_manager.cpp
index 2eb0a3a76a..379c3bbb01 100644
--- a/editor/project_manager.cpp
+++ b/editor/project_manager.cpp
@@ -1064,7 +1064,7 @@ public:
 	void select_first_visible_project();
 	void erase_selected_projects(bool p_delete_project_contents);
 	Vector<Item> get_selected_projects() const;
-	const RBSet<String> &get_selected_project_keys() const;
+	const HashSet<String> &get_selected_project_keys() const;
 	void ensure_project_visible(int p_index);
 	int get_single_selected_index() const;
 	bool is_any_project_missing() const;
@@ -1090,7 +1090,7 @@ private:
 
 	String _search_term;
 	FilterOption _order_option;
-	RBSet<String> _selected_project_keys;
+	HashSet<String> _selected_project_keys;
 	String _last_clicked; // Project key
 	VBoxContainer *_scroll_children;
 	int _icon_load_index;
@@ -1258,7 +1258,7 @@ void ProjectList::load_projects() {
 	List<PropertyInfo> properties;
 	EditorSettings::get_singleton()->get_property_list(&properties);
 
-	RBSet<String> favorites;
+	HashSet<String> favorites;
 	// Find favourites...
 	for (const PropertyInfo &E : properties) {
 		String property_key = E.name;
@@ -1504,7 +1504,7 @@ void ProjectList::sort_projects() {
 	update_dock_menu();
 }
 
-const RBSet<String> &ProjectList::get_selected_project_keys() const {
+const HashSet<String> &ProjectList::get_selected_project_keys() const {
 	// Faster if that's all you need
 	return _selected_project_keys;
 }
@@ -1539,7 +1539,7 @@ int ProjectList::get_single_selected_index() const {
 	String key;
 	if (_selected_project_keys.size() == 1) {
 		// Only one selected
-		key = _selected_project_keys.front()->get();
+		key = *_selected_project_keys.begin();
 	} else {
 		// Multiple selected, consider the last clicked one as "main"
 		key = _last_clicked;
@@ -2107,7 +2107,7 @@ void ProjectManager::_open_selected_projects() {
 	// This is especially important for the HTML5 project manager.
 	loading_label->show();
 
-	const RBSet<String> &selected_list = _project_list->get_selected_project_keys();
+	const HashSet<String> &selected_list = _project_list->get_selected_project_keys();
 
 	for (const String &E : selected_list) {
 		const String &selected = E;
@@ -2156,7 +2156,7 @@ void ProjectManager::_open_selected_projects() {
 }
 
 void ProjectManager::_open_selected_projects_ask() {
-	const RBSet<String> &selected_list = _project_list->get_selected_project_keys();
+	const HashSet<String> &selected_list = _project_list->get_selected_project_keys();
 
 	if (selected_list.size() < 1) {
 		return;
@@ -2271,7 +2271,7 @@ void ProjectManager::_run_project_confirm() {
 }
 
 void ProjectManager::_run_project() {
-	const RBSet<String> &selected_list = _project_list->get_selected_project_keys();
+	const HashSet<String> &selected_list = _project_list->get_selected_project_keys();
 
 	if (selected_list.size() < 1) {
 		return;
@@ -2331,7 +2331,7 @@ void ProjectManager::_import_project() {
 }
 
 void ProjectManager::_rename_project() {
-	const RBSet<String> &selected_list = _project_list->get_selected_project_keys();
+	const HashSet<String> &selected_list = _project_list->get_selected_project_keys();
 
 	if (selected_list.size() == 0) {
 		return;
@@ -2357,7 +2357,7 @@ void ProjectManager::_erase_missing_projects_confirm() {
 }
 
 void ProjectManager::_erase_project() {
-	const RBSet<String> &selected_list = _project_list->get_selected_project_keys();
+	const HashSet<String> &selected_list = _project_list->get_selected_project_keys();
 
 	if (selected_list.size() == 0) {
 		return;
@@ -2414,7 +2414,7 @@ void ProjectManager::_files_dropped(PackedStringArray p_files) {
 		_install_project(p_files[0], file.substr(0, file.length() - 4).capitalize());
 		return;
 	}
-	RBSet<String> folders_set;
+	HashSet<String> folders_set;
 	Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
 	for (int i = 0; i < p_files.size(); i++) {
 		String file = p_files[i];
diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp
index 5367306f1a..14a0427e18 100644
--- a/editor/project_settings_editor.cpp
+++ b/editor/project_settings_editor.cpp
@@ -249,7 +249,7 @@ String ProjectSettingsEditor::_get_setting_name() const {
 }
 
 void ProjectSettingsEditor::_add_feature_overrides() {
-	RBSet<String> presets;
+	HashSet<String> presets;
 
 	presets.insert("bptc");
 	presets.insert("s3tc");
diff --git a/editor/property_editor.cpp b/editor/property_editor.cpp
index d541b26cc9..da67ed79ba 100644
--- a/editor/property_editor.cpp
+++ b/editor/property_editor.cpp
@@ -137,7 +137,7 @@ void CustomPropertyEditor::_menu_option(int p_which) {
 						ResourceLoader::get_recognized_extensions_for_type(type.get_slice(",", i), &extensions);
 					}
 
-					RBSet<String> valid_extensions;
+					HashSet<String> valid_extensions;
 					for (const String &E : extensions) {
 						valid_extensions.insert(E);
 					}
@@ -875,7 +875,7 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 				for (int i = 0; i < hint_text.get_slice_count(","); i++) {
 					String base = hint_text.get_slice(",", i);
 
-					RBSet<String> valid_inheritors;
+					HashSet<String> valid_inheritors;
 					valid_inheritors.insert(base);
 					List<StringName> inheritors;
 					ClassDB::get_inheriters_from_class(base.strip_edges(), &inheritors);
diff --git a/editor/reparent_dialog.cpp b/editor/reparent_dialog.cpp
index 38d909038f..5a8fe24518 100644
--- a/editor/reparent_dialog.cpp
+++ b/editor/reparent_dialog.cpp
@@ -57,7 +57,7 @@ void ReparentDialog::_reparent() {
 	}
 }
 
-void ReparentDialog::set_current(const RBSet<Node *> &p_selection) {
+void ReparentDialog::set_current(const HashSet<Node *> &p_selection) {
 	tree->set_marked(p_selection, false, false);
 	//tree->set_selected(p_node->get_parent());
 }
diff --git a/editor/reparent_dialog.h b/editor/reparent_dialog.h
index a5a9818e7f..49b00661a0 100644
--- a/editor/reparent_dialog.h
+++ b/editor/reparent_dialog.h
@@ -52,7 +52,7 @@ protected:
 	static void _bind_methods();
 
 public:
-	void set_current(const RBSet<Node *> &p_selection);
+	void set_current(const HashSet<Node *> &p_selection);
 
 	ReparentDialog();
 	~ReparentDialog();
diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp
index afb3ac7c15..2387f65229 100644
--- a/editor/scene_tree_dock.cpp
+++ b/editor/scene_tree_dock.cpp
@@ -717,7 +717,7 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			}
 
 			List<Node *> nodes = editor_selection->get_selected_node_list();
-			RBSet<Node *> nodeset;
+			HashSet<Node *> nodeset;
 			for (Node *E : nodes) {
 				nodeset.insert(E);
 			}
@@ -1528,8 +1528,8 @@ bool SceneTreeDock::_check_node_path_recursive(Node *p_root_node, Variant &r_var
 	return false;
 }
 
-void SceneTreeDock::perform_node_renames(Node *p_base, HashMap<Node *, NodePath> *p_renames, HashMap<Ref<Animation>, RBSet<int>> *r_rem_anims) {
-	HashMap<Ref<Animation>, RBSet<int>> rem_anims;
+void SceneTreeDock::perform_node_renames(Node *p_base, HashMap<Node *, NodePath> *p_renames, HashMap<Ref<Animation>, HashSet<int>> *r_rem_anims) {
+	HashMap<Ref<Animation>, HashSet<int>> rem_anims;
 	if (!r_rem_anims) {
 		r_rem_anims = &rem_anims;
 	}
@@ -1581,14 +1581,14 @@ void SceneTreeDock::perform_node_renames(Node *p_base, HashMap<Node *, NodePath>
 				for (const StringName &E : anims) {
 					Ref<Animation> anim = ap->get_animation(E);
 					if (!r_rem_anims->has(anim)) {
-						r_rem_anims->insert(anim, RBSet<int>());
-						RBSet<int> &ran = r_rem_anims->find(anim)->value;
+						r_rem_anims->insert(anim, HashSet<int>());
+						HashSet<int> &ran = r_rem_anims->find(anim)->value;
 						for (int i = 0; i < anim->get_track_count(); i++) {
 							ran.insert(i);
 						}
 					}
 
-					RBSet<int> &ran = r_rem_anims->find(anim)->value;
+					HashSet<int> &ran = r_rem_anims->find(anim)->value;
 
 					if (anim.is_null()) {
 						continue;
@@ -1611,11 +1611,11 @@ void SceneTreeDock::perform_node_renames(Node *p_base, HashMap<Node *, NodePath>
 								//will be erased
 
 								int idx = 0;
-								RBSet<int>::Element *EI = ran.front();
+								HashSet<int>::Iterator EI = ran.begin();
 								ERR_FAIL_COND(!EI); //bug
-								while (EI->get() != i) {
+								while (*EI != i) {
 									idx++;
-									EI = EI->next();
+									++EI;
 									ERR_FAIL_COND(!EI); //another bug
 								}
 
diff --git a/editor/scene_tree_dock.h b/editor/scene_tree_dock.h
index 1e58a7a66a..aa64945d81 100644
--- a/editor/scene_tree_dock.h
+++ b/editor/scene_tree_dock.h
@@ -293,7 +293,7 @@ public:
 	void instantiate_scenes(const Vector<String> &p_files, Node *p_parent = nullptr);
 	void set_selected(Node *p_node, bool p_emit_selected = false);
 	void fill_path_renames(Node *p_node, Node *p_new_parent, HashMap<Node *, NodePath> *p_renames);
-	void perform_node_renames(Node *p_base, HashMap<Node *, NodePath> *p_renames, HashMap<Ref<Animation>, RBSet<int>> *r_rem_anims = nullptr);
+	void perform_node_renames(Node *p_base, HashMap<Node *, NodePath> *p_renames, HashMap<Ref<Animation>, HashSet<int>> *r_rem_anims = nullptr);
 	SceneTreeEditor *get_tree_editor() { return scene_tree; }
 	EditorData *get_editor_data() { return editor_data; }
 
diff --git a/editor/scene_tree_editor.cpp b/editor/scene_tree_editor.cpp
index afb42efa76..fbcf9739ca 100644
--- a/editor/scene_tree_editor.cpp
+++ b/editor/scene_tree_editor.cpp
@@ -874,7 +874,7 @@ Node *SceneTreeEditor::get_selected() {
 	return selected;
 }
 
-void SceneTreeEditor::set_marked(const RBSet<Node *> &p_marked, bool p_selectable, bool p_children_selectable) {
+void SceneTreeEditor::set_marked(const HashSet<Node *> &p_marked, bool p_selectable, bool p_children_selectable) {
 	if (tree_dirty) {
 		_update_tree();
 	}
@@ -885,7 +885,7 @@ void SceneTreeEditor::set_marked(const RBSet<Node *> &p_marked, bool p_selectabl
 }
 
 void SceneTreeEditor::set_marked(Node *p_marked, bool p_selectable, bool p_children_selectable) {
-	RBSet<Node *> s;
+	HashSet<Node *> s;
 	if (p_marked) {
 		s.insert(p_marked);
 	}
diff --git a/editor/scene_tree_editor.h b/editor/scene_tree_editor.h
index 604d77cf76..1f79b48449 100644
--- a/editor/scene_tree_editor.h
+++ b/editor/scene_tree_editor.h
@@ -99,7 +99,7 @@ class SceneTreeEditor : public Control {
 	void _renamed();
 	UndoRedo *undo_redo = nullptr;
 
-	RBSet<Node *> marked;
+	HashSet<Node *> marked;
 	bool marked_selectable = false;
 	bool marked_children_selectable = false;
 	bool display_foreign = false;
@@ -140,7 +140,7 @@ public:
 	void set_undo_redo(UndoRedo *p_undo_redo) { undo_redo = p_undo_redo; };
 	void set_display_foreign_nodes(bool p_display);
 
-	void set_marked(const RBSet<Node *> &p_marked, bool p_selectable = false, bool p_children_selectable = true);
+	void set_marked(const HashSet<Node *> &p_marked, bool p_selectable = false, bool p_children_selectable = true);
 	void set_marked(Node *p_marked, bool p_selectable = false, bool p_children_selectable = true);
 	void set_selected(Node *p_node, bool p_emit_selected = true);
 	Node *get_selected();
diff --git a/editor/shader_create_dialog.cpp b/editor/shader_create_dialog.cpp
index 046e8fcdfc..9c322320b8 100644
--- a/editor/shader_create_dialog.cpp
+++ b/editor/shader_create_dialog.cpp
@@ -382,7 +382,7 @@ String ShaderCreateDialog::_validate_path(const String &p_path) {
 	}
 
 	String extension = p.get_extension();
-	RBSet<String> extensions;
+	HashSet<String> extensions;
 
 	for (int i = 0; i < SHADER_TYPE_MAX; i++) {
 		for (const String &ext : language_data[i].extensions) {
diff --git a/main/main.cpp b/main/main.cpp
index 4d4173b2ee..fff78d9e8f 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -2150,7 +2150,7 @@ bool Main::start() {
 
 		DocTools docsrc;
 		HashMap<String, String> doc_data_classes;
-		RBSet<String> checked_paths;
+		HashSet<String> checked_paths;
 		print_line("Loading docs...");
 
 		for (int i = 0; i < _doc_data_class_path_count; i++) {
diff --git a/modules/gdscript/editor/gdscript_translation_parser_plugin.h b/modules/gdscript/editor/gdscript_translation_parser_plugin.h
index 4633a431d8..969a50f48c 100644
--- a/modules/gdscript/editor/gdscript_translation_parser_plugin.h
+++ b/modules/gdscript/editor/gdscript_translation_parser_plugin.h
@@ -31,7 +31,7 @@
 #ifndef GDSCRIPT_TRANSLATION_PARSER_PLUGIN_H
 #define GDSCRIPT_TRANSLATION_PARSER_PLUGIN_H
 
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 #include "editor/editor_translation_parser.h"
 #include "modules/gdscript/gdscript_parser.h"
 
@@ -44,9 +44,9 @@ class GDScriptEditorTranslationParserPlugin : public EditorTranslationParserPlug
 	// List of patterns used for extracting translation strings.
 	StringName tr_func = "tr";
 	StringName trn_func = "tr_n";
-	RBSet<StringName> assignment_patterns;
-	RBSet<StringName> first_arg_patterns;
-	RBSet<StringName> second_arg_patterns;
+	HashSet<StringName> assignment_patterns;
+	HashSet<StringName> first_arg_patterns;
+	HashSet<StringName> second_arg_patterns;
 	// FileDialog patterns.
 	StringName fd_add_filter = "add_filter";
 	StringName fd_set_filter = "set_filters";
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 25f4823d92..066b772227 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -788,7 +788,7 @@ void GDScript::update_exports() {
 		return;
 	}
 
-	RBSet<ObjectID> copy = inheriters_cache; //might get modified
+	HashSet<ObjectID> copy = inheriters_cache; //might get modified
 
 	for (const ObjectID &E : copy) {
 		Object *id = ObjectDB::get_instance(E);
@@ -937,7 +937,7 @@ void GDScript::get_constants(HashMap<StringName, Variant> *p_constants) {
 	}
 }
 
-void GDScript::get_members(RBSet<StringName> *p_members) {
+void GDScript::get_members(HashSet<StringName> *p_members) {
 	if (p_members) {
 		for (const StringName &E : members) {
 			p_members->insert(E);
@@ -1916,7 +1916,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 #ifdef TOOLS_ENABLED
 
 			while (script->placeholders.size()) {
-				Object *obj = script->placeholders.front()->get()->get_owner();
+				Object *obj = (*script->placeholders.begin())->get_owner();
 
 				//save instance info
 				if (obj->get_script_instance()) {
@@ -1926,7 +1926,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 					obj->set_script(Variant());
 				} else {
 					// no instance found. Let's remove it so we don't loop forever
-					script->placeholders.erase(script->placeholders.front()->get());
+					script->placeholders.erase(*script->placeholders.begin());
 				}
 			}
 
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index 5199d3215d..80f187a375 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -37,6 +37,7 @@
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
 #include "core/object/script_language.h"
+#include "core/templates/rb_set.h"
 #include "gdscript_function.h"
 
 class GDScriptNativeClass : public RefCounted {
@@ -80,7 +81,7 @@ class GDScript : public Script {
 	GDScript *_base = nullptr; //fast pointer access
 	GDScript *_owner = nullptr; //for subclasses
 
-	RBSet<StringName> members; //members are just indices to the instantiated script.
+	HashSet<StringName> members; //members are just indices to the instantiated script.
 	HashMap<StringName, Variant> constants;
 	HashMap<StringName, GDScriptFunction *> member_functions;
 	HashMap<StringName, MemberInfo> member_indices; //members are just indices to the instantiated script.
@@ -95,7 +96,7 @@ class GDScript : public Script {
 	List<PropertyInfo> members_cache;
 	HashMap<StringName, Variant> member_default_values_cache;
 	Ref<GDScript> base_cache;
-	RBSet<ObjectID> inheriters_cache;
+	HashSet<ObjectID> inheriters_cache;
 	bool source_changed_cache = false;
 	bool placeholder_fallback_enabled = false;
 	void _update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames);
@@ -139,7 +140,7 @@ class GDScript : public Script {
 	String _get_debug_path() const;
 
 #ifdef TOOLS_ENABLED
-	RBSet<PlaceHolderScriptInstance *> placeholders;
+	HashSet<PlaceHolderScriptInstance *> placeholders;
 	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override;
 #endif
@@ -178,7 +179,7 @@ public:
 
 	const HashMap<StringName, Ref<GDScript>> &get_subclasses() const { return subclasses; }
 	const HashMap<StringName, Variant> &get_constants() const { return constants; }
-	const RBSet<StringName> &get_members() const { return members; }
+	const HashSet<StringName> &get_members() const { return members; }
 	const GDScriptDataType &get_member_type(const StringName &p_member) const {
 		CRASH_COND(!member_indices.has(p_member));
 		return member_indices[p_member].data_type;
@@ -246,7 +247,7 @@ public:
 	}
 
 	virtual void get_constants(HashMap<StringName, Variant> *p_constants) override;
-	virtual void get_members(RBSet<StringName> *p_members) override;
+	virtual void get_members(HashSet<StringName> *p_members) override;
 
 	virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const override;
 
@@ -449,7 +450,7 @@ public:
 	virtual bool is_using_templates() override;
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
 	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const override;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
 	virtual Script *create_script() const override;
 	virtual bool has_named_classes() const override;
 	virtual bool supports_builtin_mode() const override;
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 32fa3b8c87..3976bde8c9 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -898,7 +898,7 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class) {
 			}
 
 #ifdef DEBUG_ENABLED
-			RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
+			HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 			for (uint32_t ignored_warning : member.function->ignored_warnings) {
 				parser->ignored_warning_codes.insert(ignored_warning);
 			}
@@ -947,7 +947,7 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class) {
 		GDScriptParser::ClassNode::Member member = p_class->members[i];
 		if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
 #ifdef DEBUG_ENABLED
-			RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
+			HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 			for (uint32_t ignored_warning : member.function->ignored_warnings) {
 				parser->ignored_warning_codes.insert(ignored_warning);
 			}
@@ -1279,7 +1279,7 @@ void GDScriptAnalyzer::resolve_suite(GDScriptParser::SuiteNode *p_suite) {
 		}
 
 #ifdef DEBUG_ENABLED
-		RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
+		HashSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 		for (uint32_t ignored_warning : stmt->ignored_warnings) {
 			parser->ignored_warning_codes.insert(ignored_warning);
 		}
diff --git a/modules/gdscript/gdscript_analyzer.h b/modules/gdscript/gdscript_analyzer.h
index 5b03f6dbb4..3966b81b6e 100644
--- a/modules/gdscript/gdscript_analyzer.h
+++ b/modules/gdscript/gdscript_analyzer.h
@@ -33,7 +33,7 @@
 
 #include "core/object/object.h"
 #include "core/object/ref_counted.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 #include "gdscript_cache.h"
 #include "gdscript_parser.h"
 
diff --git a/modules/gdscript/gdscript_cache.cpp b/modules/gdscript/gdscript_cache.cpp
index bd98d66fcc..4c15fca91e 100644
--- a/modules/gdscript/gdscript_cache.cpp
+++ b/modules/gdscript/gdscript_cache.cpp
@@ -223,13 +223,13 @@ Error GDScriptCache::finish_compiling(const String &p_owner) {
 	singleton->full_gdscript_cache[p_owner] = script.ptr();
 	singleton->shallow_gdscript_cache.erase(p_owner);
 
-	RBSet<String> depends = singleton->dependencies[p_owner];
+	HashSet<String> depends = singleton->dependencies[p_owner];
 
 	Error err = OK;
-	for (const RBSet<String>::Element *E = depends.front(); E != nullptr; E = E->next()) {
+	for (const String &E : depends) {
 		Error this_err = OK;
 		// No need to save the script. We assume it's already referenced in the owner.
-		get_full_script(E->get(), this_err);
+		get_full_script(E, this_err);
 
 		if (this_err != OK) {
 			err = this_err;
diff --git a/modules/gdscript/gdscript_cache.h b/modules/gdscript/gdscript_cache.h
index 8abae7d4ad..b971bdd984 100644
--- a/modules/gdscript/gdscript_cache.h
+++ b/modules/gdscript/gdscript_cache.h
@@ -34,7 +34,7 @@
 #include "core/object/ref_counted.h"
 #include "core/os/mutex.h"
 #include "core/templates/hash_map.h"
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 #include "gdscript.h"
 
 class GDScriptAnalyzer;
@@ -74,7 +74,7 @@ class GDScriptCache {
 	HashMap<String, GDScriptParserRef *> parser_map;
 	HashMap<String, GDScript *> shallow_gdscript_cache;
 	HashMap<String, GDScript *> full_gdscript_cache;
-	HashMap<String, RBSet<String>> dependencies;
+	HashMap<String, HashSet<String>> dependencies;
 
 	friend class GDScript;
 	friend class GDScriptParserRef;
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index c9ffb04fb8..4841884e2d 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -31,7 +31,7 @@
 #ifndef GDSCRIPT_COMPILER_H
 #define GDSCRIPT_COMPILER_H
 
-#include "core/templates/rb_set.h"
+#include "core/templates/hash_set.h"
 #include "gdscript.h"
 #include "gdscript_codegen.h"
 #include "gdscript_function.h"
@@ -39,8 +39,8 @@
 
 class GDScriptCompiler {
 	const GDScriptParser *parser = nullptr;
-	RBSet<GDScript *> parsed_classes;
-	RBSet<GDScript *> parsing_classes;
+	HashSet<GDScript *> parsed_classes;
+	HashSet<GDScript *> parsing_classes;
 	GDScript *main_script = nullptr;
 
 	struct CodeGen {
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 72f54626e3..5b63fe7466 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -110,7 +110,7 @@ static void get_function_names_recursively(const GDScriptParser::ClassNode *p_cl
 	}
 }
 
-bool GDScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, RBSet<int> *r_safe_lines) const {
+bool GDScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
 	GDScriptParser parser;
 	GDScriptAnalyzer analyzer(&parser);
 
@@ -159,7 +159,7 @@ bool GDScriptLanguage::validate(const String &p_script, const String &p_path, Li
 
 #ifdef DEBUG_ENABLED
 	if (r_safe_lines) {
-		const RBSet<int> &unsafe_lines = parser.get_unsafe_lines();
+		const HashSet<int> &unsafe_lines = parser.get_unsafe_lines();
 		for (int i = 1; i <= parser.get_last_line_number(); i++) {
 			if (!unsafe_lines.has(i)) {
 				r_safe_lines->insert(i);
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 17f87edeeb..96b9a10d3c 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -1205,9 +1205,9 @@ private:
 	List<ParserError> errors;
 #ifdef DEBUG_ENABLED
 	List<GDScriptWarning> warnings;
-	RBSet<String> ignored_warnings;
-	RBSet<uint32_t> ignored_warning_codes;
-	RBSet<int> unsafe_lines;
+	HashSet<String> ignored_warnings;
+	HashSet<uint32_t> ignored_warning_codes;
+	HashSet<int> unsafe_lines;
 #endif
 
 	GDScriptTokenizer tokenizer;
@@ -1419,7 +1419,7 @@ public:
 	}
 #ifdef DEBUG_ENABLED
 	const List<GDScriptWarning> &get_warnings() const { return warnings; }
-	const RBSet<int> &get_unsafe_lines() const { return unsafe_lines; }
+	const HashSet<int> &get_unsafe_lines() const { return unsafe_lines; }
 	int get_last_line_number() const { return current.end_line; }
 #endif
 
diff --git a/modules/gdscript/gdscript_tokenizer.h b/modules/gdscript/gdscript_tokenizer.h
index ad818cf812..7fb715f2c8 100644
--- a/modules/gdscript/gdscript_tokenizer.h
+++ b/modules/gdscript/gdscript_tokenizer.h
@@ -32,8 +32,8 @@
 #define GDSCRIPT_TOKENIZER_H
 
 #include "core/templates/hash_map.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/list.h"
-#include "core/templates/rb_set.h"
 #include "core/templates/vector.h"
 #include "core/variant/variant.h"
 
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index ffd3cfa907..8d484a43b3 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -784,7 +784,7 @@ GDScriptWorkspace::GDScriptWorkspace() {
 }
 
 GDScriptWorkspace::~GDScriptWorkspace() {
-	RBSet<String> cached_parsers;
+	HashSet<String> cached_parsers;
 
 	for (const KeyValue<String, ExtendGDScriptParser *> &E : parse_results) {
 		cached_parsers.insert(E.key);
diff --git a/modules/gdscript/register_types.cpp b/modules/gdscript/register_types.cpp
index 7cedbda804..b230c6ba36 100644
--- a/modules/gdscript/register_types.cpp
+++ b/modules/gdscript/register_types.cpp
@@ -70,7 +70,7 @@ class EditorExportGDScript : public EditorExportPlugin {
 	GDCLASS(EditorExportGDScript, EditorExportPlugin);
 
 public:
-	virtual void _export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) override {
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override {
 		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		String script_key;
 
diff --git a/modules/gltf/gltf_document.h b/modules/gltf/gltf_document.h
index 61a82e4bbc..2f61210ff9 100644
--- a/modules/gltf/gltf_document.h
+++ b/modules/gltf/gltf_document.h
@@ -128,12 +128,12 @@ private:
 	}
 
 	template <class T>
-	static Array to_array(const RBSet<T> &p_inp) {
+	static Array to_array(const HashSet<T> &p_inp) {
 		Array ret;
-		typename RBSet<T>::Element *elem = p_inp.front();
+		typename HashSet<T>::Iterator elem = p_inp.begin();
 		while (elem) {
-			ret.push_back(elem->get());
-			elem = elem->next();
+			ret.push_back(*elem);
+			++elem;
 		}
 		return ret;
 	}
@@ -147,7 +147,7 @@ private:
 	}
 
 	template <class T>
-	static void set_from_array(RBSet<T> &r_out, const Array &p_inp) {
+	static void set_from_array(HashSet<T> &r_out, const Array &p_inp) {
 		r_out.clear();
 		for (int i = 0; i < p_inp.size(); i++) {
 			r_out.insert(p_inp[i]);
diff --git a/modules/gltf/gltf_skeleton.h b/modules/gltf/gltf_skeleton.h
index 4dcee41465..92ee6e6234 100644
--- a/modules/gltf/gltf_skeleton.h
+++ b/modules/gltf/gltf_skeleton.h
@@ -50,7 +50,7 @@ private:
 	Skeleton3D *godot_skeleton = nullptr;
 
 	// Set of unique bone names for the skeleton
-	RBSet<String> unique_names;
+	HashSet<String> unique_names;
 
 	HashMap<int32_t, GLTFNodeIndex> godot_bone_node;
 
diff --git a/modules/gltf/gltf_state.h b/modules/gltf/gltf_state.h
index 5e3402b9a1..2fdef19038 100644
--- a/modules/gltf/gltf_state.h
+++ b/modules/gltf/gltf_state.h
@@ -81,8 +81,8 @@ class GLTFState : public Resource {
 	Vector<Ref<GLTFSkin>> skins;
 	Vector<Ref<GLTFCamera>> cameras;
 	Vector<Ref<GLTFLight>> lights;
-	RBSet<String> unique_names;
-	RBSet<String> unique_animation_names;
+	HashSet<String> unique_names;
+	HashSet<String> unique_animation_names;
 
 	Vector<Ref<GLTFSkeleton>> skeletons;
 	HashMap<GLTFSkeletonIndex, GLTFNodeIndex> skeleton_to_node;
diff --git a/modules/gridmap/grid_map.h b/modules/gridmap/grid_map.h
index 88e16bce82..d0872a839b 100644
--- a/modules/gridmap/grid_map.h
+++ b/modules/gridmap/grid_map.h
@@ -113,7 +113,7 @@ class GridMap : public Node3D {
 		};
 
 		Vector<MultimeshInstance> multimesh_instances;
-		RBSet<IndexKey> cells;
+		HashSet<IndexKey> cells;
 		RID collision_debug;
 		RID collision_debug_instance;
 
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index d0140f117c..bee4e0e1fb 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -875,7 +875,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
 		// Script::instances are deleted during managed object disposal, which happens on domain finalize.
 		// Only placeholders are kept. Therefore we need to keep a copy before that happens.
 
-		for (Object *&obj : script->instances) {
+		for (Object *obj : script->instances) {
 			script->pending_reload_instances.insert(obj->get_instance_id());
 
 			RefCounted *rc = Object::cast_to<RefCounted>(obj);
@@ -885,7 +885,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
 		}
 
 #ifdef TOOLS_ENABLED
-		for (PlaceHolderScriptInstance *&script_instance : script->placeholders) {
+		for (PlaceHolderScriptInstance *script_instance : script->placeholders) {
 			Object *obj = script_instance->get_owner();
 			script->pending_reload_instances.insert(obj->get_instance_id());
 
@@ -899,7 +899,7 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
 		// Save state and remove script from instances
 		RBMap<ObjectID, CSharpScript::StateBackup> &owners_map = script->pending_reload_state;
 
-		for (Object *&obj : script->instances) {
+		for (Object *obj : script->instances) {
 			ERR_CONTINUE(!obj->get_script_instance());
 
 			CSharpInstance *csi = static_cast<CSharpInstance *>(obj->get_script_instance());
@@ -922,8 +922,8 @@ void CSharpLanguage::reload_assemblies(bool p_soft_reload) {
 
 	// After the state of all instances is saved, clear scripts and script instances
 	for (Ref<CSharpScript> &script : scripts) {
-		while (script->instances.front()) {
-			Object *obj = script->instances.front()->get();
+		while (script->instances.begin()) {
+			Object *obj = *script->instances.begin();
 			obj->set_script(Ref<RefCounted>()); // Remove script and existing script instances (placeholder are not removed before domain reload)
 		}
 
@@ -2315,9 +2315,9 @@ CSharpInstance::~CSharpInstance() {
 
 #ifdef DEBUG_ENABLED
 		// CSharpInstance must not be created unless it's going to be added to the list for sure
-		RBSet<Object *>::Element *match = script->instances.find(owner);
+		HashSet<Object *>::Iterator match = script->instances.find(owner);
 		CRASH_COND(!match);
-		script->instances.erase(match);
+		script->instances.remove(match);
 #else
 		script->instances.erase(owner);
 #endif
@@ -2572,7 +2572,7 @@ bool CSharpScript::_update_exports(PlaceHolderScriptInstance *p_instance_to_upda
 			_update_exports_values(values, propnames);
 
 			if (changed) {
-				for (PlaceHolderScriptInstance *&script_instance : placeholders) {
+				for (PlaceHolderScriptInstance *script_instance : placeholders) {
 					script_instance->update(propnames, values);
 				}
 			} else {
@@ -3574,7 +3574,7 @@ CSharpScript::~CSharpScript() {
 #endif
 }
 
-void CSharpScript::get_members(RBSet<StringName> *p_members) {
+void CSharpScript::get_members(HashSet<StringName> *p_members) {
 #if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED)
 	if (p_members) {
 		for (const StringName &member_name : exported_members_names) {
diff --git a/modules/mono/csharp_script.h b/modules/mono/csharp_script.h
index 6e600bb47a..69bd8703aa 100644
--- a/modules/mono/csharp_script.h
+++ b/modules/mono/csharp_script.h
@@ -110,7 +110,7 @@ private:
 
 	Ref<CSharpScript> base_cache; // TODO what's this for?
 
-	RBSet<Object *> instances;
+	HashSet<Object *> instances;
 
 #ifdef GD_MONO_HOT_RELOAD
 	struct StateBackup {
@@ -121,7 +121,7 @@ private:
 		List<Pair<StringName, Array>> event_signals;
 	};
 
-	RBSet<ObjectID> pending_reload_instances;
+	HashSet<ObjectID> pending_reload_instances;
 	RBMap<ObjectID, StateBackup> pending_reload_state;
 	StringName tied_class_name_for_reload;
 	StringName tied_class_namespace_for_reload;
@@ -141,7 +141,7 @@ private:
 #ifdef TOOLS_ENABLED
 	List<PropertyInfo> exported_members_cache; // members_cache
 	HashMap<StringName, Variant> exported_members_defval_cache; // member_default_values_cache
-	RBSet<PlaceHolderScriptInstance *> placeholders;
+	HashSet<PlaceHolderScriptInstance *> placeholders;
 	bool source_changed_cache = false;
 	bool placeholder_fallback_enabled = false;
 	bool exports_invalidated = true;
@@ -151,7 +151,7 @@ private:
 #endif
 
 #if defined(TOOLS_ENABLED) || defined(DEBUG_ENABLED)
-	RBSet<StringName> exported_members_names;
+	HashSet<StringName> exported_members_names;
 #endif
 
 	HashMap<StringName, PropertyInfo> member_info;
@@ -218,7 +218,7 @@ public:
 	void get_script_property_list(List<PropertyInfo> *r_list) const override;
 	void update_exports() override;
 
-	void get_members(RBSet<StringName> *p_members) override;
+	void get_members(HashSet<StringName> *p_members) override;
 
 	bool is_tool() const override { return tool; }
 	bool is_valid() const override { return valid; }
@@ -467,7 +467,7 @@ public:
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
 	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
 	/* TODO */ bool validate(const String &p_script, const String &p_path, List<String> *r_functions,
-			List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const override {
+			List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override {
 		return true;
 	}
 	String validate_path(const String &p_path) const override;
diff --git a/modules/raycast/lightmap_raycaster.cpp b/modules/raycast/lightmap_raycaster.cpp
index fc9ac416b7..9b35b5616e 100644
--- a/modules/raycast/lightmap_raycaster.cpp
+++ b/modules/raycast/lightmap_raycaster.cpp
@@ -152,7 +152,7 @@ void LightmapRaycasterEmbree::commit() {
 	rtcCommitScene(embree_scene);
 }
 
-void LightmapRaycasterEmbree::set_mesh_filter(const RBSet<int> &p_mesh_ids) {
+void LightmapRaycasterEmbree::set_mesh_filter(const HashSet<int> &p_mesh_ids) {
 	for (const int &E : p_mesh_ids) {
 		rtcDisableGeometry(rtcGetGeometry(embree_scene, E));
 	}
diff --git a/modules/raycast/lightmap_raycaster.h b/modules/raycast/lightmap_raycaster.h
index 4c52758fd8..4266b46ea8 100644
--- a/modules/raycast/lightmap_raycaster.h
+++ b/modules/raycast/lightmap_raycaster.h
@@ -53,7 +53,7 @@ private:
 	static void filter_function(const struct RTCFilterFunctionNArguments *p_args);
 
 	HashMap<unsigned int, AlphaTextureData> alpha_textures;
-	RBSet<int> filter_meshes;
+	HashSet<int> filter_meshes;
 
 public:
 	virtual bool intersect(Ray &p_ray) override;
@@ -64,7 +64,7 @@ public:
 	virtual void set_mesh_alpha_texture(Ref<Image> p_alpha_texture, unsigned int p_id) override;
 	virtual void commit() override;
 
-	virtual void set_mesh_filter(const RBSet<int> &p_mesh_ids) override;
+	virtual void set_mesh_filter(const HashSet<int> &p_mesh_ids) override;
 	virtual void clear_mesh_filter() override;
 
 	static LightmapRaycaster *create_embree_raycaster();
diff --git a/modules/raycast/raycast_occlusion_cull.h b/modules/raycast/raycast_occlusion_cull.h
index 779f6fb3c4..4474031991 100644
--- a/modules/raycast/raycast_occlusion_cull.h
+++ b/modules/raycast/raycast_occlusion_cull.h
@@ -86,11 +86,13 @@ private:
 		RID scenario;
 		RID instance;
 
-		bool operator<(const InstanceID &rhs) const {
-			if (instance == rhs.instance) {
-				return rhs.scenario < scenario;
-			}
-			return instance < rhs.instance;
+		static uint32_t hash(const InstanceID &p_ins) {
+			uint32_t h = hash_djb2_one_64(p_ins.scenario.get_id());
+			return hash_djb2_one_64(p_ins.instance.get_id(), h);
+		}
+		bool operator==(const InstanceID &rhs) const {
+			return instance == rhs.instance && rhs.scenario == scenario;
+			;
 		}
 
 		InstanceID() {}
@@ -101,7 +103,7 @@ private:
 	struct Occluder {
 		PackedVector3Array vertices;
 		PackedInt32Array indices;
-		RBSet<InstanceID> users;
+		HashSet<InstanceID, InstanceID> users;
 	};
 
 	struct OccluderInstance {
@@ -136,7 +138,7 @@ private:
 		int current_scene_idx = 0;
 
 		HashMap<RID, OccluderInstance> instances;
-		RBSet<RID> dirty_instances; // To avoid duplicates
+		HashSet<RID> dirty_instances; // To avoid duplicates
 		LocalVector<RID> dirty_instances_array; // To iterate and split into threads
 		LocalVector<RID> removed_instances;
 
diff --git a/modules/raycast/static_raycaster.cpp b/modules/raycast/static_raycaster.cpp
index 5d2dedf1a4..7659eea27f 100644
--- a/modules/raycast/static_raycaster.cpp
+++ b/modules/raycast/static_raycaster.cpp
@@ -94,7 +94,7 @@ void StaticRaycasterEmbree::commit() {
 	rtcCommitScene(embree_scene);
 }
 
-void StaticRaycasterEmbree::set_mesh_filter(const RBSet<int> &p_mesh_ids) {
+void StaticRaycasterEmbree::set_mesh_filter(const HashSet<int> &p_mesh_ids) {
 	for (const int &E : p_mesh_ids) {
 		rtcDisableGeometry(rtcGetGeometry(embree_scene, E));
 	}
diff --git a/modules/raycast/static_raycaster.h b/modules/raycast/static_raycaster.h
index b52b5bccfc..e2909f9b56 100644
--- a/modules/raycast/static_raycaster.h
+++ b/modules/raycast/static_raycaster.h
@@ -41,7 +41,7 @@ private:
 	static RTCDevice embree_device;
 	RTCScene embree_scene;
 
-	RBSet<int> filter_meshes;
+	HashSet<int> filter_meshes;
 
 public:
 	virtual bool intersect(Ray &p_ray) override;
@@ -50,7 +50,7 @@ public:
 	virtual void add_mesh(const PackedVector3Array &p_vertices, const PackedInt32Array &p_indices, unsigned int p_id) override;
 	virtual void commit() override;
 
-	virtual void set_mesh_filter(const RBSet<int> &p_mesh_ids) override;
+	virtual void set_mesh_filter(const HashSet<int> &p_mesh_ids) override;
 	virtual void clear_mesh_filter() override;
 
 	static StaticRaycaster *create_embree_raycaster();
diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp
index ef7807ca5d..0f45855a76 100644
--- a/modules/text_server_adv/text_server_adv.cpp
+++ b/modules/text_server_adv/text_server_adv.cpp
@@ -5589,7 +5589,7 @@ PackedInt32Array TextServerAdvanced::string_get_word_breaks(const String &p_stri
 	// Convert to UTF-16.
 	Char16String utf16 = p_string.utf16();
 
-	RBSet<int> breaks;
+	HashSet<int> breaks;
 	UErrorCode err = U_ZERO_ERROR;
 	UBreakIterator *bi = ubrk_open(UBRK_LINE, p_language.ascii().get_data(), (const UChar *)utf16.ptr(), utf16.length(), &err);
 	if (U_FAILURE(err)) {
diff --git a/modules/text_server_adv/text_server_adv.h b/modules/text_server_adv/text_server_adv.h
index 897c27b6fa..fe1d4bdcbf 100644
--- a/modules/text_server_adv/text_server_adv.h
+++ b/modules/text_server_adv/text_server_adv.h
@@ -126,7 +126,7 @@ class TextServerAdvanced : public TextServerExtension {
 	_THREAD_SAFE_CLASS_
 
 	struct NumSystemData {
-		RBSet<StringName> lang;
+		HashSet<StringName> lang;
 		String digits;
 		String percent_sign;
 		String exp;
@@ -235,7 +235,7 @@ class TextServerAdvanced : public TextServerExtension {
 		HashMap<Vector2i, FontDataForSizeAdvanced *, VariantHasher, VariantComparator> cache;
 
 		bool face_init = false;
-		RBSet<uint32_t> supported_scripts;
+		HashSet<uint32_t> supported_scripts;
 		Dictionary supported_features;
 		Dictionary supported_varaitions;
 		Dictionary feature_overrides;
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 7c15651fa2..24bb22960e 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -2223,7 +2223,7 @@ Ref<Script> VisualScriptLanguage::make_template(const String &p_template, const
 	return script;
 }
 
-bool VisualScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, RBSet<int> *r_safe_lines) const {
+bool VisualScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
 	return false;
 }
 
diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h
index c28ec2268b..0f3b8de3fc 100644
--- a/modules/visual_script/visual_script.h
+++ b/modules/visual_script/visual_script.h
@@ -36,6 +36,7 @@
 #include "core/doc_data.h"
 #include "core/object/script_language.h"
 #include "core/os/thread.h"
+#include "core/templates/rb_set.h"
 
 class VisualScriptInstance;
 class VisualScriptNodeInstance;
@@ -570,7 +571,7 @@ public:
 	virtual void get_string_delimiters(List<String> *p_delimiters) const override;
 	virtual bool is_using_templates() override;
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const override;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
 	virtual Script *create_script() const override;
 	virtual bool has_named_classes() const override;
 	virtual bool supports_builtin_mode() const override;
diff --git a/platform/android/export/export_plugin.cpp b/platform/android/export/export_plugin.cpp
index 18f037ed56..948e3f9078 100644
--- a/platform/android/export/export_plugin.cpp
+++ b/platform/android/export/export_plugin.cpp
@@ -3067,7 +3067,7 @@ void EditorExportPlatformAndroid::get_platform_features(List<String> *r_features
 	r_features->push_back("android");
 }
 
-void EditorExportPlatformAndroid::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) {
+void EditorExportPlatformAndroid::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) {
 }
 
 EditorExportPlatformAndroid::EditorExportPlatformAndroid() {
diff --git a/platform/android/export/export_plugin.h b/platform/android/export/export_plugin.h
index c857850007..e828710b97 100644
--- a/platform/android/export/export_plugin.h
+++ b/platform/android/export/export_plugin.h
@@ -228,7 +228,7 @@ public:
 
 	virtual void get_platform_features(List<String> *r_features) override;
 
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override;
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override;
 
 	EditorExportPlatformAndroid();
 
diff --git a/platform/iphone/export/export_plugin.cpp b/platform/iphone/export/export_plugin.cpp
index f28d014c07..1f5e378098 100644
--- a/platform/iphone/export/export_plugin.cpp
+++ b/platform/iphone/export/export_plugin.cpp
@@ -102,7 +102,7 @@ void EditorExportPlatformIOS::get_export_options(List<ExportOption> *r_options)
 		r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, vformat("%s/%s", PNAME("plugins"), found_plugins[i].name)), false));
 	}
 
-	RBSet<String> plist_keys;
+	HashSet<String> plist_keys;
 
 	for (int i = 0; i < found_plugins.size(); i++) {
 		// Editable plugin plist values
@@ -1178,7 +1178,7 @@ Error EditorExportPlatformIOS::_export_ios_plugins(const Ref<EditorExportPreset>
 	Vector<String> added_embedded_dependenciy_names;
 	HashMap<String, String> plist_values;
 
-	RBSet<String> plugin_linker_flags;
+	HashSet<String> plugin_linker_flags;
 
 	Error err;
 
@@ -1453,7 +1453,7 @@ Error EditorExportPlatformIOS::export_project(const Ref<EditorExportPreset> &p_p
 	bool found_library = false;
 
 	const String project_file = "godot_ios.xcodeproj/project.pbxproj";
-	RBSet<String> files_to_parse;
+	HashSet<String> files_to_parse;
 	files_to_parse.insert("godot_ios/godot_ios-Info.plist");
 	files_to_parse.insert(project_file);
 	files_to_parse.insert("godot_ios/export_options.plist");
diff --git a/platform/iphone/export/export_plugin.h b/platform/iphone/export/export_plugin.h
index 10a17c4bf1..1db7418e3f 100644
--- a/platform/iphone/export/export_plugin.h
+++ b/platform/iphone/export/export_plugin.h
@@ -204,7 +204,7 @@ public:
 		r_features->push_back("ios");
 	}
 
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override {
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override {
 	}
 
 	EditorExportPlatformIOS();
diff --git a/platform/javascript/export/export_plugin.h b/platform/javascript/export/export_plugin.h
index d38d6e7073..2d6cbfde38 100644
--- a/platform/javascript/export/export_plugin.h
+++ b/platform/javascript/export/export_plugin.h
@@ -138,7 +138,7 @@ public:
 		r_features->push_back(get_os_name().to_lower());
 	}
 
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override {
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override {
 	}
 
 	String get_debug_protocol() const override { return "ws://"; }
diff --git a/platform/linuxbsd/display_server_x11.cpp b/platform/linuxbsd/display_server_x11.cpp
index 5829711698..887d916f35 100644
--- a/platform/linuxbsd/display_server_x11.cpp
+++ b/platform/linuxbsd/display_server_x11.cpp
@@ -1255,7 +1255,7 @@ void DisplayServerX11::delete_sub_window(WindowID p_id) {
 	DEBUG_LOG_X11("delete_sub_window: %lu (%u) \n", wd.x11_window, p_id);
 
 	while (wd.transient_children.size()) {
-		window_set_transient(wd.transient_children.front()->get(), INVALID_WINDOW_ID);
+		window_set_transient(*wd.transient_children.begin(), INVALID_WINDOW_ID);
 	}
 
 	if (wd.transient_parent != INVALID_WINDOW_ID) {
diff --git a/platform/linuxbsd/display_server_x11.h b/platform/linuxbsd/display_server_x11.h
index 66941fbe29..872af3dc09 100644
--- a/platform/linuxbsd/display_server_x11.h
+++ b/platform/linuxbsd/display_server_x11.h
@@ -137,7 +137,7 @@ class DisplayServerX11 : public DisplayServer {
 		Callable drop_files_callback;
 
 		WindowID transient_parent = INVALID_WINDOW_ID;
-		RBSet<WindowID> transient_children;
+		HashSet<WindowID> transient_children;
 
 		ObjectID instance_id;
 
diff --git a/platform/osx/display_server_osx.h b/platform/osx/display_server_osx.h
index 76df8b400a..52b4fab2ea 100644
--- a/platform/osx/display_server_osx.h
+++ b/platform/osx/display_server_osx.h
@@ -97,7 +97,7 @@ public:
 
 		WindowID transient_parent = INVALID_WINDOW_ID;
 		bool exclusive = false;
-		RBSet<WindowID> transient_children;
+		HashSet<WindowID> transient_children;
 
 		bool layered_window = false;
 		bool fullscreen = false;
diff --git a/platform/osx/export/export_plugin.h b/platform/osx/export/export_plugin.h
index c90c5c29b2..ec97d4139f 100644
--- a/platform/osx/export/export_plugin.h
+++ b/platform/osx/export/export_plugin.h
@@ -127,7 +127,7 @@ public:
 		r_features->push_back("macos");
 	}
 
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override {
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override {
 	}
 
 	EditorExportPlatformOSX();
diff --git a/platform/osx/godot_window_delegate.mm b/platform/osx/godot_window_delegate.mm
index 9f49a6a4e9..521127f01b 100644
--- a/platform/osx/godot_window_delegate.mm
+++ b/platform/osx/godot_window_delegate.mm
@@ -58,7 +58,7 @@
 
 	DisplayServerOSX::WindowData &wd = ds->get_window(window_id);
 	while (wd.transient_children.size()) {
-		ds->window_set_transient(wd.transient_children.front()->get(), DisplayServerOSX::INVALID_WINDOW_ID);
+		ds->window_set_transient(*wd.transient_children.begin(), DisplayServerOSX::INVALID_WINDOW_ID);
 	}
 
 	if (wd.transient_parent != DisplayServerOSX::INVALID_WINDOW_ID) {
diff --git a/platform/uwp/export/app_packager.h b/platform/uwp/export/app_packager.h
index 430f42d85f..dc5a5259ec 100644
--- a/platform/uwp/export/app_packager.h
+++ b/platform/uwp/export/app_packager.h
@@ -89,7 +89,7 @@ class AppxPackager {
 	String progress_task;
 	Ref<FileAccess> package;
 
-	RBSet<String> mime_types;
+	HashSet<String> mime_types;
 
 	Vector<FileMeta> file_metadata;
 
diff --git a/platform/uwp/export/export_plugin.cpp b/platform/uwp/export/export_plugin.cpp
index e2e84131a3..01683c656c 100644
--- a/platform/uwp/export/export_plugin.cpp
+++ b/platform/uwp/export/export_plugin.cpp
@@ -499,7 +499,7 @@ void EditorExportPlatformUWP::get_platform_features(List<String> *r_features) {
 	r_features->push_back("uwp");
 }
 
-void EditorExportPlatformUWP::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) {
+void EditorExportPlatformUWP::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) {
 }
 
 EditorExportPlatformUWP::EditorExportPlatformUWP() {
diff --git a/platform/uwp/export/export_plugin.h b/platform/uwp/export/export_plugin.h
index 4eff96a432..d92687075c 100644
--- a/platform/uwp/export/export_plugin.h
+++ b/platform/uwp/export/export_plugin.h
@@ -441,7 +441,7 @@ public:
 
 	virtual void get_platform_features(List<String> *r_features) override;
 
-	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, RBSet<String> &p_features) override;
+	virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<String> &p_features) override;
 
 	EditorExportPlatformUWP();
 };
diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp
index e771057d2e..9763fb1066 100644
--- a/platform/windows/display_server_windows.cpp
+++ b/platform/windows/display_server_windows.cpp
@@ -628,7 +628,7 @@ void DisplayServerWindows::delete_sub_window(WindowID p_window) {
 	WindowData &wd = windows[p_window];
 
 	while (wd.transient_children.size()) {
-		window_set_transient(wd.transient_children.front()->get(), INVALID_WINDOW_ID);
+		window_set_transient(*wd.transient_children.begin(), INVALID_WINDOW_ID);
 	}
 
 	if (wd.transient_parent != INVALID_WINDOW_ID) {
diff --git a/platform/windows/display_server_windows.h b/platform/windows/display_server_windows.h
index 90f7b27b0c..fc89517774 100644
--- a/platform/windows/display_server_windows.h
+++ b/platform/windows/display_server_windows.h
@@ -389,7 +389,7 @@ class DisplayServerWindows : public DisplayServer {
 		Callable drop_files_callback;
 
 		WindowID transient_parent = INVALID_WINDOW_ID;
-		RBSet<WindowID> transient_children;
+		HashSet<WindowID> transient_children;
 
 		bool is_popup = false;
 		Rect2i parent_safe_rect;
diff --git a/scene/2d/audio_stream_player_2d.cpp b/scene/2d/audio_stream_player_2d.cpp
index d2a08af76c..e7f1740f0b 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();
 
-	RBSet<Viewport *> viewports = world_2d->get_viewports();
+	HashSet<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/ray_cast_2d.h b/scene/2d/ray_cast_2d.h
index b809bc4b8e..1fb97d89fe 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;
-	RBSet<RID> exclude;
+	HashSet<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 78125b08bd..7ff080aed0 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);
 
-	RBSet<RID> exclude;
+	HashSet<RID> exclude;
 	real_t margin = 0.0;
 	uint32_t collision_mask = 1;
 	bool exclude_parent_body = true;
diff --git a/scene/2d/visible_on_screen_notifier_2d.h b/scene/2d/visible_on_screen_notifier_2d.h
index 3165eb92df..38b508e2f6 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);
 
-	RBSet<Viewport *> viewports;
+	HashSet<Viewport *> viewports;
 
 	Rect2 rect;
 
diff --git a/scene/3d/audio_stream_player_3d.cpp b/scene/3d/audio_stream_player_3d.cpp
index c63803c015..735ce0bb07 100644
--- a/scene/3d/audio_stream_player_3d.cpp
+++ b/scene/3d/audio_stream_player_3d.cpp
@@ -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);
 
-	RBSet<Camera3D *> cameras = world_3d->get_cameras();
+	HashSet<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());
diff --git a/scene/3d/collision_object_3d.h b/scene/3d/collision_object_3d.h
index 84b00de9c9..098f573551 100644
--- a/scene/3d/collision_object_3d.h
+++ b/scene/3d/collision_object_3d.h
@@ -78,7 +78,7 @@ private:
 	bool capture_input_on_drag = false;
 	bool ray_pickable = true;
 
-	RBSet<uint32_t> debug_shapes_to_update;
+	HashSet<uint32_t> debug_shapes_to_update;
 	int debug_shapes_count = 0;
 	Transform3D debug_shape_old_transform;
 
diff --git a/scene/3d/lightmapper.h b/scene/3d/lightmapper.h
index 55d9a52a28..4e6f76e360 100644
--- a/scene/3d/lightmapper.h
+++ b/scene/3d/lightmapper.h
@@ -118,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 RBSet<int> &p_mesh_ids) = 0;
+	virtual void set_mesh_filter(const HashSet<int> &p_mesh_ids) = 0;
 	virtual void clear_mesh_filter() = 0;
 
 	static Ref<LightmapRaycaster> create();
diff --git a/scene/3d/ray_cast_3d.h b/scene/3d/ray_cast_3d.h
index d6062969d8..c69c910efb 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);
-	RBSet<RID> exclude;
+	HashSet<RID> exclude;
 
 	uint32_t collision_mask = 1;
 	bool exclude_parent_body = true;
diff --git a/scene/3d/skeleton_3d.h b/scene/3d/skeleton_3d.h
index c72792bd47..cb4c82d232 100644
--- a/scene/3d/skeleton_3d.h
+++ b/scene/3d/skeleton_3d.h
@@ -131,7 +131,7 @@ private:
 		}
 	};
 
-	RBSet<SkinReference *> skin_bindings;
+	HashSet<SkinReference *> skin_bindings;
 
 	void _skin_changed();
 
diff --git a/scene/3d/spring_arm_3d.h b/scene/3d/spring_arm_3d.h
index 78d9db7259..0b5307acf7 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;
-	RBSet<RID> excluded_objects;
+	HashSet<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 4ef70f7764..0ef8bd7482 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;
 
-	RBSet<RID> exclude;
+	HashSet<RID> exclude;
 
 	Vector<Vector3> m_forwardWS;
 	Vector<Vector3> m_axle;
diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h
index 3ef87dba28..c679405dfe 100644
--- a/scene/animation/animation_player.h
+++ b/scene/animation/animation_player.h
@@ -184,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;
-	RBSet<TrackNodeCache *> playing_caches;
+	HashSet<TrackNodeCache *> playing_caches;
 
 	uint64_t accum_pass = 1;
 	float speed_scale = 1.0;
diff --git a/scene/animation/animation_tree.h b/scene/animation/animation_tree.h
index 37cd22568a..b646efede4 100644
--- a/scene/animation/animation_tree.h
+++ b/scene/animation/animation_tree.h
@@ -267,7 +267,7 @@ private:
 	};
 
 	HashMap<NodePath, TrackCache *> track_cache;
-	RBSet<TrackCache *> playing_caches;
+	HashSet<TrackCache *> playing_caches;
 
 	Ref<AnimationNode> root;
 
diff --git a/scene/debugger/scene_debugger.cpp b/scene/debugger/scene_debugger.cpp
index dfad91ecd5..a54e728c1b 100644
--- a/scene/debugger/scene_debugger.cpp
+++ b/scene/debugger/scene_debugger.cpp
@@ -345,8 +345,8 @@ void SceneDebugger::remove_from_cache(const String &p_filename, Node *p_node) {
 		return;
 	}
 
-	HashMap<String, RBSet<Node *>> &edit_cache = debugger->live_scene_edit_cache;
-	HashMap<String, RBSet<Node *>>::Iterator E = edit_cache.find(p_filename);
+	HashMap<String, HashSet<Node *>> &edit_cache = debugger->live_scene_edit_cache;
+	HashMap<String, HashSet<Node *>>::Iterator E = edit_cache.find(p_filename);
 	if (E) {
 		E->value.erase(p_node);
 		if (E->value.size() == 0) {
@@ -408,12 +408,12 @@ SceneDebuggerObject::SceneDebuggerObject(ObjectID p_id) {
 }
 
 void SceneDebuggerObject::_parse_script_properties(Script *p_script, ScriptInstance *p_instance) {
-	typedef HashMap<const Script *, RBSet<StringName>> ScriptMemberMap;
+	typedef HashMap<const Script *, HashSet<StringName>> ScriptMemberMap;
 	typedef HashMap<const Script *, HashMap<StringName, Variant>> ScriptConstantsMap;
 
 	ScriptMemberMap members;
 	if (p_instance) {
-		members[p_script] = RBSet<StringName>();
+		members[p_script] = HashSet<StringName>();
 		p_script->get_members(&(members[p_script]));
 	}
 
@@ -424,7 +424,7 @@ void SceneDebuggerObject::_parse_script_properties(Script *p_script, ScriptInsta
 	Ref<Script> base = p_script->get_base_script();
 	while (base.is_valid()) {
 		if (p_instance) {
-			members[base.ptr()] = RBSet<StringName>();
+			members[base.ptr()] = HashSet<StringName>();
 			base->get_members(&(members[base.ptr()]));
 		}
 
@@ -435,7 +435,7 @@ void SceneDebuggerObject::_parse_script_properties(Script *p_script, ScriptInsta
 	}
 
 	// Members
-	for (KeyValue<const Script *, RBSet<StringName>> sm : members) {
+	for (KeyValue<const Script *, HashSet<StringName>> sm : members) {
 		for (const StringName &E : sm.value) {
 			Variant m;
 			if (p_instance->get(E, m)) {
@@ -624,7 +624,7 @@ void LiveEditor::_node_set_func(int p_id, const StringName &p_prop, const Varian
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
@@ -668,7 +668,7 @@ void LiveEditor::_node_call_func(int p_id, const StringName &p_method, const Var
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
@@ -753,7 +753,7 @@ void LiveEditor::_create_node_func(const NodePath &p_parent, const String &p_typ
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
@@ -797,7 +797,7 @@ void LiveEditor::_instance_node_func(const NodePath &p_parent, const String &p_p
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
@@ -835,15 +835,15 @@ void LiveEditor::_remove_node_func(const NodePath &p_at) {
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
-		RBSet<Node *>::Element *N = F->next();
+	Vector<Node *> to_delete;
 
-		Node *n = F->get();
+	for (HashSet<Node *>::Iterator F = E->value.begin(); F; ++F) {
+		Node *n = *F;
 
 		if (base && !base->is_ancestor_of(n)) {
 			continue;
@@ -854,9 +854,11 @@ void LiveEditor::_remove_node_func(const NodePath &p_at) {
 		}
 		Node *n2 = n->get_node(p_at);
 
-		memdelete(n2);
+		to_delete.push_back(n2);
+	}
 
-		F = N;
+	for (int i = 0; i < to_delete.size(); i++) {
+		memdelete(to_delete[i]);
 	}
 }
 
@@ -871,15 +873,14 @@ void LiveEditor::_remove_and_keep_node_func(const NodePath &p_at, ObjectID p_kee
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
-		RBSet<Node *>::Element *N = F->next();
-
-		Node *n = F->get();
+	Vector<Node *> to_remove;
+	for (HashSet<Node *>::Iterator F = E->value.begin(); F; ++F) {
+		Node *n = *F;
 
 		if (base && !base->is_ancestor_of(n)) {
 			continue;
@@ -889,13 +890,14 @@ void LiveEditor::_remove_and_keep_node_func(const NodePath &p_at, ObjectID p_kee
 			continue;
 		}
 
-		Node *n2 = n->get_node(p_at);
+		to_remove.push_back(n);
+	}
 
+	for (int i = 0; i < to_remove.size(); i++) {
+		Node *n = to_remove[i];
+		Node *n2 = n->get_node(p_at);
 		n2->get_parent()->remove_child(n2);
-
 		live_edit_remove_list[n][p_keep_id] = n2;
-
-		F = N;
 	}
 }
 
@@ -910,15 +912,16 @@ void LiveEditor::_restore_node_func(ObjectID p_id, const NodePath &p_at, int p_a
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
 
-	for (RBSet<Node *>::Element *F = E->value.front(); F;) {
-		RBSet<Node *>::Element *N = F->next();
+	for (HashSet<Node *>::Iterator F = E->value.begin(); F;) {
+		HashSet<Node *>::Iterator N = F;
+		++N;
 
-		Node *n = F->get();
+		Node *n = *F;
 
 		if (base && !base->is_ancestor_of(n)) {
 			continue;
@@ -963,7 +966,7 @@ void LiveEditor::_duplicate_node_func(const NodePath &p_at, const String &p_new_
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
@@ -1002,7 +1005,7 @@ void LiveEditor::_reparent_node_func(const NodePath &p_at, const NodePath &p_new
 		base = scene_tree->root->get_node(live_edit_root);
 	}
 
-	HashMap<String, RBSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
+	HashMap<String, HashSet<Node *>>::Iterator E = live_scene_edit_cache.find(live_edit_scene);
 	if (!E) {
 		return; //scene not editable
 	}
diff --git a/scene/debugger/scene_debugger.h b/scene/debugger/scene_debugger.h
index 0daefa9609..4ed126d36e 100644
--- a/scene/debugger/scene_debugger.h
+++ b/scene/debugger/scene_debugger.h
@@ -138,7 +138,7 @@ private:
 	NodePath live_edit_root;
 	String live_edit_scene;
 
-	HashMap<String, RBSet<Node *>> live_scene_edit_cache;
+	HashMap<String, HashSet<Node *>> live_scene_edit_cache;
 	HashMap<Node *, HashMap<ObjectID, Node *>> live_edit_remove_list;
 
 	void _send_tree();
diff --git a/scene/gui/base_button.h b/scene/gui/base_button.h
index 0b70d285ee..ba3852ec98 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;
-	RBSet<BaseButton *> buttons;
+	HashSet<BaseButton *> buttons;
 
 protected:
 	static void _bind_methods();
diff --git a/scene/gui/code_edit.h b/scene/gui/code_edit.h
index 0b00735f46..ccf046c612 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;
-	RBSet<char32_t> auto_indent_prefixes;
+	HashSet<char32_t> auto_indent_prefixes;
 
 	bool indent_using_spaces = false;
 	int _calculate_spaces_till_next_left_indent(int p_column) const;
@@ -214,7 +214,7 @@ private:
 	int code_completion_longest_line = 0;
 	Rect2i code_completion_rect;
 
-	RBSet<char32_t> code_completion_prefixes;
+	HashSet<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/graph_edit.cpp b/scene/gui/graph_edit.cpp
index ccf7e2828a..fdff6a88a9 100644
--- a/scene/gui/graph_edit.cpp
+++ b/scene/gui/graph_edit.cpp
@@ -1696,7 +1696,7 @@ void GraphEdit::set_warped_panning(bool p_warped) {
 	warped_panning = p_warped;
 }
 
-int GraphEdit::_set_operations(SET_OPERATIONS p_operation, RBSet<StringName> &r_u, const RBSet<StringName> &r_v) {
+int GraphEdit::_set_operations(SET_OPERATIONS p_operation, HashSet<StringName> &r_u, const HashSet<StringName> &r_v) {
 	switch (p_operation) {
 		case GraphEdit::IS_EQUAL: {
 			for (const StringName &E : r_u) {
@@ -1718,10 +1718,13 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, RBSet<StringName> &r_
 			return 1;
 		} break;
 		case GraphEdit::DIFFERENCE: {
-			for (RBSet<StringName>::Element *E = r_u.front(); E; E = E->next()) {
-				if (r_v.has(E->get())) {
-					r_u.erase(E->get());
+			for (HashSet<StringName>::Iterator E = r_u.begin(); E;) {
+				HashSet<StringName>::Iterator N = E;
+				++N;
+				if (r_v.has(*E)) {
+					r_u.remove(E);
 				}
+				E = N;
 			}
 			return r_u.size();
 		} break;
@@ -1739,17 +1742,17 @@ int GraphEdit::_set_operations(SET_OPERATIONS p_operation, RBSet<StringName> &r_
 	return -1;
 }
 
-HashMap<int, Vector<StringName>> GraphEdit::_layering(const RBSet<StringName> &r_selected_nodes, const HashMap<StringName, RBSet<StringName>> &r_upper_neighbours) {
+HashMap<int, Vector<StringName>> GraphEdit::_layering(const HashSet<StringName> &r_selected_nodes, const HashMap<StringName, HashSet<StringName>> &r_upper_neighbours) {
 	HashMap<int, Vector<StringName>> l;
 
-	RBSet<StringName> p = r_selected_nodes, q = r_selected_nodes, u, z;
+	HashSet<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 StringName &E : p) {
-			RBSet<StringName> n = r_upper_neighbours[E];
+			HashSet<StringName> n = r_upper_neighbours[E];
 			if (_set_operations(GraphEdit::IS_SUBSET, n, z)) {
 				Vector<StringName> t;
 				t.push_back(E);
@@ -1759,7 +1762,7 @@ HashMap<int, Vector<StringName>> GraphEdit::_layering(const RBSet<StringName> &r
 				selected = true;
 				t.append_array(l[current_layer]);
 				l.insert(current_layer, t);
-				RBSet<StringName> V;
+				HashSet<StringName> V;
 				V.insert(E);
 				_set_operations(GraphEdit::UNION, u, V);
 			}
@@ -1801,7 +1804,7 @@ 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, RBSet<StringName>> &r_upper_neighbours, const RBSet<StringName> &r_selected_nodes) {
+void GraphEdit::_horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, HashSet<StringName>> &r_upper_neighbours, const HashSet<StringName> &r_selected_nodes) {
 	for (const StringName &E : r_selected_nodes) {
 		r_root[E] = E;
 		r_align[E] = E;
@@ -1841,7 +1844,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, RBSet<StringName>> &r_upper_neighbours) {
+void GraphEdit::_crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, HashSet<StringName>> &r_upper_neighbours) {
 	if (r_layers.size() == 1) {
 		return;
 	}
@@ -1879,7 +1882,7 @@ 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 RBSet<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info) {
+void GraphEdit::_calculate_inner_shifts(Dictionary &r_inner_shifts, const Dictionary &r_root, const Dictionary &r_node_names, const Dictionary &r_align, const HashSet<StringName> &r_block_heads, const HashMap<StringName, Pair<int, int>> &r_port_info) {
 	for (const StringName &E : r_block_heads) {
 		real_t left = 0;
 		StringName u = E;
@@ -2052,7 +2055,7 @@ void GraphEdit::arrange_nodes() {
 	}
 
 	Dictionary node_names;
-	RBSet<StringName> selected_nodes;
+	HashSet<StringName> selected_nodes;
 
 	for (int i = get_child_count() - 1; i >= 0; i--) {
 		GraphNode *gn = Object::cast_to<GraphNode>(get_child(i));
@@ -2063,7 +2066,7 @@ void GraphEdit::arrange_nodes() {
 		node_names[gn->get_name()] = gn;
 	}
 
-	HashMap<StringName, RBSet<StringName>> upper_neighbours;
+	HashMap<StringName, HashSet<StringName>> upper_neighbours;
 	HashMap<StringName, Pair<int, int>> port_info;
 	Vector2 origin(FLT_MAX, FLT_MAX);
 
@@ -2078,7 +2081,7 @@ void GraphEdit::arrange_nodes() {
 
 		if (gn->is_selected()) {
 			selected_nodes.insert(gn->get_name());
-			RBSet<StringName> s;
+			HashSet<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()) {
@@ -2115,7 +2118,7 @@ void GraphEdit::arrange_nodes() {
 	HashMap<StringName, Vector2> new_positions;
 	Vector2 default_position(FLT_MAX, FLT_MAX);
 	Dictionary inner_shift;
-	RBSet<StringName> block_heads;
+	HashSet<StringName> block_heads;
 
 	for (const StringName &E : selected_nodes) {
 		inner_shift[E] = 0.0f;
diff --git a/scene/gui/graph_edit.h b/scene/gui/graph_edit.h
index 9e34d5528f..5484a2317c 100644
--- a/scene/gui/graph_edit.h
+++ b/scene/gui/graph_edit.h
@@ -218,8 +218,11 @@ private:
 			uint64_t key = 0;
 		};
 
-		bool operator<(const ConnType &p_type) const {
-			return key < p_type.key;
+		static uint32_t hash(const ConnType &p_conn) {
+			return hash_one_uint64(p_conn.key);
+		}
+		bool operator==(const ConnType &p_type) const {
+			return key == p_type.key;
 		}
 
 		ConnType(uint32_t a = 0, uint32_t b = 0) {
@@ -228,9 +231,9 @@ private:
 		}
 	};
 
-	RBSet<ConnType> valid_connection_types;
-	RBSet<int> valid_left_disconnect_types;
-	RBSet<int> valid_right_disconnect_types;
+	HashSet<ConnType, ConnType> valid_connection_types;
+	HashSet<int> valid_left_disconnect_types;
+	HashSet<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 +261,12 @@ private:
 		UNION,
 	};
 
-	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);
+	int _set_operations(SET_OPERATIONS p_operation, HashSet<StringName> &r_u, const HashSet<StringName> &r_v);
+	HashMap<int, Vector<StringName>> _layering(const HashSet<StringName> &r_selected_nodes, const HashMap<StringName, HashSet<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, 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);
+	void _horizontal_alignment(Dictionary &r_root, Dictionary &r_align, const HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, HashSet<StringName>> &r_upper_neighbours, const HashSet<StringName> &r_selected_nodes);
+	void _crossing_minimisation(HashMap<int, Vector<StringName>> &r_layers, const HashMap<StringName, HashSet<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 HashSet<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/grid_container.cpp b/scene/gui/grid_container.cpp
index 5d9484806b..6f8518a7b0 100644
--- a/scene/gui/grid_container.cpp
+++ b/scene/gui/grid_container.cpp
@@ -29,12 +29,13 @@
 /*************************************************************************/
 
 #include "grid_container.h"
+#include "core/templates/rb_set.h"
 
 void GridContainer::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_SORT_CHILDREN: {
-			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).
+			RBMap<int, int> col_minw; // Max of min_width of all controls in each col (indexed by col).
+			RBMap<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.
 
@@ -261,8 +262,8 @@ void GridContainer::_bind_methods() {
 }
 
 Size2 GridContainer::get_minimum_size() const {
-	HashMap<int, int> col_minw;
-	HashMap<int, int> row_minh;
+	RBMap<int, int> col_minw;
+	RBMap<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/range.h b/scene/gui/range.h
index a59bfa9677..1274821bd1 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;
-		RBSet<Range *> owners;
+		HashSet<Range *> owners;
 		void emit_value_changed();
 		void emit_changed(const char *p_what = "");
 	};
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index bd791dff2a..27f240164c 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);
 	}
 
-	RBSet<const Node *> visited;
+	HashSet<const Node *> visited;
 
 	const Node *n = this;
 
@@ -1669,7 +1669,7 @@ NodePath Node::get_path_to(const Node *p_node) const {
 		return NodePath(".");
 	}
 
-	RBSet<const Node *> visited;
+	HashSet<const Node *> visited;
 
 	const Node *n = this;
 
@@ -2042,7 +2042,7 @@ StringName Node::get_property_store_alias(const StringName &p_property) const {
 }
 #endif
 
-void Node::get_storable_properties(RBSet<StringName> &r_storable_properties) const {
+void Node::get_storable_properties(HashSet<StringName> &r_storable_properties) const {
 	List<PropertyInfo> pi;
 	get_property_list(&pi);
 	for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) {
diff --git a/scene/main/node.h b/scene/main/node.h
index 8505d2618f..8de6c1ce69 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -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(RBSet<StringName> &r_storable_properties) const;
+	void get_storable_properties(HashSet<StringName> &r_storable_properties) const;
 
 	virtual String to_string() override;
 
@@ -522,6 +522,6 @@ public:
 
 VARIANT_ENUM_CAST(Node::DuplicateFlags);
 
-typedef RBSet<Node *, Node::Comparator> NodeSet;
+typedef HashSet<Node *, Node::Comparator> NodeSet;
 
 #endif
diff --git a/scene/main/resource_preloader.cpp b/scene/main/resource_preloader.cpp
index 71e62fe804..5512d0a84e 100644
--- a/scene/main/resource_preloader.cpp
+++ b/scene/main/resource_preloader.cpp
@@ -29,7 +29,7 @@
 /*************************************************************************/
 
 #include "resource_preloader.h"
-
+#include "core/templates/rb_set.h"
 void ResourcePreloader::_set_resources(const Array &p_data) {
 	resources.clear();
 
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index cb5e9cc1ee..67a17a69f2 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -130,7 +130,7 @@ private:
 
 	// Safety for when a node is deleted while a group is being called.
 	int call_lock = 0;
-	RBSet<Node *> call_skip; // Skip erased nodes.
+	HashSet<Node *> call_skip; // Skip erased nodes.
 
 	List<ObjectID> delete_queue;
 
diff --git a/scene/main/viewport.h b/scene/main/viewport.h
index 48e4b175b6..5bca5a2dda 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;
-	RBSet<CanvasLayer *> canvas_layers;
+	HashSet<CanvasLayer *> canvas_layers;
 
 	RID viewport;
 	RID current_canvas;
@@ -301,7 +301,7 @@ private:
 	bool use_occlusion_culling = false;
 
 	Ref<ViewportTexture> default_texture;
-	RBSet<ViewportTexture *> viewport_textures;
+	HashSet<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;
-	RBSet<AudioListener3D *> audio_listener_3d_set;
+	HashSet<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;
-	RBSet<Camera3D *> camera_3d_set;
+	HashSet<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.h b/scene/main/window.h
index 80dd9a854c..c060f1d79d 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;
-	RBSet<Window *> transient_children;
+	HashSet<Window *> transient_children;
 
 	friend class Control;
 	Ref<Theme> theme;
diff --git a/scene/multiplayer/multiplayer_spawner.h b/scene/multiplayer/multiplayer_spawner.h
index ac35df7ff3..8fbc9c4803 100644
--- a/scene/multiplayer/multiplayer_spawner.h
+++ b/scene/multiplayer/multiplayer_spawner.h
@@ -47,7 +47,7 @@ public:
 
 private:
 	TypedArray<PackedScene> spawnable_scenes;
-	RBSet<ResourceUID::ID> spawnable_ids;
+	HashSet<ResourceUID::ID> spawnable_ids;
 	NodePath spawn_path;
 
 	struct SpawnInfo {
diff --git a/scene/multiplayer/scene_replication_interface.cpp b/scene/multiplayer/scene_replication_interface.cpp
index 55266c53ad..19c69adb4a 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 RBSet<ObjectID> &known = rep_state->get_known_nodes(p_peer);
+	const HashSet<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 e5cc57ff31..937b30cb36 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 RBSet<ObjectID> SceneReplicationState::get_known_nodes(int p_peer) {
-	ERR_FAIL_COND_V(!peers_info.has(p_peer), RBSet<ObjectID>());
+const HashSet<ObjectID> SceneReplicationState::get_known_nodes(int p_peer) {
+	ERR_FAIL_COND_V(!peers_info.has(p_peer), HashSet<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 33f72363ac..60a6c5d70c 100644
--- a/scene/multiplayer/scene_replication_state.h
+++ b/scene/multiplayer/scene_replication_state.h
@@ -62,27 +62,27 @@ private:
 	};
 
 	struct PeerInfo {
-		RBSet<ObjectID> known_nodes;
+		HashSet<ObjectID> known_nodes;
 		HashMap<uint32_t, ObjectID> recv_nodes;
 		uint16_t last_sent_sync = 0;
 		uint16_t last_recv_sync = 0;
 	};
 
-	RBSet<int> known_peers;
+	HashSet<int> known_peers;
 	uint32_t last_net_id = 0;
 	HashMap<ObjectID, TrackedNode> tracked_nodes;
 	HashMap<int, PeerInfo> peers_info;
-	RBSet<ObjectID> spawned_nodes;
-	RBSet<ObjectID> path_only_nodes;
+	HashSet<ObjectID> spawned_nodes;
+	HashSet<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 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; }
+	const HashSet<int> get_peers() const { return known_peers; }
+	const HashSet<ObjectID> &get_spawned_nodes() const { return spawned_nodes; }
+	const HashSet<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 RBSet<ObjectID> get_known_nodes(int p_peer);
+	const HashSet<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/bit_map.cpp b/scene/resources/bit_map.cpp
index 634fb3ef2f..1ff72825ac 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;
-	RBSet<Point2i> case9s;
-	RBSet<Point2i> case6s;
+	HashSet<Point2i> case9s;
+	HashSet<Point2i> case6s;
 	Vector<Vector2> _points;
 	do {
 		int sv = 0;
diff --git a/scene/resources/concave_polygon_shape_3d.cpp b/scene/resources/concave_polygon_shape_3d.cpp
index 081271c2fc..b91f0e4f1c 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 {
-	RBSet<DrawEdge> edges;
+	HashSet<DrawEdge, DrawEdge> edges;
 
 	int index_count = faces.size();
 	ERR_FAIL_COND_V((index_count % 3) != 0, Vector<Vector3>());
diff --git a/scene/resources/concave_polygon_shape_3d.h b/scene/resources/concave_polygon_shape_3d.h
index 5337deb5fb..4711e38468 100644
--- a/scene/resources/concave_polygon_shape_3d.h
+++ b/scene/resources/concave_polygon_shape_3d.h
@@ -42,12 +42,12 @@ class ConcavePolygonShape3D : public Shape3D {
 	struct DrawEdge {
 		Vector3 a;
 		Vector3 b;
-		bool operator<(const DrawEdge &p_edge) const {
-			if (a == p_edge.a) {
-				return b < p_edge.b;
-			} else {
-				return a < p_edge.a;
-			}
+		static uint32_t hash(const DrawEdge &p_edge) {
+			uint32_t h = hash_djb2_one_32(HashMapHasherDefault::hash(p_edge.a));
+			return hash_djb2_one_32(HashMapHasherDefault::hash(p_edge.b), h);
+		}
+		bool operator==(const DrawEdge &p_edge) const {
+			return (a == p_edge.a && b == p_edge.b);
 		}
 
 		DrawEdge(const Vector3 &p_a = Vector3(), const Vector3 &p_b = Vector3()) {
diff --git a/scene/resources/packed_scene.cpp b/scene/resources/packed_scene.cpp
index c7b1981aed..f795e0ffd0 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();
 	}
-	RBSet<StringName> storable_properties;
+	HashSet<StringName> storable_properties;
 	p_node->get_storable_properties(storable_properties);
 	int i = 0;
 	do {
diff --git a/scene/resources/polygon_path_finder.cpp b/scene/resources/polygon_path_finder.cpp
index 6b0c22d720..29135e30c9 100644
--- a/scene/resources/polygon_path_finder.cpp
+++ b/scene/resources/polygon_path_finder.cpp
@@ -289,7 +289,7 @@ Vector<Vector2> PolygonPathFinder::find_path(const Vector2 &p_from, const Vector
 	}
 	//solve graph
 
-	RBSet<int> open_list;
+	HashSet<int> open_list;
 
 	points.write[aidx].distance = 0;
 	points.write[aidx].prev = aidx;
diff --git a/scene/resources/polygon_path_finder.h b/scene/resources/polygon_path_finder.h
index 71ad77eb6e..0e22b53dcb 100644
--- a/scene/resources/polygon_path_finder.h
+++ b/scene/resources/polygon_path_finder.h
@@ -38,21 +38,23 @@ class PolygonPathFinder : public Resource {
 
 	struct Point {
 		Vector2 pos;
-		RBSet<int> connections;
+		HashSet<int> connections;
 		float distance = 0.0;
 		float penalty = 0.0;
 		int prev = 0;
 	};
 
-	struct Edge {
-		int points[2] = {};
+	union Edge {
+		struct {
+			int32_t points[2];
+		};
+		uint64_t key = 0;
 
-		_FORCE_INLINE_ bool operator<(const Edge &p_edge) const {
-			if (points[0] == p_edge.points[0]) {
-				return points[1] < p_edge.points[1];
-			} else {
-				return points[0] < p_edge.points[0];
-			}
+		_FORCE_INLINE_ bool operator==(const Edge &p_edge) const {
+			return key == p_edge.key;
+		}
+		_FORCE_INLINE_ static uint32_t hash(const Edge &p_edge) {
+			return hash_one_uint64(p_edge.key);
 		}
 
 		Edge(int a = 0, int b = 0) {
@@ -68,7 +70,7 @@ class PolygonPathFinder : public Resource {
 	Rect2 bounds;
 
 	Vector<Point> points;
-	RBSet<Edge> edges;
+	HashSet<Edge, 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 193bd0ac05..72d66ee4f5 100644
--- a/scene/resources/resource_format_text.cpp
+++ b/scene/resources/resource_format_text.cpp
@@ -1737,7 +1737,7 @@ Error ResourceFormatSaverTextInstance::save(const String &p_path, const Ref<Reso
 
 #ifdef TOOLS_ENABLED
 	// Keep order from cached ids.
-	RBSet<String> cached_ids_found;
+	HashSet<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.
 	}
 
-	RBSet<String> used_unique_ids;
+	HashSet<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 adab503599..5c6a937bf2 100644
--- a/scene/resources/resource_format_text.h
+++ b/scene/resources/resource_format_text.h
@@ -165,7 +165,7 @@ class ResourceFormatSaverTextInstance {
 
 	RBMap<NonPersistentKey, Ref<Resource>> non_persistent_map;
 
-	RBSet<Ref<Resource>> resource_set;
+	HashSet<Ref<Resource>> resource_set;
 	List<Ref<Resource>> saved_resources;
 	HashMap<Ref<Resource>, String> external_resources;
 	HashMap<Ref<Resource>, String> internal_resources;
diff --git a/scene/resources/theme.cpp b/scene/resources/theme.cpp
index 2981f38766..6af5d127a8 100644
--- a/scene/resources/theme.cpp
+++ b/scene/resources/theme.cpp
@@ -1275,7 +1275,7 @@ void Theme::get_type_list(List<StringName> *p_list) const {
 	// This Set guarantees uniqueness.
 	// Because each map can have the same type defined, but for this method
 	// we only want one occurrence of each type.
-	RBSet<StringName> types;
+	HashSet<StringName> types;
 
 	// Icons.
 	for (const KeyValue<StringName, ThemeIconMap> &E : icon_map) {
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index cdfe75f478..1b1107d79e 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -34,7 +34,7 @@
 #include "core/io/marshalls.h"
 #include "core/math/geometry_2d.h"
 #include "core/templates/local_vector.h"
-
+#include "core/templates/rb_set.h"
 #include "scene/2d/navigation_region_2d.h"
 #include "scene/gui/control.h"
 #include "scene/resources/convex_polygon_shape_2d.h"
diff --git a/scene/resources/tile_set.h b/scene/resources/tile_set.h
index 633e1f4bed..615ab35615 100644
--- a/scene/resources/tile_set.h
+++ b/scene/resources/tile_set.h
@@ -34,6 +34,7 @@
 #include "core/io/resource.h"
 #include "core/object/object.h"
 #include "core/templates/local_vector.h"
+#include "core/templates/rb_set.h"
 #include "scene/2d/light_occluder_2d.h"
 #include "scene/2d/navigation_region_2d.h"
 #include "scene/main/canvas_item.h"
diff --git a/scene/resources/visual_shader.cpp b/scene/resources/visual_shader.cpp
index d361aa876b..18bb0ff01d 100644
--- a/scene/resources/visual_shader.cpp
+++ b/scene/resources/visual_shader.cpp
@@ -1180,7 +1180,7 @@ String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port
 	StringBuilder global_code_per_node;
 	HashMap<Type, StringBuilder> global_code_per_func;
 	StringBuilder code;
-	RBSet<StringName> classes;
+	HashSet<StringName> classes;
 
 	global_code += String() + "shader_type canvas_item;\n";
 
@@ -1222,7 +1222,7 @@ String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port
 
 	code += "\nvoid fragment() {\n";
 
-	RBSet<int> processed;
+	HashSet<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());
 
@@ -1551,7 +1551,7 @@ void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
 	//render modes
 
 	HashMap<String, String> blend_mode_enums;
-	RBSet<String> toggles;
+	HashSet<String> toggles;
 
 	const Vector<ShaderLanguage::ModeInfo> &rmodes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(shader_mode));
 
@@ -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, 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 {
+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, HashSet<int> &processed, bool for_preview, HashSet<StringName> &r_classes) const {
 	const Ref<VisualShaderNode> vsnode = graph[type].nodes[node].node;
 
 	if (vsnode->is_disabled()) {
@@ -2136,7 +2136,7 @@ void VisualShader::_update_shader() const {
 	HashMap<Type, StringBuilder> global_code_per_func;
 	StringBuilder code;
 	Vector<VisualShader::DefaultTextureParam> default_tex_params;
-	RBSet<StringName> classes;
+	HashSet<StringName> classes;
 	HashMap<int, int> insertion_pos;
 	static const char *shader_mode_str[Shader::MODE_MAX] = { "spatial", "canvas_item", "particles", "sky", "fog" };
 
@@ -2181,7 +2181,7 @@ 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;
-	RBSet<String> used_uniform_names;
+	HashSet<String> used_uniform_names;
 	List<VisualShaderNodeUniform *> uniforms;
 	HashMap<int, List<int>> emitters;
 	HashMap<int, List<int>> varying_setters;
@@ -2270,7 +2270,7 @@ void VisualShader::_update_shader() const {
 	}
 
 	HashMap<int, String> code_map;
-	RBSet<int> empty_funcs;
+	HashSet<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;
-		RBSet<int> processed;
+		HashSet<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 aa5263943b..925dff31af 100644
--- a/scene/resources/visual_shader.h
+++ b/scene/resources/visual_shader.h
@@ -139,7 +139,7 @@ private:
 	Vector2 graph_offset;
 
 	HashMap<String, int> modes;
-	RBSet<StringName> flags;
+	HashSet<StringName> flags;
 
 	HashMap<String, Varying> varyings;
 	List<Varying> varyings_list;
@@ -158,7 +158,7 @@ private:
 		}
 	};
 
-	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;
+	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, HashSet<int> &processed, bool for_preview, HashSet<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;
diff --git a/scene/resources/world_2d.h b/scene/resources/world_2d.h
index 71ae40ec82..c04b8f6461 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;
 
-	RBSet<Viewport *> viewports;
+	HashSet<Viewport *> viewports;
 
 protected:
 	static void _bind_methods();
@@ -62,7 +62,7 @@ public:
 
 	PhysicsDirectSpaceState2D *get_direct_space_state();
 
-	_FORCE_INLINE_ const RBSet<Viewport *> &get_viewports() { return viewports; }
+	_FORCE_INLINE_ const HashSet<Viewport *> &get_viewports() { return viewports; }
 
 	World2D();
 	~World2D();
diff --git a/scene/resources/world_3d.h b/scene/resources/world_3d.h
index 18d28e812f..08bc050349 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;
 
-	RBSet<Camera3D *> cameras;
+	HashSet<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 RBSet<Camera3D *> &get_cameras() const { return cameras; }
+	_FORCE_INLINE_ const HashSet<Camera3D *> &get_cameras() const { return cameras; }
 
 	PhysicsDirectSpaceState3D *get_direct_space_state();
 
diff --git a/servers/audio/audio_stream.h b/servers/audio/audio_stream.h
index 8851e1419b..bf200e7ecf 100644
--- a/servers/audio/audio_stream.h
+++ b/servers/audio/audio_stream.h
@@ -125,7 +125,7 @@ class AudioStreamMicrophone : public AudioStream {
 	GDCLASS(AudioStreamMicrophone, AudioStream);
 	friend class AudioStreamPlaybackMicrophone;
 
-	RBSet<AudioStreamPlaybackMicrophone *> playbacks;
+	HashSet<AudioStreamPlaybackMicrophone *> playbacks;
 
 protected:
 	static void _bind_methods();
@@ -192,7 +192,7 @@ private:
 		float weight;
 	};
 
-	RBSet<AudioStreamPlaybackRandomizer *> playbacks;
+	HashSet<AudioStreamPlaybackRandomizer *> playbacks;
 	Vector<PoolEntry> audio_stream_pool;
 	float random_pitch_scale = 1.1f;
 	float random_volume_offset_db = 5.0f;
diff --git a/servers/extensions/physics_server_3d_extension.cpp b/servers/extensions/physics_server_3d_extension.cpp
index b073e837e2..3694dcdb9a 100644
--- a/servers/extensions/physics_server_3d_extension.cpp
+++ b/servers/extensions/physics_server_3d_extension.cpp
@@ -34,7 +34,7 @@ bool PhysicsDirectSpaceState3DExtension::is_body_excluded_from_query(const RID &
 	return exclude && exclude->has(p_body);
 }
 
-thread_local const RBSet<RID> *PhysicsDirectSpaceState3DExtension::exclude = nullptr;
+thread_local const HashSet<RID> *PhysicsDirectSpaceState3DExtension::exclude = nullptr;
 
 void PhysicsDirectSpaceState3DExtension::_bind_methods() {
 	GDVIRTUAL_BIND(_intersect_ray, "from", "to", "collision_mask", "collide_with_bodies", "collide_with_areas", "hit_from_inside", "hit_back_faces", "result");
@@ -113,8 +113,8 @@ void PhysicsDirectBodyState3DExtension::_bind_methods() {
 PhysicsDirectBodyState3DExtension::PhysicsDirectBodyState3DExtension() {
 }
 
-thread_local const RBSet<RID> *PhysicsServer3DExtension::exclude_bodies = nullptr;
-thread_local const RBSet<ObjectID> *PhysicsServer3DExtension::exclude_objects = nullptr;
+thread_local const HashSet<RID> *PhysicsServer3DExtension::exclude_bodies = nullptr;
+thread_local const HashSet<ObjectID> *PhysicsServer3DExtension::exclude_objects = nullptr;
 
 bool PhysicsServer3DExtension::body_test_motion_is_excluding_body(RID p_body) const {
 	return exclude_bodies && exclude_bodies->has(p_body);
diff --git a/servers/extensions/physics_server_3d_extension.h b/servers/extensions/physics_server_3d_extension.h
index 8b49278306..663af1ae6c 100644
--- a/servers/extensions/physics_server_3d_extension.h
+++ b/servers/extensions/physics_server_3d_extension.h
@@ -122,7 +122,7 @@ GDVIRTUAL_NATIVE_PTR(PhysicsServer3DExtensionShapeRestInfo)
 class PhysicsDirectSpaceState3DExtension : public PhysicsDirectSpaceState3D {
 	GDCLASS(PhysicsDirectSpaceState3DExtension, PhysicsDirectSpaceState3D);
 
-	thread_local static const RBSet<RID> *exclude;
+	thread_local static const HashSet<RID> *exclude;
 
 protected:
 	static void _bind_methods();
@@ -388,8 +388,8 @@ public:
 
 	GDVIRTUAL7RC(bool, _body_test_motion, RID, const Transform3D &, const Vector3 &, real_t, int, bool, GDNativePtr<PhysicsServer3DExtensionMotionResult>)
 
-	thread_local static const RBSet<RID> *exclude_bodies;
-	thread_local static const RBSet<ObjectID> *exclude_objects;
+	thread_local static const HashSet<RID> *exclude_bodies;
+	thread_local static const HashSet<ObjectID> *exclude_objects;
 
 	bool body_test_motion_is_excluding_body(RID p_body) const;
 	bool body_test_motion_is_excluding_object(ObjectID p_object) const;
diff --git a/servers/physics_2d/godot_area_2d.h b/servers/physics_2d/godot_area_2d.h
index b825ea5cdb..35dad9d2c3 100644
--- a/servers/physics_2d/godot_area_2d.h
+++ b/servers/physics_2d/godot_area_2d.h
@@ -93,7 +93,7 @@ class GodotArea2D : public GodotCollisionObject2D {
 	HashMap<BodyKey, BodyState, BodyKey> monitored_bodies;
 	HashMap<BodyKey, BodyState, BodyKey> monitored_areas;
 
-	RBSet<GodotConstraint2D *> constraints;
+	HashSet<GodotConstraint2D *> constraints;
 
 	virtual void _shapes_changed() override;
 	void _queue_monitor_update();
@@ -142,7 +142,7 @@ public:
 
 	_FORCE_INLINE_ void add_constraint(GodotConstraint2D *p_constraint) { constraints.insert(p_constraint); }
 	_FORCE_INLINE_ void remove_constraint(GodotConstraint2D *p_constraint) { constraints.erase(p_constraint); }
-	_FORCE_INLINE_ const RBSet<GodotConstraint2D *> &get_constraints() const { return constraints; }
+	_FORCE_INLINE_ const HashSet<GodotConstraint2D *> &get_constraints() const { return constraints; }
 	_FORCE_INLINE_ void clear_constraints() { constraints.clear(); }
 
 	void set_monitorable(bool p_monitorable);
diff --git a/servers/physics_2d/godot_physics_server_2d.cpp b/servers/physics_2d/godot_physics_server_2d.cpp
index cb829e5d91..99e68de07c 100644
--- a/servers/physics_2d/godot_physics_server_2d.cpp
+++ b/servers/physics_2d/godot_physics_server_2d.cpp
@@ -1212,7 +1212,7 @@ void GodotPhysicsServer2D::free(RID p_rid) {
 		GodotSpace2D *space = space_owner.get_or_null(p_rid);
 
 		while (space->get_objects().size()) {
-			GodotCollisionObject2D *co = static_cast<GodotCollisionObject2D *>(space->get_objects().front()->get());
+			GodotCollisionObject2D *co = static_cast<GodotCollisionObject2D *>(*space->get_objects().begin());
 			co->set_space(nullptr);
 		}
 
diff --git a/servers/physics_2d/godot_physics_server_2d.h b/servers/physics_2d/godot_physics_server_2d.h
index 55a7b39b9e..2af6e5c97c 100644
--- a/servers/physics_2d/godot_physics_server_2d.h
+++ b/servers/physics_2d/godot_physics_server_2d.h
@@ -56,7 +56,7 @@ class GodotPhysicsServer2D : public PhysicsServer2D {
 	bool flushing_queries = false;
 
 	GodotStep2D *stepper = nullptr;
-	RBSet<const GodotSpace2D *> active_spaces;
+	HashSet<const GodotSpace2D *> active_spaces;
 
 	mutable RID_PtrOwner<GodotShape2D, true> shape_owner;
 	mutable RID_PtrOwner<GodotSpace2D, true> space_owner;
diff --git a/servers/physics_2d/godot_space_2d.cpp b/servers/physics_2d/godot_space_2d.cpp
index 0a7859d86a..166ec3049e 100644
--- a/servers/physics_2d/godot_space_2d.cpp
+++ b/servers/physics_2d/godot_space_2d.cpp
@@ -1073,7 +1073,7 @@ void GodotSpace2D::remove_object(GodotCollisionObject2D *p_object) {
 	objects.erase(p_object);
 }
 
-const RBSet<GodotCollisionObject2D *> &GodotSpace2D::get_objects() const {
+const HashSet<GodotCollisionObject2D *> &GodotSpace2D::get_objects() const {
 	return objects;
 }
 
diff --git a/servers/physics_2d/godot_space_2d.h b/servers/physics_2d/godot_space_2d.h
index e8b05fa4f9..b6fc48bd70 100644
--- a/servers/physics_2d/godot_space_2d.h
+++ b/servers/physics_2d/godot_space_2d.h
@@ -92,7 +92,7 @@ private:
 	static void *_broadphase_pair(GodotCollisionObject2D *A, int p_subindex_A, GodotCollisionObject2D *B, int p_subindex_B, void *p_self);
 	static void _broadphase_unpair(GodotCollisionObject2D *A, int p_subindex_A, GodotCollisionObject2D *B, int p_subindex_B, void *p_data, void *p_self);
 
-	RBSet<GodotCollisionObject2D *> objects;
+	HashSet<GodotCollisionObject2D *> objects;
 
 	GodotArea2D *area = nullptr;
 
@@ -156,7 +156,7 @@ public:
 
 	void add_object(GodotCollisionObject2D *p_object);
 	void remove_object(GodotCollisionObject2D *p_object);
-	const RBSet<GodotCollisionObject2D *> &get_objects() const;
+	const HashSet<GodotCollisionObject2D *> &get_objects() const;
 
 	_FORCE_INLINE_ int get_solver_iterations() const { return solver_iterations; }
 	_FORCE_INLINE_ real_t get_contact_recycle_radius() const { return contact_recycle_radius; }
diff --git a/servers/physics_3d/godot_area_3d.h b/servers/physics_3d/godot_area_3d.h
index 2a5e5a537a..a00451f602 100644
--- a/servers/physics_3d/godot_area_3d.h
+++ b/servers/physics_3d/godot_area_3d.h
@@ -99,7 +99,7 @@ class GodotArea3D : public GodotCollisionObject3D {
 	HashMap<BodyKey, BodyState, BodyKey> monitored_bodies;
 	HashMap<BodyKey, BodyState, BodyKey> monitored_areas;
 
-	RBSet<GodotConstraint3D *> constraints;
+	HashSet<GodotConstraint3D *> constraints;
 
 	virtual void _shapes_changed() override;
 	void _queue_monitor_update();
@@ -163,7 +163,7 @@ public:
 
 	_FORCE_INLINE_ void add_constraint(GodotConstraint3D *p_constraint) { constraints.insert(p_constraint); }
 	_FORCE_INLINE_ void remove_constraint(GodotConstraint3D *p_constraint) { constraints.erase(p_constraint); }
-	_FORCE_INLINE_ const RBSet<GodotConstraint3D *> &get_constraints() const { return constraints; }
+	_FORCE_INLINE_ const HashSet<GodotConstraint3D *> &get_constraints() const { return constraints; }
 	_FORCE_INLINE_ void clear_constraints() { constraints.clear(); }
 
 	void set_monitorable(bool p_monitorable);
diff --git a/servers/physics_3d/godot_physics_server_3d.cpp b/servers/physics_3d/godot_physics_server_3d.cpp
index b3a384ba8f..bed9b02da1 100644
--- a/servers/physics_3d/godot_physics_server_3d.cpp
+++ b/servers/physics_3d/godot_physics_server_3d.cpp
@@ -1570,7 +1570,7 @@ void GodotPhysicsServer3D::free(RID p_rid) {
 		GodotSpace3D *space = space_owner.get_or_null(p_rid);
 
 		while (space->get_objects().size()) {
-			GodotCollisionObject3D *co = static_cast<GodotCollisionObject3D *>(space->get_objects().front()->get());
+			GodotCollisionObject3D *co = static_cast<GodotCollisionObject3D *>(*space->get_objects().begin());
 			co->set_space(nullptr);
 		}
 
diff --git a/servers/physics_3d/godot_physics_server_3d.h b/servers/physics_3d/godot_physics_server_3d.h
index 65c53084ac..1d57451925 100644
--- a/servers/physics_3d/godot_physics_server_3d.h
+++ b/servers/physics_3d/godot_physics_server_3d.h
@@ -54,7 +54,7 @@ class GodotPhysicsServer3D : public PhysicsServer3D {
 	bool flushing_queries = false;
 
 	GodotStep3D *stepper = nullptr;
-	RBSet<const GodotSpace3D *> active_spaces;
+	HashSet<const GodotSpace3D *> active_spaces;
 
 	mutable RID_PtrOwner<GodotShape3D, true> shape_owner;
 	mutable RID_PtrOwner<GodotSpace3D, true> space_owner;
diff --git a/servers/physics_3d/godot_soft_body_3d.h b/servers/physics_3d/godot_soft_body_3d.h
index 094ab39c47..86f73c366b 100644
--- a/servers/physics_3d/godot_soft_body_3d.h
+++ b/servers/physics_3d/godot_soft_body_3d.h
@@ -37,8 +37,8 @@
 #include "core/math/aabb.h"
 #include "core/math/dynamic_bvh.h"
 #include "core/math/vector3.h"
+#include "core/templates/hash_set.h"
 #include "core/templates/local_vector.h"
-#include "core/templates/rb_set.h"
 #include "core/templates/vset.h"
 
 class GodotConstraint3D;
@@ -103,7 +103,7 @@ class GodotSoftBody3D : public GodotCollisionObject3D {
 
 	SelfList<GodotSoftBody3D> active_list;
 
-	RBSet<GodotConstraint3D *> constraints;
+	HashSet<GodotConstraint3D *> constraints;
 
 	Vector<AreaCMP> areas;
 
@@ -123,7 +123,7 @@ public:
 
 	_FORCE_INLINE_ void add_constraint(GodotConstraint3D *p_constraint) { constraints.insert(p_constraint); }
 	_FORCE_INLINE_ void remove_constraint(GodotConstraint3D *p_constraint) { constraints.erase(p_constraint); }
-	_FORCE_INLINE_ const RBSet<GodotConstraint3D *> &get_constraints() const { return constraints; }
+	_FORCE_INLINE_ const HashSet<GodotConstraint3D *> &get_constraints() const { return constraints; }
 	_FORCE_INLINE_ void clear_constraints() { constraints.clear(); }
 
 	_FORCE_INLINE_ void add_exception(const RID &p_exception) { exceptions.insert(p_exception); }
diff --git a/servers/physics_3d/godot_space_3d.cpp b/servers/physics_3d/godot_space_3d.cpp
index 2bdaf581a1..533d7605ce 100644
--- a/servers/physics_3d/godot_space_3d.cpp
+++ b/servers/physics_3d/godot_space_3d.cpp
@@ -1096,7 +1096,7 @@ void GodotSpace3D::remove_object(GodotCollisionObject3D *p_object) {
 	objects.erase(p_object);
 }
 
-const RBSet<GodotCollisionObject3D *> &GodotSpace3D::get_objects() const {
+const HashSet<GodotCollisionObject3D *> &GodotSpace3D::get_objects() const {
 	return objects;
 }
 
diff --git a/servers/physics_3d/godot_space_3d.h b/servers/physics_3d/godot_space_3d.h
index 67dde30fb5..df7315e96d 100644
--- a/servers/physics_3d/godot_space_3d.h
+++ b/servers/physics_3d/godot_space_3d.h
@@ -89,7 +89,7 @@ private:
 	static void *_broadphase_pair(GodotCollisionObject3D *A, int p_subindex_A, GodotCollisionObject3D *B, int p_subindex_B, void *p_self);
 	static void _broadphase_unpair(GodotCollisionObject3D *A, int p_subindex_A, GodotCollisionObject3D *B, int p_subindex_B, void *p_data, void *p_self);
 
-	RBSet<GodotCollisionObject3D *> objects;
+	HashSet<GodotCollisionObject3D *> objects;
 
 	GodotArea3D *area = nullptr;
 
@@ -158,7 +158,7 @@ public:
 
 	void add_object(GodotCollisionObject3D *p_object);
 	void remove_object(GodotCollisionObject3D *p_object);
-	const RBSet<GodotCollisionObject3D *> &get_objects() const;
+	const HashSet<GodotCollisionObject3D *> &get_objects() const;
 
 	_FORCE_INLINE_ int get_solver_iterations() const { return solver_iterations; }
 	_FORCE_INLINE_ real_t get_contact_recycle_radius() const { return contact_recycle_radius; }
diff --git a/servers/physics_server_2d.h b/servers/physics_server_2d.h
index 745ee38ee1..7a821c64e6 100644
--- a/servers/physics_server_2d.h
+++ b/servers/physics_server_2d.h
@@ -127,7 +127,7 @@ public:
 	struct RayParameters {
 		Vector2 from;
 		Vector2 to;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -157,7 +157,7 @@ public:
 	struct PointParameters {
 		Vector2 position;
 		ObjectID canvas_instance_id;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -173,7 +173,7 @@ public:
 		Transform2D transform;
 		Vector2 motion;
 		real_t margin = 0.0;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -483,8 +483,8 @@ public:
 		Vector2 motion;
 		real_t margin = 0.08;
 		bool collide_separation_ray = false;
-		RBSet<RID> exclude_bodies;
-		RBSet<ObjectID> exclude_objects;
+		HashSet<RID> exclude_bodies;
+		HashSet<ObjectID> exclude_objects;
 		bool recovery_as_collision = false;
 
 		MotionParameters() {}
diff --git a/servers/physics_server_3d.h b/servers/physics_server_3d.h
index 6a721f75a3..86a41d96ef 100644
--- a/servers/physics_server_3d.h
+++ b/servers/physics_server_3d.h
@@ -133,7 +133,7 @@ public:
 	struct RayParameters {
 		Vector3 from;
 		Vector3 to;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -165,7 +165,7 @@ public:
 
 	struct PointParameters {
 		Vector3 position;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -179,7 +179,7 @@ public:
 		Transform3D transform;
 		Vector3 motion;
 		real_t margin = 0.0;
-		RBSet<RID> exclude;
+		HashSet<RID> exclude;
 		uint32_t collision_mask = UINT32_MAX;
 
 		bool collide_with_bodies = true;
@@ -520,8 +520,8 @@ public:
 		real_t margin = 0.001;
 		int max_collisions = 1;
 		bool collide_separation_ray = false;
-		RBSet<RID> exclude_bodies;
-		RBSet<ObjectID> exclude_objects;
+		HashSet<RID> exclude_bodies;
+		HashSet<ObjectID> exclude_objects;
 		bool recovery_as_collision = false;
 
 		MotionParameters() {}
diff --git a/servers/rendering/renderer_canvas_cull.cpp b/servers/rendering/renderer_canvas_cull.cpp
index 9291a89333..bc1e8eb348 100644
--- a/servers/rendering/renderer_canvas_cull.cpp
+++ b/servers/rendering/renderer_canvas_cull.cpp
@@ -1928,14 +1928,14 @@ bool RendererCanvasCull::free(RID p_rid) {
 		ERR_FAIL_COND_V(!canvas, false);
 
 		while (canvas->viewports.size()) {
-			RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.get_or_null(canvas->viewports.front()->get());
+			RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.get_or_null(*canvas->viewports.begin());
 			ERR_FAIL_COND_V(!vp, true);
 
 			HashMap<RID, RendererViewport::Viewport::CanvasData>::Iterator E = vp->canvas_map.find(p_rid);
 			ERR_FAIL_COND_V(!E, true);
 			vp->canvas_map.erase(p_rid);
 
-			canvas->viewports.erase(canvas->viewports.front());
+			canvas->viewports.erase(*canvas->viewports.begin());
 		}
 
 		for (int i = 0; i < canvas->child_items.size(); i++) {
@@ -2030,8 +2030,8 @@ bool RendererCanvasCull::free(RID p_rid) {
 		RSG::canvas_render->free(occluder_poly->occluder);
 
 		while (occluder_poly->owners.size()) {
-			occluder_poly->owners.front()->get()->polygon = RID();
-			occluder_poly->owners.erase(occluder_poly->owners.front());
+			(*occluder_poly->owners.begin())->polygon = RID();
+			occluder_poly->owners.remove(occluder_poly->owners.begin());
 		}
 
 		canvas_light_occluder_polygon_owner.free(p_rid);
diff --git a/servers/rendering/renderer_canvas_cull.h b/servers/rendering/renderer_canvas_cull.h
index 6f3cd1d2c6..963cca7630 100644
--- a/servers/rendering/renderer_canvas_cull.h
+++ b/servers/rendering/renderer_canvas_cull.h
@@ -108,7 +108,7 @@ public:
 		Rect2 aabb;
 		RS::CanvasOccluderPolygonCullMode cull_mode;
 		RID occluder;
-		RBSet<RendererCanvasRender::LightOccluderInstance *> owners;
+		HashSet<RendererCanvasRender::LightOccluderInstance *> owners;
 
 		LightOccluderPolygon() {
 			active = false;
@@ -121,7 +121,7 @@ public:
 	RID_Owner<RendererCanvasRender::LightOccluderInstance, true> canvas_light_occluder_owner;
 
 	struct Canvas : public RendererViewport::CanvasBase {
-		RBSet<RID> viewports;
+		HashSet<RID> viewports;
 		struct ChildItem {
 			Point2 mirror;
 			Item *item = nullptr;
@@ -130,10 +130,10 @@ public:
 			}
 		};
 
-		RBSet<RendererCanvasRender::Light *> lights;
-		RBSet<RendererCanvasRender::Light *> directional_lights;
+		HashSet<RendererCanvasRender::Light *> lights;
+		HashSet<RendererCanvasRender::Light *> directional_lights;
 
-		RBSet<RendererCanvasRender::LightOccluderInstance *> occluders;
+		HashSet<RendererCanvasRender::LightOccluderInstance *> occluders;
 
 		bool children_order_dirty;
 		Vector<ChildItem> child_items;
diff --git a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h
index c22b2f243d..a4eb0656b7 100644
--- a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h
+++ b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h
@@ -239,7 +239,7 @@ public:
 	ShaderData *overdraw_material_shader_ptr = nullptr;
 
 	Vector<RD::PipelineSpecializationConstant> default_specialization_constants;
-	RBSet<uint32_t> valid_color_pass_pipelines;
+	HashSet<uint32_t> valid_color_pass_pipelines;
 	SceneShaderForwardClustered();
 	~SceneShaderForwardClustered();
 
diff --git a/servers/rendering/renderer_rd/renderer_scene_render_rd.h b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
index 4daee17525..a384f216cd 100644
--- a/servers/rendering/renderer_rd/renderer_scene_render_rd.h
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
@@ -387,7 +387,7 @@ private:
 
 		Rect2 directional_rect;
 
-		RBSet<RID> shadow_atlases; //shadow atlases where this light is registered
+		HashSet<RID> shadow_atlases; //shadow atlases where this light is registered
 
 		ForwardID forward_id = -1;
 
diff --git a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp
index 93f1f4e0d9..de9913be3f 100644
--- a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp
+++ b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp
@@ -2267,7 +2267,7 @@ void MaterialStorage::shader_free(RID p_rid) {
 
 	//make material unreference this
 	while (shader->owners.size()) {
-		material_set_shader(shader->owners.front()->get()->self, RID());
+		material_set_shader((*shader->owners.begin())->self, RID());
 	}
 
 	//clear data if exists
diff --git a/servers/rendering/renderer_rd/storage_rd/material_storage.h b/servers/rendering/renderer_rd/storage_rd/material_storage.h
index 7d4db49f78..f83df05355 100644
--- a/servers/rendering/renderer_rd/storage_rd/material_storage.h
+++ b/servers/rendering/renderer_rd/storage_rd/material_storage.h
@@ -77,7 +77,7 @@ struct Shader {
 	String code;
 	ShaderType type;
 	HashMap<StringName, HashMap<int, RID>> default_texture_parameter;
-	RBSet<Material *> owners;
+	HashSet<Material *> owners;
 };
 
 /* Material structs */
@@ -137,7 +137,7 @@ struct GlobalVariables {
 		BUFFER_DIRTY_REGION_SIZE = 1024
 	};
 	struct Variable {
-		RBSet<RID> texture_materials; // materials using this
+		HashSet<RID> texture_materials; // materials using this
 
 		RS::GlobalVariableType type;
 		Variant value;
diff --git a/servers/rendering/renderer_rd/storage_rd/mesh_storage.h b/servers/rendering/renderer_rd/storage_rd/mesh_storage.h
index d90bb2f128..7ce019cf98 100644
--- a/servers/rendering/renderer_rd/storage_rd/mesh_storage.h
+++ b/servers/rendering/renderer_rd/storage_rd/mesh_storage.h
@@ -141,7 +141,7 @@ struct Mesh {
 	List<MeshInstance *> instances;
 
 	RID shadow_mesh;
-	RBSet<Mesh *> shadow_owners;
+	HashSet<Mesh *> shadow_owners;
 
 	RendererStorage::Dependency dependency;
 };
diff --git a/servers/rendering/renderer_rd/storage_rd/particles_storage.h b/servers/rendering/renderer_rd/storage_rd/particles_storage.h
index eb55db19fb..115633d17a 100644
--- a/servers/rendering/renderer_rd/storage_rd/particles_storage.h
+++ b/servers/rendering/renderer_rd/storage_rd/particles_storage.h
@@ -224,7 +224,7 @@ struct Particles {
 	ParticleEmissionBuffer *emission_buffer = nullptr;
 	RID emission_storage_buffer;
 
-	RBSet<RID> collisions;
+	HashSet<RID> collisions;
 
 	RendererStorage::Dependency dependency;
 
diff --git a/servers/rendering/renderer_rd/storage_rd/texture_storage.h b/servers/rendering/renderer_rd/storage_rd/texture_storage.h
index 029816cbda..418eb82808 100644
--- a/servers/rendering/renderer_rd/storage_rd/texture_storage.h
+++ b/servers/rendering/renderer_rd/storage_rd/texture_storage.h
@@ -124,7 +124,7 @@ public:
 	RID proxy_to;
 	Vector<RID> proxies;
 
-	RBSet<RID> lightmap_users;
+	HashSet<RID> lightmap_users;
 
 	RS::TextureDetectCallback detect_3d_callback = nullptr;
 	void *detect_3d_callback_ud = nullptr;
diff --git a/servers/rendering/renderer_scene_cull.cpp b/servers/rendering/renderer_scene_cull.cpp
index 89bd12ea3d..2cb4e16583 100644
--- a/servers/rendering/renderer_scene_cull.cpp
+++ b/servers/rendering/renderer_scene_cull.cpp
@@ -562,8 +562,8 @@ void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) {
 			case RS::INSTANCE_LIGHTMAP: {
 				InstanceLightmapData *lightmap_data = static_cast<InstanceLightmapData *>(instance->base_data);
 				//erase dependencies, since no longer a lightmap
-				while (lightmap_data->users.front()) {
-					instance_geometry_set_lightmap(lightmap_data->users.front()->get()->self, RID(), Rect2(), 0);
+				while (lightmap_data->users.begin()) {
+					instance_geometry_set_lightmap((*lightmap_data->users.begin())->self, RID(), Rect2(), 0);
 				}
 				scene_render->free(lightmap_data->instance);
 			} break;
@@ -1292,7 +1292,7 @@ void RendererSceneCull::instance_set_visibility_parent(RID p_instance, RID p_par
 
 bool RendererSceneCull::_update_instance_visibility_depth(Instance *p_instance) {
 	bool cycle_detected = false;
-	RBSet<Instance *> traversed_nodes;
+	HashSet<Instance *> traversed_nodes;
 
 	{
 		Instance *instance = p_instance;
@@ -3592,8 +3592,8 @@ void RendererSceneCull::render_probes() {
 }
 
 void RendererSceneCull::render_particle_colliders() {
-	while (heightfield_particle_colliders_update_list.front()) {
-		Instance *hfpc = heightfield_particle_colliders_update_list.front()->get();
+	while (heightfield_particle_colliders_update_list.begin()) {
+		Instance *hfpc = *heightfield_particle_colliders_update_list.begin();
 
 		if (hfpc->scenario && hfpc->base_type == RS::INSTANCE_PARTICLES_COLLISION && RSG::particles_storage->particles_collision_is_heightfield(hfpc->base)) {
 			//update heightfield
@@ -3625,7 +3625,7 @@ void RendererSceneCull::render_particle_colliders() {
 
 			scene_render->render_particle_collider_heightfield(hfpc->base, hfpc->transform, scene_cull_result.geometry_instances);
 		}
-		heightfield_particle_colliders_update_list.erase(heightfield_particle_colliders_update_list.front());
+		heightfield_particle_colliders_update_list.remove(heightfield_particle_colliders_update_list.begin());
 	}
 }
 
diff --git a/servers/rendering/renderer_scene_cull.h b/servers/rendering/renderer_scene_cull.h
index c5325ef30a..60983f9944 100644
--- a/servers/rendering/renderer_scene_cull.h
+++ b/servers/rendering/renderer_scene_cull.h
@@ -443,7 +443,7 @@ public:
 		float visibility_range_end_margin = 0.0f;
 		RS::VisibilityRangeFadeMode visibility_range_fade_mode = RS::VISIBILITY_RANGE_FADE_DISABLED;
 		Instance *visibility_parent = nullptr;
-		RBSet<Instance *> visibility_dependencies;
+		HashSet<Instance *> visibility_dependencies;
 		uint32_t visibility_dependencies_depth = 0;
 		float transparency = 0.0f;
 		Scenario *scenario = nullptr;
@@ -579,16 +579,16 @@ public:
 
 	struct InstanceGeometryData : public InstanceBaseData {
 		RendererSceneRender::GeometryInstance *geometry_instance = nullptr;
-		RBSet<Instance *> lights;
+		HashSet<Instance *> lights;
 		bool can_cast_shadows;
 		bool material_is_animated;
 		uint32_t projector_count = 0;
 		uint32_t softshadow_count = 0;
 
-		RBSet<Instance *> decals;
-		RBSet<Instance *> reflection_probes;
-		RBSet<Instance *> voxel_gi_instances;
-		RBSet<Instance *> lightmap_captures;
+		HashSet<Instance *> decals;
+		HashSet<Instance *> reflection_probes;
+		HashSet<Instance *> voxel_gi_instances;
+		HashSet<Instance *> lightmap_captures;
 
 		InstanceGeometryData() {
 			can_cast_shadows = true;
@@ -599,7 +599,7 @@ public:
 	struct InstanceReflectionProbeData : public InstanceBaseData {
 		Instance *owner = nullptr;
 
-		RBSet<Instance *> geometries;
+		HashSet<Instance *> geometries;
 
 		RID instance;
 		SelfList<InstanceReflectionProbeData> update_list;
@@ -616,7 +616,7 @@ public:
 		Instance *owner = nullptr;
 		RID instance;
 
-		RBSet<Instance *> geometries;
+		HashSet<Instance *> geometries;
 
 		InstanceDecalData() {
 		}
@@ -654,7 +654,7 @@ public:
 		bool uses_projector = false;
 		bool uses_softshadow = false;
 
-		RBSet<Instance *> geometries;
+		HashSet<Instance *> geometries;
 
 		Instance *baked_light = nullptr;
 
@@ -673,10 +673,10 @@ public:
 	struct InstanceVoxelGIData : public InstanceBaseData {
 		Instance *owner = nullptr;
 
-		RBSet<Instance *> geometries;
-		RBSet<Instance *> dynamic_geometries;
+		HashSet<Instance *> geometries;
+		HashSet<Instance *> dynamic_geometries;
 
-		RBSet<Instance *> lights;
+		HashSet<Instance *> lights;
 
 		struct LightCache {
 			RS::LightType type;
@@ -713,8 +713,8 @@ public:
 
 	struct InstanceLightmapData : public InstanceBaseData {
 		RID instance;
-		RBSet<Instance *> geometries;
-		RBSet<Instance *> users;
+		HashSet<Instance *> geometries;
+		HashSet<Instance *> users;
 
 		InstanceLightmapData() {
 		}
@@ -779,7 +779,7 @@ public:
 		}
 	};
 
-	RBSet<Instance *> heightfield_particle_colliders_update_list;
+	HashSet<Instance *> heightfield_particle_colliders_update_list;
 
 	PagedArrayPool<Instance *> instance_cull_page_pool;
 	PagedArrayPool<RendererSceneRender::GeometryInstance *> geometry_instance_cull_page_pool;
diff --git a/servers/rendering/renderer_storage.h b/servers/rendering/renderer_storage.h
index 672fd4e4f1..bb4acab582 100644
--- a/servers/rendering/renderer_storage.h
+++ b/servers/rendering/renderer_storage.h
@@ -117,7 +117,7 @@ public:
 	private:
 		friend struct Dependency;
 		uint32_t instance_version = 0;
-		RBSet<Dependency *> dependencies;
+		HashSet<Dependency *> dependencies;
 	};
 
 	virtual void base_update_dependency(RID p_base, DependencyTracker *p_instance) = 0;
diff --git a/servers/rendering/shader_compiler.cpp b/servers/rendering/shader_compiler.cpp
index 662016e6f4..81cd83aebb 100644
--- a/servers/rendering/shader_compiler.cpp
+++ b/servers/rendering/shader_compiler.cpp
@@ -289,7 +289,7 @@ String ShaderCompiler::_get_sampler_name(ShaderLanguage::TextureFilter p_filter,
 	return actions.sampler_array_name + "[" + itos(p_filter + (p_repeat == ShaderLanguage::REPEAT_ENABLE ? ShaderLanguage::FILTER_DEFAULT : 0)) + "]";
 }
 
-void ShaderCompiler::_dump_function_deps(const SL::ShaderNode *p_node, const StringName &p_for_func, const HashMap<StringName, String> &p_func_code, String &r_to_add, RBSet<StringName> &added) {
+void ShaderCompiler::_dump_function_deps(const SL::ShaderNode *p_node, const StringName &p_for_func, const HashMap<StringName, String> &p_func_code, String &r_to_add, HashSet<StringName> &added) {
 	int fidx = -1;
 
 	for (int i = 0; i < p_node->functions.size(); i++) {
@@ -748,7 +748,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
 
 			//place functions in actual code
 
-			RBSet<StringName> added_funcs_per_stage[STAGE_MAX];
+			HashSet<StringName> added_funcs_per_stage[STAGE_MAX];
 
 			for (int i = 0; i < pnode->functions.size(); i++) {
 				SL::FunctionNode *fnode = pnode->functions[i].function;
diff --git a/servers/rendering/shader_compiler.h b/servers/rendering/shader_compiler.h
index 85b93c4063..2656ee68a6 100644
--- a/servers/rendering/shader_compiler.h
+++ b/servers/rendering/shader_compiler.h
@@ -103,20 +103,20 @@ private:
 
 	String _get_sampler_name(ShaderLanguage::TextureFilter p_filter, ShaderLanguage::TextureRepeat p_repeat);
 
-	void _dump_function_deps(const ShaderLanguage::ShaderNode *p_node, const StringName &p_for_func, const HashMap<StringName, String> &p_func_code, String &r_to_add, RBSet<StringName> &added);
+	void _dump_function_deps(const ShaderLanguage::ShaderNode *p_node, const StringName &p_for_func, const HashMap<StringName, String> &p_func_code, String &r_to_add, HashSet<StringName> &added);
 	String _dump_node_code(const ShaderLanguage::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions, bool p_assigning, bool p_scope = true);
 
 	const ShaderLanguage::ShaderNode *shader = nullptr;
 	const ShaderLanguage::FunctionNode *function = nullptr;
 	StringName current_func_name;
 	StringName time_name;
-	RBSet<StringName> texture_functions;
+	HashSet<StringName> texture_functions;
 
-	RBSet<StringName> used_name_defines;
-	RBSet<StringName> used_flag_pointers;
-	RBSet<StringName> used_rmode_defines;
-	RBSet<StringName> internal_functions;
-	RBSet<StringName> fragment_varyings;
+	HashSet<StringName> used_name_defines;
+	HashSet<StringName> used_flag_pointers;
+	HashSet<StringName> used_rmode_defines;
+	HashSet<StringName> internal_functions;
+	HashSet<StringName> fragment_varyings;
 
 	DefaultIdentifierActions actions;
 
diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp
index d2e188a9a7..a3bd067963 100644
--- a/servers/rendering/shader_language.cpp
+++ b/servers/rendering/shader_language.cpp
@@ -4019,7 +4019,7 @@ uint32_t ShaderLanguage::get_datatype_size(ShaderLanguage::DataType p_type) {
 }
 
 void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
-	RBSet<String> kws;
+	HashSet<String> kws;
 
 	int idx = 0;
 
@@ -4056,7 +4056,7 @@ bool ShaderLanguage::is_control_flow_keyword(String p_keyword) {
 }
 
 void ShaderLanguage::get_builtin_funcs(List<String> *r_keywords) {
-	RBSet<String> kws;
+	HashSet<String> kws;
 
 	int idx = 0;
 
@@ -4340,7 +4340,7 @@ bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(StringNam
 				arg->tex_argument_check = true;
 				arg->tex_argument_filter = p_filter;
 				arg->tex_argument_repeat = p_repeat;
-				for (KeyValue<StringName, RBSet<int>> &E : arg->tex_argument_connect) {
+				for (KeyValue<StringName, HashSet<int>> &E : arg->tex_argument_connect) {
 					for (const int &F : E.value) {
 						if (!_propagate_function_call_sampler_uniform_settings(E.key, F, p_filter, p_repeat)) {
 							return false;
@@ -4374,7 +4374,7 @@ bool ShaderLanguage::_propagate_function_call_sampler_builtin_reference(StringNa
 				arg->tex_builtin_check = true;
 				arg->tex_builtin = p_builtin;
 
-				for (KeyValue<StringName, RBSet<int>> &E : arg->tex_argument_connect) {
+				for (KeyValue<StringName, HashSet<int>> &E : arg->tex_argument_connect) {
 					for (const int &F : E.value) {
 						if (!_propagate_function_call_sampler_builtin_reference(E.key, F, p_builtin)) {
 							return false;
@@ -5096,7 +5096,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 											for (int j = 0; j < base_function->arguments.size(); j++) {
 												if (base_function->arguments[j].name == varname) {
 													if (!base_function->arguments[j].tex_argument_connect.has(call_function->name)) {
-														base_function->arguments.write[j].tex_argument_connect[call_function->name] = RBSet<int>();
+														base_function->arguments.write[j].tex_argument_connect[call_function->name] = HashSet<int>();
 													}
 													base_function->arguments.write[j].tex_argument_connect[call_function->name].insert(i);
 													found = true;
@@ -7062,7 +7062,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
 					_set_tkpos(pos);
 					continue;
 				} else {
-					RBSet<int> constants;
+					HashSet<int> constants;
 					for (int i = 0; i < switch_block->statements.size(); i++) { // Checks for duplicates.
 						ControlFlowNode *flow = static_cast<ControlFlowNode *>(switch_block->statements[i]);
 						if (flow) {
@@ -7565,7 +7565,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun
 	return OK;
 }
 
-String ShaderLanguage::_get_shader_type_list(const RBSet<String> &p_shader_types) const {
+String ShaderLanguage::_get_shader_type_list(const HashSet<String> &p_shader_types) const {
 	// Return a list of shader types as an human-readable string
 	String valid_types;
 	for (const String &E : p_shader_types) {
@@ -7639,7 +7639,7 @@ Error ShaderLanguage::_validate_datatype(DataType p_type) {
 	return OK;
 }
 
-Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const RBSet<String> &p_shader_types) {
+Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types) {
 	Token tk = _get_token();
 	TkPos prev_pos;
 	Token next;
@@ -7790,7 +7790,7 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
 				st.shader_struct = st_node;
 
 				int member_count = 0;
-				RBSet<String> member_names;
+				HashSet<String> member_names;
 
 				while (true) { // variables list
 #ifdef DEBUG_ENABLED
@@ -9793,7 +9793,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 				}
 
 				int idx2 = 0;
-				RBSet<int> out_args;
+				HashSet<int> out_args;
 				while (builtin_func_out_args[idx2].name != nullptr) {
 					if (builtin_func_out_args[idx2].name == builtin_func_defs[idx].name) {
 						for (int i = 0; i < BuiltinFuncOutArgs::MAX_ARGS; i++) {
diff --git a/servers/rendering/shader_language.h b/servers/rendering/shader_language.h
index d4a2e0b549..cd3f07e27e 100644
--- a/servers/rendering/shader_language.h
+++ b/servers/rendering/shader_language.h
@@ -589,7 +589,7 @@ public:
 			bool is_const;
 			int array_size;
 
-			HashMap<StringName, RBSet<int>> tex_argument_connect;
+			HashMap<StringName, HashSet<int>> tex_argument_connect;
 		};
 
 		StringName name;
@@ -622,7 +622,7 @@ public:
 		struct Function {
 			StringName name;
 			FunctionNode *function = nullptr;
-			RBSet<StringName> uses_function;
+			HashSet<StringName> uses_function;
 			bool callable;
 		};
 
@@ -1068,10 +1068,10 @@ private:
 
 	Node *_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info);
 	Error _parse_block(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_just_one = false, bool p_can_break = false, bool p_can_continue = false);
-	String _get_shader_type_list(const RBSet<String> &p_shader_types) const;
+	String _get_shader_type_list(const HashSet<String> &p_shader_types) const;
 	String _get_qualifier_str(ArgumentQualifier p_qualifier) const;
 
-	Error _parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const RBSet<String> &p_shader_types);
+	Error _parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types);
 
 	Error _find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op);
 	Error _find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op);
@@ -1097,7 +1097,7 @@ public:
 		HashMap<StringName, FunctionInfo> functions;
 		Vector<ModeInfo> render_modes;
 		VaryingFunctionNames varying_function_names = VaryingFunctionNames();
-		RBSet<String> shader_types;
+		HashSet<String> shader_types;
 		GlobalVariableGetTypeFunc global_variable_type_func = nullptr;
 	};
 
diff --git a/servers/rendering/shader_types.cpp b/servers/rendering/shader_types.cpp
index 05700e7ff9..e0dd417758 100644
--- a/servers/rendering/shader_types.cpp
+++ b/servers/rendering/shader_types.cpp
@@ -39,7 +39,7 @@ const Vector<ShaderLanguage::ModeInfo> &ShaderTypes::get_modes(RS::ShaderMode p_
 	return shader_modes[p_mode].modes;
 }
 
-const RBSet<String> &ShaderTypes::get_types() const {
+const HashSet<String> &ShaderTypes::get_types() const {
 	return shader_types;
 }
 
diff --git a/servers/rendering/shader_types.h b/servers/rendering/shader_types.h
index e0fee0a822..107525cd15 100644
--- a/servers/rendering/shader_types.h
+++ b/servers/rendering/shader_types.h
@@ -45,7 +45,7 @@ class ShaderTypes {
 
 	static ShaderTypes *singleton;
 
-	RBSet<String> shader_types;
+	HashSet<String> shader_types;
 	List<String> shader_types_list;
 
 public:
@@ -53,7 +53,7 @@ public:
 
 	const HashMap<StringName, ShaderLanguage::FunctionInfo> &get_functions(RS::ShaderMode p_mode) const;
 	const Vector<ShaderLanguage::ModeInfo> &get_modes(RS::ShaderMode p_mode) const;
-	const RBSet<String> &get_types() const;
+	const HashSet<String> &get_types() const;
 	const List<String> &get_types_list() const;
 
 	ShaderTypes();
diff --git a/tests/core/templates/test_hash_set.h b/tests/core/templates/test_hash_set.h
new file mode 100644
index 0000000000..93fc0b26a3
--- /dev/null
+++ b/tests/core/templates/test_hash_set.h
@@ -0,0 +1,228 @@
+/*************************************************************************/
+/*  test_hash_set.h                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef TEST_HASH_SET_H
+#define TEST_HASH_SET_H
+
+#include "core/templates/hash_set.h"
+
+#include "tests/test_macros.h"
+
+namespace TestHashSet {
+
+TEST_CASE("[HashSet] Insert element") {
+	print_line("SMALL BEGIN MEM: ", Memory::get_mem_usage());
+	HashSet<int> set;
+	HashSet<int>::Iterator e = set.insert(42);
+
+	CHECK(e);
+	CHECK(*e == 42);
+	CHECK(set.has(42));
+	CHECK(set.find(42));
+	set.reset();
+	print_line("SMALL END MEM: ", Memory::get_mem_usage());
+}
+
+TEST_CASE("[HashSet] Insert existing element") {
+	HashSet<int> set;
+	set.insert(42);
+	set.insert(42);
+
+	CHECK(set.has(42));
+	CHECK(set.size() == 1);
+}
+
+TEST_CASE("[HashSet] Insert, iterate and remove many elements") {
+	const int elem_max = 12343;
+	HashSet<int> set;
+	for (int i = 0; i < elem_max; i++) {
+		set.insert(i);
+	}
+
+	//insert order should have been kept
+	int idx = 0;
+	for (const int &K : set) {
+		CHECK(idx == K);
+		CHECK(set.has(idx));
+		idx++;
+	}
+
+	Vector<int> elems_still_valid;
+
+	for (int i = 0; i < elem_max; i++) {
+		if ((i % 5) == 0) {
+			set.erase(i);
+		} else {
+			elems_still_valid.push_back(i);
+		}
+	}
+
+	CHECK(elems_still_valid.size() == set.size());
+
+	for (int i = 0; i < elems_still_valid.size(); i++) {
+		CHECK(set.has(elems_still_valid[i]));
+	}
+}
+
+TEST_CASE("[HashSet] Insert, iterate and remove many strings") {
+	// This tests a key that uses allocation, to see if any leaks occur
+
+	uint64_t pre_mem = Memory::get_mem_usage();
+	const int elem_max = 4018;
+	HashSet<String> set;
+	for (int i = 0; i < elem_max; i++) {
+		set.insert(itos(i));
+	}
+
+	//insert order should have been kept
+	int idx = 0;
+	for (const String &K : set) {
+		CHECK(itos(idx) == K);
+		CHECK(set.has(itos(idx)));
+		idx++;
+	}
+
+	Vector<String> elems_still_valid;
+
+	for (int i = 0; i < elem_max; i++) {
+		if ((i % 5) == 0) {
+			set.erase(itos(i));
+		} else {
+			elems_still_valid.push_back(itos(i));
+		}
+	}
+
+	CHECK(elems_still_valid.size() == set.size());
+
+	for (int i = 0; i < elems_still_valid.size(); i++) {
+		CHECK(set.has(elems_still_valid[i]));
+	}
+
+	elems_still_valid.clear();
+	set.reset();
+
+	CHECK(Memory::get_mem_usage() == pre_mem);
+}
+
+TEST_CASE("[HashSet] Erase via element") {
+	HashSet<int> set;
+	HashSet<int>::Iterator e = set.insert(42);
+	set.remove(e);
+	CHECK(!set.has(42));
+	CHECK(!set.find(42));
+}
+
+TEST_CASE("[HashSet] Erase via key") {
+	HashSet<int> set;
+	set.insert(42);
+	set.insert(49);
+	set.erase(42);
+	CHECK(!set.has(42));
+	CHECK(!set.find(42));
+}
+
+TEST_CASE("[HashSet] Insert and erase half elements") {
+	HashSet<int> set;
+	set.insert(1);
+	set.insert(2);
+	set.insert(3);
+	set.insert(4);
+	set.erase(1);
+	set.erase(3);
+
+	CHECK(set.size() == 2);
+	CHECK(set.has(2));
+	CHECK(set.has(4));
+}
+
+TEST_CASE("[HashSet] Size") {
+	HashSet<int> set;
+	set.insert(42);
+	set.insert(123);
+	set.insert(123);
+	set.insert(0);
+	set.insert(123485);
+
+	CHECK(set.size() == 4);
+}
+
+TEST_CASE("[HashSet] Iteration") {
+	HashSet<int> set;
+	set.insert(42);
+	set.insert(123);
+	set.insert(0);
+	set.insert(123485);
+
+	Vector<int> expected;
+	expected.push_back(42);
+	expected.push_back(123);
+	expected.push_back(0);
+	expected.push_back(123485);
+
+	int idx = 0;
+	for (const int &E : set) {
+		CHECK(expected[idx] == E);
+		++idx;
+	}
+}
+
+TEST_CASE("[HashSet] Copy") {
+	HashSet<int> set;
+	set.insert(42);
+	set.insert(123);
+	set.insert(0);
+	set.insert(123485);
+
+	Vector<int> expected;
+	expected.push_back(42);
+	expected.push_back(123);
+	expected.push_back(0);
+	expected.push_back(123485);
+
+	HashSet<int> copy_assign = set;
+
+	int idx = 0;
+	for (const int &E : copy_assign) {
+		CHECK(expected[idx] == E);
+		++idx;
+	}
+
+	HashSet<int> copy_construct(set);
+
+	idx = 0;
+	for (const int &E : copy_construct) {
+		CHECK(expected[idx] == E);
+		++idx;
+	}
+}
+
+} // namespace TestHashSet
+
+#endif // TEST_HASH_MAP_H
diff --git a/tests/test_main.cpp b/tests/test_main.cpp
index a5f6fb9b88..ac0cdf0cc1 100644
--- a/tests/test_main.cpp
+++ b/tests/test_main.cpp
@@ -60,6 +60,7 @@
 #include "tests/core/string/test_translation.h"
 #include "tests/core/templates/test_command_queue.h"
 #include "tests/core/templates/test_hash_map.h"
+#include "tests/core/templates/test_hash_set.h"
 #include "tests/core/templates/test_list.h"
 #include "tests/core/templates/test_local_vector.h"
 #include "tests/core/templates/test_lru.h"
author	reduz <reduzio@gmail.com>	2022-05-19 17:00:06 +0200
committer	reduz <reduzio@gmail.com>	2022-05-20 22:40:38 +0200
commit	45af29da8095af16729955117a165d23e77cd740 (patch)
tree	0436c59187702466a73d05caf9688a58e5935afd
parent	410893ad0fb6f0d7d774b6529581d886defd6cf0 (diff)