diff --git a/core/config/project_settings.cpp b/core/config/project_settings.cpp
index 8f3577290fc..d6ec6634299 100644
--- a/core/config/project_settings.cpp
+++ b/core/config/project_settings.cpp
@@ -1627,6 +1627,7 @@ ProjectSettings::ProjectSettings() {
 
 	GLOBAL_DEF(PropertyInfo(Variant::INT, "debug/settings/profiler/max_functions", PROPERTY_HINT_RANGE, "128,65535,1"), 16384);
 	GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "debug/settings/profiler/max_timestamp_query_elements", PROPERTY_HINT_RANGE, "256,65535,1"), 256);
+	GLOBAL_DEF("debug/gdscript/warnings/show_experimental_trait_warning", true); // @todo: remove experimental tag in 27.1-rc.1
 
 	GLOBAL_DEF(PropertyInfo(Variant::BOOL, "compression/formats/zstd/long_distance_matching"), Compression::zstd_long_distance_matching);
 	GLOBAL_DEF(PropertyInfo(Variant::INT, "compression/formats/zstd/compression_level", PROPERTY_HINT_RANGE, "1,22,1"), Compression::zstd_level);
diff --git a/core/core_bind.cpp b/core/core_bind.cpp
index b498cb8c3b4..554889d6ac4 100644
--- a/core/core_bind.cpp
+++ b/core/core_bind.cpp
@@ -1586,14 +1586,16 @@ namespace Special {
 ////// ClassDB //////
 
 PackedStringArray ClassDB::get_class_list() const {
-	List<StringName> classes;
-	::ClassDB::get_class_list(&classes);
+	LocalVector<StringName> classes;
+	::ClassDB::get_class_list(classes);
 
 	PackedStringArray ret;
 	ret.resize(classes.size());
+	String *ptrw = ret.ptrw();
 	int idx = 0;
-	for (const StringName &E : classes) {
-		ret.set(idx++, E);
+	for (const StringName &cls : classes) {
+		ptrw[idx] = cls;
+		idx++;
 	}
 
 	return ret;
diff --git a/core/debugger/remote_debugger.cpp b/core/debugger/remote_debugger.cpp
index bd5a278f6c7..795e06559c2 100644
--- a/core/debugger/remote_debugger.cpp
+++ b/core/debugger/remote_debugger.cpp
@@ -571,25 +571,25 @@ void RemoteDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) {
 					input_vals.append(V);
 				}
 
-				List<StringName> native_types;
-				ClassDB::get_class_list(&native_types);
-				for (const StringName &E : native_types) {
-					if (!ClassDB::is_class_exposed(E) || !Engine::get_singleton()->has_singleton(E) || Engine::get_singleton()->is_singleton_editor_only(E)) {
+				LocalVector<StringName> native_types;
+				ClassDB::get_class_list(native_types);
+				for (const StringName &class_name : native_types) {
+					if (!ClassDB::is_class_exposed(class_name) || !Engine::get_singleton()->has_singleton(class_name) || Engine::get_singleton()->is_singleton_editor_only(class_name)) {
 						continue;
 					}
 
-					input_names.append(E);
-					input_vals.append(Engine::get_singleton()->get_singleton_object(E));
+					input_names.append(class_name);
+					input_vals.append(Engine::get_singleton()->get_singleton_object(class_name));
 				}
 
-				List<StringName> user_types;
-				ScriptServer::get_global_class_list(&user_types);
-				for (const StringName &S : user_types) {
-					String scr_path = ScriptServer::get_global_class_path(S);
+				LocalVector<StringName> user_types;
+				ScriptServer::get_global_class_list(user_types);
+				for (const StringName &class_name : user_types) {
+					String scr_path = ScriptServer::get_global_class_path(class_name);
 					Ref<Script> scr = ResourceLoader::load(scr_path, "Script");
-					ERR_CONTINUE_MSG(scr.is_null(), vformat(R"(Could not load the global class %s from resource path: "%s".)", S, scr_path));
+					ERR_CONTINUE_MSG(scr.is_null(), vformat(R"(Could not load the global class %s from resource path: "%s".)", class_name, scr_path));
 
-					input_names.append(S);
+					input_names.append(class_name);
 					input_vals.append(scr);
 				}
 
diff --git a/core/extension/extension_api_dump.cpp b/core/extension/extension_api_dump.cpp
index 1d79ee17f59..5bd7747bace 100644
--- a/core/extension/extension_api_dump.cpp
+++ b/core/extension/extension_api_dump.cpp
@@ -931,11 +931,9 @@ Dictionary GDExtensionAPIDump::generate_extension_api(bool p_include_docs) {
 		// classes
 		Array classes;
 
-		List<StringName> class_list;
+		LocalVector<StringName> class_list;
 
-		ClassDB::get_class_list(&class_list);
-
-		class_list.sort_custom<StringName::AlphCompare>();
+		ClassDB::get_class_list(class_list);
 
 		for (const StringName &class_name : class_list) {
 			if (!ClassDB::is_class_exposed(class_name)) {
diff --git a/core/io/resource_loader.cpp b/core/io/resource_loader.cpp
index b012d8b5a09..ad630bfd367 100644
--- a/core/io/resource_loader.cpp
+++ b/core/io/resource_loader.cpp
@@ -1492,8 +1492,8 @@ void ResourceLoader::set_create_missing_resources_if_class_unavailable(bool p_en
 void ResourceLoader::add_custom_loaders() {
 	String custom_loader_base_class = ResourceFormatLoader::get_class_static();
 
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
 
 	for (const StringName &class_name : global_classes) {
 		StringName base_class = ScriptServer::get_global_class_native_base(class_name);
diff --git a/core/io/resource_saver.cpp b/core/io/resource_saver.cpp
index f3f0f86b7f4..776e0c60741 100644
--- a/core/io/resource_saver.cpp
+++ b/core/io/resource_saver.cpp
@@ -261,8 +261,8 @@ bool ResourceSaver::add_custom_resource_format_saver(const String &script_path)
 void ResourceSaver::add_custom_savers() {
 	String custom_saver_base_class = ResourceFormatSaver::get_class_static();
 
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
 
 	for (const StringName &class_name : global_classes) {
 		StringName base_class = ScriptServer::get_global_class_native_base(class_name);
diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp
index 081de067496..3738287ca41 100644
--- a/core/object/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -41,6 +41,7 @@
 #include "core/config/engine.h"
 #include "core/io/resource_loader.h"
 #include "core/object/script_language.h"
+#include "core/templates/sort_array.h"
 #include "core/version.h"
 
 #ifdef DEBUG_ENABLED
@@ -248,28 +249,46 @@ bool ClassDB::is_parent_class(const StringName &p_class, const StringName &p_inh
 	return _is_parent_class(p_class, p_inherits);
 }
 
-void ClassDB::get_class_list(List<StringName> *p_classes) {
+// This function only sorts items added by this function.
+// If `p_classes` is not empty before calling and a global sort is needed, caller must handle that separately.
+void ClassDB::get_class_list(LocalVector<StringName> &p_classes) {
 	Locker::Lock lock(Locker::STATE_READ);
 
-	for (const KeyValue<StringName, ClassInfo> &E : classes) {
-		p_classes->push_back(E.key);
+	if (classes.is_empty()) {
+		return;
 	}
 
-	p_classes->sort_custom<StringName::AlphCompare>();
+	p_classes.reserve(p_classes.size() + classes.size());
+	for (const KeyValue<StringName, ClassInfo> &cls : classes) {
+		p_classes.push_back(cls.key);
+	}
+
+	SortArray<StringName, StringName::AlphCompare> sorter;
+	sorter.sort(&p_classes[p_classes.size() - classes.size()], classes.size());
 }
 
 #ifdef TOOLS_ENABLED
-void ClassDB::get_extensions_class_list(List<StringName> *p_classes) {
+// This function only sorts items added by this function.
+// If `p_classes` is not empty before calling and a global sort is needed, caller must handle that separately.
+void ClassDB::get_extensions_class_list(LocalVector<StringName> &p_classes) {
 	Locker::Lock lock(Locker::STATE_READ);
 
+	uint32_t original_size = p_classes.size();
+
 	for (const KeyValue<StringName, ClassInfo> &E : classes) {
 		if (E.value.api != API_EXTENSION && E.value.api != API_EDITOR_EXTENSION) {
 			continue;
 		}
-		p_classes->push_back(E.key);
+		p_classes.push_back(E.key);
 	}
 
-	p_classes->sort_custom<StringName::AlphCompare>();
+	// Nothing appended.
+	if (p_classes.size() == original_size) {
+		return;
+	}
+
+	SortArray<StringName, StringName::AlphCompare> sorter;
+	sorter.sort(&p_classes[original_size], p_classes.size() - original_size);
 }
 
 void ClassDB::get_extension_class_list(const Ref<GDExtension> &p_extension, List<StringName> *p_classes) {
diff --git a/core/object/class_db.h b/core/object/class_db.h
index ad4a9a12f40..f7878124c13 100644
--- a/core/object/class_db.h
+++ b/core/object/class_db.h
@@ -319,9 +319,9 @@ class ClassDB {
 		T::register_custom_data_to_otdb();
 	}
 
-	static void get_class_list(List<StringName> *p_classes);
+	static void get_class_list(LocalVector<StringName> &p_classes);
 #ifdef TOOLS_ENABLED
-	static void get_extensions_class_list(List<StringName> *p_classes);
+	static void get_extensions_class_list(LocalVector<StringName> &p_classes);
 	static void get_extension_class_list(const Ref<GDExtension> &p_extension, List<StringName> *p_classes);
 	static ObjectGDExtension *get_placeholder_extension(const StringName &p_class);
 #endif
diff --git a/core/object/script_language.cpp b/core/object/script_language.cpp
index 37601f1b6cf..e8ddab47d42 100644
--- a/core/object/script_language.cpp
+++ b/core/object/script_language.cpp
@@ -43,6 +43,7 @@
 #include "core/debugger/engine_debugger.h"
 #include "core/debugger/script_debugger.h"
 #include "core/io/resource_loader.h"
+#include "core/templates/sort_array.h"
 
 ScriptLanguage *ScriptServer::_languages[MAX_LANGUAGES];
 int ScriptServer::_language_count = 0;
@@ -515,15 +516,18 @@ bool ScriptServer::is_global_class_tool(const String &p_class) {
 	return global_classes[p_class].is_tool;
 }
 
-void ScriptServer::get_global_class_list(List<StringName> *r_global_classes) {
-	List<StringName> classes;
-	for (const KeyValue<StringName, GlobalScriptClass> &E : global_classes) {
-		classes.push_back(E.key);
+// This function only sorts items added by this function.
+// If `r_global_classes` is not empty before calling and a global sort is needed, caller must handle that separately.
+void ScriptServer::get_global_class_list(LocalVector<StringName> &r_global_classes) {
+	if (global_classes.is_empty()) {
+		return;
 	}
-	classes.sort_custom<StringName::AlphCompare>();
-	for (const StringName &E : classes) {
-		r_global_classes->push_back(E);
+	r_global_classes.reserve(r_global_classes.size() + global_classes.size());
+	for (const KeyValue<StringName, GlobalScriptClass> &global_class : global_classes) {
+		r_global_classes.push_back(global_class.key);
 	}
+	SortArray<StringName, StringName::AlphCompare> sorter;
+	sorter.sort(&r_global_classes[r_global_classes.size() - global_classes.size()], global_classes.size());
 }
 
 void ScriptServer::save_global_classes() {
@@ -538,17 +542,17 @@ void ScriptServer::save_global_classes() {
 		class_icons[d["name"]] = d["icon"];
 	}
 
-	List<StringName> gc;
-	get_global_class_list(&gc);
+	LocalVector<StringName> gc;
+	get_global_class_list(gc);
 	Array gcarr;
-	for (const StringName &E : gc) {
-		const GlobalScriptClass &global_class = global_classes[E];
+	for (const StringName &class_name : gc) {
+		const GlobalScriptClass &global_class = global_classes[class_name];
 		Dictionary d;
-		d["class"] = E;
+		d["class"] = class_name;
 		d["language"] = global_class.language;
 		d["path"] = global_class.path;
 		d["base"] = global_class.base;
-		d["icon"] = class_icons.get(E, "");
+		d["icon"] = class_icons.get(class_name, "");
 		d["is_abstract"] = global_class.is_abstract;
 		d["is_tool"] = global_class.is_tool;
 		gcarr.push_back(d);
diff --git a/core/object/script_language.h b/core/object/script_language.h
index e7cff1d1e6c..f657cfd52b5 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -106,7 +106,7 @@ class ScriptServer {
 	static StringName get_global_class_native_base(const String &p_class);
 	static bool is_global_class_abstract(const String &p_class);
 	static bool is_global_class_tool(const String &p_class);
-	static void get_global_class_list(List<StringName> *r_global_classes);
+	static void get_global_class_list(LocalVector<StringName> &r_global_classes);
 	static void get_inheriters_list(const StringName &p_base_type, List<StringName> *r_classes);
 	static void save_global_classes();
 
diff --git a/doc/classes/ProjectSettings.xml b/doc/classes/ProjectSettings.xml
index b6862b7808b..cbcd35f7335 100644
--- a/doc/classes/ProjectSettings.xml
+++ b/doc/classes/ProjectSettings.xml
@@ -556,6 +556,9 @@
 		<member name="debug/gdscript/warnings/exclude_addons" type="bool" setter="" getter="" default="true">
 			If [code]true[/code], scripts in the [code]res://addons[/code] folder will not generate warnings.
 		</member>
+		<member name="debug/gdscript/warnings/experimental_trait" type="int" setter="" getter="" default="1">
+			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when using traits, as they are still experimental and may be subject to changes in future releases.
+		</member>
 		<member name="debug/gdscript/warnings/get_node_default_without_onready" type="int" setter="" getter="" default="2">
 			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when [method Node.get_node] (or the shorthand [code]$[/code]) is used as default value of a class variable without the [code]@onready[/code] annotation.
 		</member>
@@ -611,6 +614,9 @@
 		<member name="debug/gdscript/warnings/shadowed_variable_base_class" type="int" setter="" getter="" default="1">
 			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when a local variable or local constant shadows a member declared in a base class.
 		</member>
+		<member name="debug/gdscript/warnings/show_experimental_trait_warning" type="bool" setter="" getter="" default="true">
+			When set to [code]true[/code], the editor will generate warnings when using traits, as they are still experimental and may be subject to changes in future releases.
+		</member>
 		<member name="debug/gdscript/warnings/standalone_expression" type="int" setter="" getter="" default="1">
 			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when calling an expression that may have no effect on the surrounding code, such as writing [code]2 + 2[/code] as a statement.
 		</member>
@@ -663,6 +669,9 @@
 		<member name="debug/gdscript/warnings/unused_signal" type="int" setter="" getter="" default="1">
 			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when a signal is declared but never explicitly used in the class.
 		</member>
+		<member name="debug/gdscript/warnings/unused_static_overriding_trait" type="int" setter="" getter="" default="1">
+			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when an overridden static member from a trait is not declared with the [code]static[/code] keyword.
+		</member>
 		<member name="debug/gdscript/warnings/unused_variable" type="int" setter="" getter="" default="1">
 			When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when a local variable is unused.
 		</member>
diff --git a/editor/doc/doc_tools.cpp b/editor/doc/doc_tools.cpp
index 03c1574f7ba..cc7dfd972d0 100644
--- a/editor/doc/doc_tools.cpp
+++ b/editor/doc/doc_tools.cpp
@@ -413,23 +413,23 @@ void DocTools::generate(BitField<GenerateFlags> p_flags) {
 
 	// Add ClassDB-exposed classes.
 	{
-		List<StringName> classes;
+		LocalVector<StringName> classes;
 		if (p_flags.has_flag(GENERATE_FLAG_EXTENSION_CLASSES_ONLY)) {
-			ClassDB::get_extensions_class_list(&classes);
+			ClassDB::get_extensions_class_list(classes);
 		} else {
-			ClassDB::get_class_list(&classes);
+			ClassDB::get_class_list(classes);
 			// Move ProjectSettings, so that other classes can register properties there.
-			classes.move_to_back(classes.find("ProjectSettings"));
+			classes.erase("ProjectSettings");
+			classes.push_back("ProjectSettings");
 		}
 
 		bool skip_setter_getter_methods = true;
 
 		// Populate documentation data for each exposed class.
-		while (classes.size()) {
-			const String &name = classes.front()->get();
+		for (uint32_t classes_idx = 0; classes_idx < classes.size(); classes_idx++) {
+			const String &name = classes[classes_idx];
 			if (!ClassDB::is_class_exposed(name)) {
 				print_verbose(vformat("Class '%s' is not exposed, skipping.", name));
-				classes.pop_front();
 				continue;
 			}
 
@@ -734,8 +734,6 @@ void DocTools::generate(BitField<GenerateFlags> p_flags) {
 
 				c.theme_properties.sort();
 			}
-
-			classes.pop_front();
 		}
 	}
 
diff --git a/editor/editor_data.cpp b/editor/editor_data.cpp
index 555afbcc448..791d89b4950 100644
--- a/editor/editor_data.cpp
+++ b/editor/editor_data.cpp
@@ -1053,8 +1053,8 @@ void EditorData::script_class_set_name(const String &p_path, const StringName &p
 }
 
 void EditorData::script_class_save_global_classes() {
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
 	Array array_classes;
 	for (const StringName &class_name : global_classes) {
 		Dictionary d;
diff --git a/editor/file_system/editor_file_system.cpp b/editor/file_system/editor_file_system.cpp
index 02337870063..94adfc4695e 100644
--- a/editor/file_system/editor_file_system.cpp
+++ b/editor/file_system/editor_file_system.cpp
@@ -1657,9 +1657,9 @@ void EditorFileSystem::_thread_func_sources(void *_userdata) {
 }
 
 bool EditorFileSystem::_remove_invalid_global_class_names(const HashSet<String> &p_existing_class_names) {
-	List<StringName> global_classes;
+	LocalVector<StringName> global_classes;
 	bool must_save = false;
-	ScriptServer::get_global_class_list(&global_classes);
+	ScriptServer::get_global_class_list(global_classes);
 	for (const StringName &class_name : global_classes) {
 		if (!p_existing_class_names.has(class_name)) {
 			ScriptServer::remove_global_class(class_name);
diff --git a/editor/gui/create_dialog.cpp b/editor/gui/create_dialog.cpp
index 9cd8e50d5ab..8f53a6047fd 100644
--- a/editor/gui/create_dialog.cpp
+++ b/editor/gui/create_dialog.cpp
@@ -89,9 +89,9 @@ void CreateDialog::for_inherit() {
 }
 
 void CreateDialog::_fill_type_list() {
-	List<StringName> complete_type_list;
-	ClassDB::get_class_list(&complete_type_list);
-	ScriptServer::get_global_class_list(&complete_type_list);
+	LocalVector<StringName> complete_type_list;
+	ClassDB::get_class_list(complete_type_list);
+	ScriptServer::get_global_class_list(complete_type_list);
 
 	EditorData &ed = EditorNode::get_editor_data();
 	HashMap<String, DocData::ClassDoc> &class_docs_list = EditorHelp::get_doc_data()->class_list;
diff --git a/editor/project_upgrade/project_converter_3_to_4.cpp b/editor/project_upgrade/project_converter_3_to_4.cpp
index 92895a90118..8ef2ba32a94 100644
--- a/editor/project_upgrade/project_converter_3_to_4.cpp
+++ b/editor/project_upgrade/project_converter_3_to_4.cpp
@@ -1193,8 +1193,8 @@ bool ProjectConverter3To4::test_array_names() {
 		//	}
 		//}
 
-		List<StringName> classes_list;
-		ClassDB::get_class_list(&classes_list);
+		LocalVector<StringName> classes_list;
+		ClassDB::get_class_list(classes_list);
 		for (StringName &name_of_class : classes_list) {
 			List<MethodInfo> method_list;
 			ClassDB::get_method_list(name_of_class, &method_list, true);
diff --git a/editor/script/script_editor_plugin.cpp b/editor/script/script_editor_plugin.cpp
index d5a748a0ad4..75eff8aba15 100644
--- a/editor/script/script_editor_plugin.cpp
+++ b/editor/script/script_editor_plugin.cpp
@@ -133,18 +133,18 @@ void EditorStandardSyntaxHighlighter::_update_cache() {
 
 	/* Engine types. */
 	const Color type_color = EDITOR_GET("text_editor/theme/highlighting/engine_type_color");
-	List<StringName> types;
-	ClassDB::get_class_list(&types);
-	for (const StringName &E : types) {
-		highlighter->add_keyword_color(E, type_color);
+	LocalVector<StringName> types;
+	ClassDB::get_class_list(types);
+	for (const StringName &type : types) {
+		highlighter->add_keyword_color(type, type_color);
 	}
 
 	/* User types. */
 	const Color usertype_color = EDITOR_GET("text_editor/theme/highlighting/user_type_color");
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
-	for (const StringName &E : global_classes) {
-		highlighter->add_keyword_color(E, usertype_color);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
+	for (const StringName &class_name : global_classes) {
+		highlighter->add_keyword_color(class_name, usertype_color);
 	}
 
 	/* Autoloads. */
diff --git a/editor/settings/editor_build_profile.cpp b/editor/settings/editor_build_profile.cpp
index dd158e1c064..a7d5e8d7794 100644
--- a/editor/settings/editor_build_profile.cpp
+++ b/editor/settings/editor_build_profile.cpp
@@ -950,20 +950,20 @@ void EditorBuildProfileManager::_detect_from_project() {
 
 	edited->clear_disabled_classes();
 
-	List<StringName> all_classes;
-	ClassDB::get_class_list(&all_classes);
+	LocalVector<StringName> all_classes;
+	ClassDB::get_class_list(all_classes);
 
-	for (const StringName &E : all_classes) {
-		if (String(E).begins_with("Editor") || ClassDB::get_api_type(E) != ClassDB::API_CORE || all_used_classes.has(E)) {
+	for (const StringName &class_name : all_classes) {
+		if (String(class_name).begins_with("Editor") || ClassDB::get_api_type(class_name) != ClassDB::API_CORE || all_used_classes.has(class_name)) {
 			// This class is valid or editor-only, do nothing.
 			continue;
 		}
 
-		StringName p = ClassDB::get_parent_class(E);
+		StringName p = ClassDB::get_parent_class(class_name);
 		if (!p || all_used_classes.has(p)) {
 			// If no parent, or if the parent is enabled, then add to disabled classes.
 			// This way we avoid disabling redundant classes.
-			edited->set_disable_class(E, true);
+			edited->set_disable_class(class_name, true);
 		}
 	}
 
diff --git a/editor/shader/visual_shader_editor_plugin.cpp b/editor/shader/visual_shader_editor_plugin.cpp
index e5911d8d105..1c3debf4e48 100644
--- a/editor/shader/visual_shader_editor_plugin.cpp
+++ b/editor/shader/visual_shader_editor_plugin.cpp
@@ -2166,12 +2166,12 @@ void VisualShaderEditor::_update_nodes() {
 
 	// Add GDScript classes.
 	{
-		List<StringName> class_list;
-		ScriptServer::get_global_class_list(&class_list);
+		LocalVector<StringName> class_list;
+		ScriptServer::get_global_class_list(class_list);
 
-		for (const StringName &E : class_list) {
-			if (ScriptServer::get_global_class_native_base(E) == "VisualShaderNodeCustom") {
-				String script_path = ScriptServer::get_global_class_path(E);
+		for (const StringName &class_name : class_list) {
+			if (ScriptServer::get_global_class_native_base(class_name) == "VisualShaderNodeCustom") {
+				String script_path = ScriptServer::get_global_class_path(class_name);
 				Ref<Resource> res = ResourceLoader::load(script_path);
 				ERR_CONTINUE(res.is_null());
 				ERR_CONTINUE(!res->is_class("Script"));
@@ -2196,19 +2196,19 @@ void VisualShaderEditor::_update_nodes() {
 
 	// Add GDExtension classes.
 	{
-		List<StringName> class_list;
-		ClassDB::get_class_list(&class_list);
+		LocalVector<StringName> class_list;
+		ClassDB::get_class_list(class_list);
 
-		for (const StringName &E : class_list) {
-			if (ClassDB::get_parent_class(E) == "VisualShaderNodeCustom") {
-				Object *instance = ClassDB::instantiate(E);
+		for (const StringName &class_name : class_list) {
+			if (ClassDB::get_parent_class(class_name) == "VisualShaderNodeCustom") {
+				Object *instance = ClassDB::instantiate(class_name);
 				Ref<VisualShaderNodeCustom> ref = Object::cast_to<VisualShaderNodeCustom>(instance);
 				ERR_CONTINUE(ref.is_null());
 				if (!ref->is_available(visual_shader->get_mode(), get_current_shader_type())) {
 					continue;
 				}
 				Dictionary dict = get_custom_node_data(ref);
-				dict["type"] = E;
+				dict["type"] = class_name;
 				dict["script"] = Ref<Script>();
 
 				String key;
diff --git a/modules/gdscript/editor/gdscript_docgen.cpp b/modules/gdscript/editor/gdscript_docgen.cpp
index a17371d143f..430afefe9b5 100644
--- a/modules/gdscript/editor/gdscript_docgen.cpp
+++ b/modules/gdscript/editor/gdscript_docgen.cpp
@@ -132,6 +132,7 @@ void GDScriptDocGen::_doctype_from_gdtype(const GDType &p_gdtype, String &r_type
 			}
 			r_type = "Object";
 			return;
+		case GDType::TRAIT:
 		case GDType::CLASS:
 			if (p_gdtype.is_meta_type) {
 				r_type = GDScript::get_class_static();
@@ -377,6 +378,10 @@ void GDScriptDocGen::_generate_docs(GDScript *p_script, const GDP::ClassNode *p_
 	for (const GDP::ClassNode::Member &member : p_class->members) {
 		switch (member.type) {
 			case GDP::ClassNode::Member::CLASS: {
+				if (p_class->type == GDP::Node::TRAIT) {
+					// Trait do not have scripts for their inner classes.
+					continue;
+				}
 				const GDP::ClassNode *inner_class = member.m_class;
 				const StringName &class_name = inner_class->identifier->name;
 
diff --git a/modules/gdscript/editor/gdscript_highlighter.cpp b/modules/gdscript/editor/gdscript_highlighter.cpp
index c5cda96b2d8..eb1dac3158f 100644
--- a/modules/gdscript/editor/gdscript_highlighter.cpp
+++ b/modules/gdscript/editor/gdscript_highlighter.cpp
@@ -723,11 +723,11 @@ void GDScriptSyntaxHighlighter::_update_cache() {
 
 	/* Engine types. */
 	const Color types_color = EDITOR_GET("text_editor/theme/highlighting/engine_type_color");
-	List<StringName> types;
-	ClassDB::get_class_list(&types);
-	for (const StringName &E : types) {
-		if (ClassDB::is_class_exposed(E)) {
-			class_names[E] = types_color;
+	LocalVector<StringName> types;
+	ClassDB::get_class_list(types);
+	for (const StringName &type : types) {
+		if (ClassDB::is_class_exposed(type)) {
+			class_names[type] = types_color;
 		}
 	}
 
@@ -740,10 +740,10 @@ void GDScriptSyntaxHighlighter::_update_cache() {
 
 	/* User types. */
 	const Color usertype_color = EDITOR_GET("text_editor/theme/highlighting/user_type_color");
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
-	for (const StringName &E : global_classes) {
-		class_names[E] = usertype_color;
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
+	for (const StringName &class_name : global_classes) {
+		class_names[class_name] = usertype_color;
 	}
 
 	/* Autoloads. */
diff --git a/modules/gdscript/editor/gdscript_translation_parser_plugin.cpp b/modules/gdscript/editor/gdscript_translation_parser_plugin.cpp
index c2e0dede7ed..914a7a5496e 100644
--- a/modules/gdscript/editor/gdscript_translation_parser_plugin.cpp
+++ b/modules/gdscript/editor/gdscript_translation_parser_plugin.cpp
@@ -147,6 +147,7 @@ void GDScriptEditorTranslationParserPlugin::_traverse_class(const GDScriptParser
 		const GDScriptParser::ClassNode::Member &m = p_class->members[i];
 		// Other member types can't contain translatable strings.
 		switch (m.type) {
+			case GDScriptParser::ClassNode::Member::TRAIT:
 			case GDScriptParser::ClassNode::Member::CLASS:
 				_traverse_class(m.m_class);
 				break;
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 307cdf638d0..5ab46be4c04 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -2276,14 +2276,14 @@ void GDScriptLanguage::init() {
 
 	//populate native classes
 
-	List<StringName> class_list;
-	ClassDB::get_class_list(&class_list);
-	for (const StringName &n : class_list) {
-		if (globals.has(n)) {
+	LocalVector<StringName> class_list;
+	ClassDB::get_class_list(class_list);
+	for (const StringName &class_name : class_list) {
+		if (globals.has(class_name)) {
 			continue;
 		}
-		Ref<GDScriptNativeClass> nc = memnew(GDScriptNativeClass(n));
-		_add_global(n, nc);
+		Ref<GDScriptNativeClass> nc = memnew(GDScriptNativeClass(class_name));
+		_add_global(class_name, nc);
 	}
 
 	//populate singletons
@@ -2769,7 +2769,9 @@ Vector<String> GDScriptLanguage::get_reserved_words() const {
 		"namespace", // Reserved for potential future use.
 		"signal",
 		"static",
-		"trait", // Reserved for potential future use.
+		"trait",
+		"trait_name",
+		"uses",
 		"var",
 		// Other keywords.
 		"await",
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index 4864d110cb2..e17629c57cd 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -196,6 +196,7 @@ class GDScript : public Script {
 	StringName global_name; ///< `class_name`.
 	String fully_qualified_name;
 	String simplified_icon_path;
+	Vector<StringName> traits_fqtn; // Fully-qualified trait names used by script.
 	SelfList<GDScript> script_list;
 
 	SelfList<GDScriptFunctionState>::List pending_func_states;
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 176afa7651f..a677b1a54cb 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -246,6 +246,7 @@ bool GDScriptAnalyzer::has_member_name_conflict_in_script_class(const StringName
 				member->type == GDScriptParser::ClassNode::Member::CONSTANT ||
 				member->type == GDScriptParser::ClassNode::Member::ENUM ||
 				member->type == GDScriptParser::ClassNode::Member::ENUM_VALUE ||
+				member->type == GDScriptParser::ClassNode::Member::TRAIT ||
 				member->type == GDScriptParser::ClassNode::Member::CLASS ||
 				member->type == GDScriptParser::ClassNode::Member::SIGNAL) {
 			return true;
@@ -297,7 +298,7 @@ Error GDScriptAnalyzer::check_native_member_name_conflict(const StringName &p_me
 Error GDScriptAnalyzer::check_class_member_name_conflict(const GDScriptParser::ClassNode *p_class_node, const StringName &p_member_name, const GDScriptParser::Node *p_member_node) {
 	/// @todo Check outer classes for static members only
 	const GDScriptParser::DataType *current_data_type = &p_class_node->base_type;
-	while (current_data_type && current_data_type->kind == GDScriptParser::DataType::Kind::CLASS) {
+	while (current_data_type && (current_data_type->kind == GDScriptParser::DataType::Kind::CLASS || current_data_type->kind == GDScriptParser::DataType::TRAIT)) {
 		GDScriptParser::ClassNode *current_class_node = current_data_type->class_type;
 		if (has_member_name_conflict_in_script_class(p_member_name, current_class_node, p_member_node)) {
 			String parent_class_name = current_class_node->fqcn;
@@ -399,6 +400,13 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 	GDScriptParser::ClassNode *previous_class = parser->current_class;
 	parser->current_class = p_class;
 
+	if (p_class->type == GDScriptParser::Node::TRAIT) {
+		_warn_experimental_trait(p_class);
+		if (p_class->identifier != nullptr) {
+			_warn_experimental_trait(p_class->identifier);
+		}
+	}
+
 	if (p_class->identifier) {
 		StringName class_name = p_class->identifier->name;
 		if (GDScriptParser::get_builtin_type(class_name) < Variant::VARIANT_MAX) {
@@ -422,11 +430,15 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 	class_type.is_meta_type = true;
 	class_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
 	class_type.kind = GDScriptParser::DataType::CLASS;
+	if (p_class->type == GDScriptParser::Node::TRAIT) {
+		class_type.kind = GDScriptParser::DataType::TRAIT;
+	}
 	class_type.class_type = p_class;
 	class_type.script_path = parser->script_path;
 	class_type.builtin_type = Variant::OBJECT;
 	p_class->set_datatype(class_type);
 
+	Ref<GDScriptParserRef> ext_parser_ref;
 	GDScriptParser::DataType result;
 	if (!p_class->extends_used) {
 		result.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
@@ -462,6 +474,7 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 			}
 #endif // DEBUG_ENABLED
 
+			ext_parser_ref = ext_parser;
 			base = ext_parser->get_parser()->head->get_datatype();
 		} else {
 			if (p_class->extends.is_empty()) {
@@ -496,6 +509,7 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 					}
 #endif // DEBUG_ENABLED
 
+					ext_parser_ref = base_parser;
 					base = base_parser->get_parser()->head->get_datatype();
 				}
 			} else if (ProjectSettings::get_singleton()->has_autoload(name) && ProjectSettings::get_singleton()->get_autoload(name).is_singleton) {
@@ -523,6 +537,7 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 				}
 #endif // DEBUG_ENABLED
 
+				ext_parser_ref = info_parser;
 				base = info_parser->get_parser()->head->get_datatype();
 			} else if (class_exists(name)) {
 				if (Engine::get_singleton()->has_singleton(name)) {
@@ -557,6 +572,9 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 						switch (member.type) {
 							case GDScriptParser::ClassNode::Member::CLASS:
 								break; // OK.
+							case GDScriptParser::ClassNode::Member::TRAIT:
+								push_error(vformat(R"(Could not inherit from trait "%s".)", name), id);
+								return ERR_PARSE_ERROR;
 							case GDScriptParser::ClassNode::Member::CONSTANT:
 								if (member_datatype.kind != GDScriptParser::DataType::SCRIPT && member_datatype.kind != GDScriptParser::DataType::CLASS) {
 									push_error(vformat(R"(Constant "%s" is not a preloaded script or class.)", name), id);
@@ -612,6 +630,12 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 		return ERR_PARSE_ERROR;
 	}
 
+	// Check if inherits trait Script.
+	if (result.kind == GDScriptParser::DataType::TRAIT) {
+		push_error("Could not inherit from trait.", p_class);
+		return ERR_PARSE_ERROR;
+	}
+
 	// Check for cyclic inheritance.
 	const GDScriptParser::ClassNode *base_class = result.class_type;
 	while (base_class) {
@@ -634,6 +658,33 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 
 	parser->current_class = previous_class;
 
+	// Copy over used traits_fqtn since it is also inherited.
+	if (result.class_type) {
+		if (!result.class_type->resolved_uses) {
+			if (ext_parser_ref.is_null()) {
+				// Extending class in script.
+				resolve_class_uses(result.class_type);
+			} else {
+				GDScriptAnalyzer *ext_analyzer = ext_parser_ref->get_analyzer();
+				GDScriptParser *ext_parser = ext_parser_ref->get_parser();
+				int error_count = ext_parser->errors.size();
+				ext_analyzer->resolve_class_uses(result.class_type);
+				if (ext_parser->errors.size() > error_count) {
+					push_error("Could not resolve extending class.", p_class);
+					return ERR_PARSE_ERROR;
+				}
+			}
+		}
+		if (!result.class_type->resolved_uses && !result.class_type->resolving_uses) {
+			push_error("Could not resolve uses from extending class.", p_class);
+		}
+		for (String trait_fqtn : result.class_type->traits_fqtn) {
+			if (!p_class->traits_fqtn.has(trait_fqtn)) {
+				p_class->traits_fqtn.append(trait_fqtn);
+			}
+		}
+	}
+
 	return OK;
 }
 
@@ -645,11 +696,16 @@ Error GDScriptAnalyzer::resolve_class_inheritance(GDScriptParser::ClassNode *p_c
 
 	if (p_recursive) {
 		for (int i = 0; i < p_class->members.size(); i++) {
-			if (p_class->members[i].type == GDScriptParser::ClassNode::Member::CLASS) {
-				err = resolve_class_inheritance(p_class->members[i].m_class, true);
-				if (err) {
-					return err;
-				}
+			switch (p_class->members[i].type) {
+				case GDScriptParser::ClassNode::Member::TRAIT:
+				case GDScriptParser::ClassNode::Member::CLASS:
+					err = resolve_class_inheritance(p_class->members[i].m_class, true);
+					if (err) {
+						return err;
+					}
+					break;
+				default:
+					break;
 			}
 		}
 	}
@@ -666,7 +722,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 		return bad_type;
 	}
 
-	if (p_type->get_datatype().is_resolving()) {
+	if (p_type->get_datatype().is_resolving() && parser->head->type != GDScriptParser::Node::TRAIT) {
 		push_error(R"(Could not resolve datatype: Cyclic reference.)", p_type);
 		return bad_type;
 	}
@@ -709,7 +765,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				Ref<GDScript> gdscript = local.constant->initializer->reduced_value;
 				if (gdscript.is_valid()) {
 					Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(gdscript->get_script_path());
-					if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
+					if (ref->raise_status(GDScriptParserRef::USES_SOLVED) != OK) {
 						push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), first_id);
 						return bad_type;
 					}
@@ -800,7 +856,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				String ext = path.get_extension();
 				if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
 					Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(path);
-					if (ref.is_null() || ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
+					if (ref.is_null() || ref->raise_status(GDScriptParserRef::USES_SOLVED) != OK) {
 						push_error(vformat(R"(Could not parse global class "%s" from "%s".)", first, ScriptServer::get_global_class_path(first)), p_type);
 						return bad_type;
 					}
@@ -824,7 +880,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 						}
 					}
 				}
-			} else if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
+			} else if (ResourceLoader::get_resource_type(autoload.path) == "GDScript" || ResourceLoader::get_resource_type(autoload.path) == "GDScriptTrait") {
 				script_path = autoload.path;
 			}
 			if (script_path.is_empty()) {
@@ -835,7 +891,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 				push_error(vformat(R"(The referenced autoload "%s" (from "%s") could not be loaded.)", first, script_path), p_type);
 				return bad_type;
 			}
-			if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
+			if (ref->raise_status(GDScriptParserRef::USES_SOLVED) != OK) {
 				push_error(vformat(R"(Could not parse singleton "%s" from "%s".)", first, script_path), p_type);
 				return bad_type;
 			}
@@ -868,6 +924,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 
 					GDScriptParser::ClassNode::Member member = script_class->get_member(first);
 					switch (member.type) {
+						case GDScriptParser::ClassNode::Member::TRAIT:
 						case GDScriptParser::ClassNode::Member::CLASS:
 							result = member.get_datatype();
 							found = true;
@@ -885,7 +942,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 								Ref<GDScript> gdscript = member.constant->initializer->reduced_value;
 								if (gdscript.is_valid()) {
 									Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(gdscript->get_script_path());
-									if (ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) != OK) {
+									if (ref->raise_status(GDScriptParserRef::USES_SOLVED) != OK) {
 										push_error(vformat(R"(Could not parse script from "%s".)", gdscript->get_script_path()), p_type);
 										return bad_type;
 									}
@@ -912,7 +969,7 @@ GDScriptParser::DataType GDScriptAnalyzer::resolve_datatype(GDScriptParser::Type
 	}
 
 	if (p_type->type_chain.size() > 1) {
-		if (result.kind == GDScriptParser::DataType::CLASS) {
+		if (result.kind == GDScriptParser::DataType::CLASS || result.kind == GDScriptParser::DataType::TRAIT) {
 			for (int i = 1; i < p_type->type_chain.size(); i++) {
 				GDScriptParser::DataType base = result;
 				reduce_identifier_from_base(p_type->type_chain[i], &base);
@@ -987,7 +1044,7 @@ void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class,
 		}
 	});
 
-	if (member.get_datatype().is_resolving()) {
+	if (member.get_datatype().is_resolving() && p_class->type != GDScriptParser::Node::TRAIT) {
 		push_error(vformat(R"(Could not resolve member "%s": Cyclic reference.)", member.get_name()), p_source);
 		return;
 	}
@@ -1252,11 +1309,13 @@ void GDScriptAnalyzer::resolve_class_member(GDScriptParser::ClassNode *p_class,
 
 				member.enum_value.identifier->set_datatype(make_class_enum_type(UNNAMED_ENUM, p_class, parser->script_path, false));
 			} break;
+			case GDScriptParser::ClassNode::Member::TRAIT:
 			case GDScriptParser::ClassNode::Member::CLASS:
 				check_class_member_name_conflict(p_class, member.m_class->identifier->name, member.m_class);
 				// If it's already resolving, that's ok.
 				if (!member.m_class->base_type.is_resolving()) {
 					resolve_class_inheritance(member.m_class, p_source);
+					resolve_class_uses(member.m_class, p_source);
 				}
 				break;
 			case GDScriptParser::ClassNode::Member::GROUP:
@@ -1313,9 +1372,10 @@ void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_clas
 		if (resolve_class_inheritance(p_class) != OK) {
 			return;
 		}
+		resolve_class_uses(p_class);
 
 		GDScriptParser::DataType base_type = p_class->base_type;
-		if (base_type.kind == GDScriptParser::DataType::CLASS) {
+		if (base_type.kind == GDScriptParser::DataType::CLASS || base_type.kind == GDScriptParser::DataType::TRAIT) {
 			GDScriptParser::ClassNode *base_class = base_type.class_type;
 			resolve_class_interface(base_class, p_class);
 		}
@@ -1326,7 +1386,7 @@ void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_clas
 #ifdef DEBUG_ENABLED
 			if (!has_static_data) {
 				GDScriptParser::ClassNode::Member member = p_class->members[i];
-				if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
+				if (member.type == GDScriptParser::ClassNode::Member::CLASS || member.type == GDScriptParser::ClassNode::Member::TRAIT) {
 					has_static_data = member.m_class->has_static_data;
 				}
 			}
@@ -1353,9 +1413,13 @@ void GDScriptAnalyzer::resolve_class_interface(GDScriptParser::ClassNode *p_clas
 
 	if (p_recursive) {
 		for (int i = 0; i < p_class->members.size(); i++) {
-			GDScriptParser::ClassNode::Member member = p_class->members[i];
-			if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
-				resolve_class_interface(member.m_class, true);
+			switch (p_class->members[i].type) {
+				case GDScriptParser::ClassNode::Member::TRAIT:
+				case GDScriptParser::ClassNode::Member::CLASS:
+					resolve_class_interface(p_class->members[i].m_class, true);
+					break;
+				default:
+					break;
 			}
 		}
 	}
@@ -1371,6 +1435,9 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, co
 	if (p_class->resolved_body) {
 		return;
 	}
+	if (!p_class->resolved_uses) {
+		resolve_class_uses(p_class);
+	}
 
 	if (!parser->has_class(p_class)) {
 		if (parser_ref.is_null()) {
@@ -1523,7 +1590,7 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, co
 			}
 		} else if (member.type == GDScriptParser::ClassNode::Member::SIGNAL) {
 #ifdef DEBUG_ENABLED
-			if (member.signal->usages == 0) {
+			if (member.signal->usages == 0 && p_class->type != GDScriptParser::Node::TRAIT) {
 				parser->push_warning(member.signal->identifier, GDScriptWarning::UNUSED_SIGNAL, member.signal->identifier->name);
 			}
 #endif // DEBUG_ENABLED
@@ -1581,23 +1648,440 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class, bo
 
 	if (p_recursive) {
 		for (int i = 0; i < p_class->members.size(); i++) {
-			GDScriptParser::ClassNode::Member member = p_class->members[i];
-			if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
-				resolve_class_body(member.m_class, true);
+			switch (p_class->members[i].type) {
+				case GDScriptParser::ClassNode::Member::TRAIT:
+				case GDScriptParser::ClassNode::Member::CLASS:
+					resolve_class_body(p_class->members[i].m_class, true);
+					break;
+				default:
+					break;
+			}
+		}
+	}
+}
+
+void GDScriptAnalyzer::resolve_class_uses(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source) {
+	if (p_class->resolved_uses || p_class->resolving_uses) {
+		return;
+	}
+
+	if (p_source == nullptr && parser->has_class(p_class)) {
+		p_source = p_class;
+	}
+
+	if (!parser->has_class(p_class)) {
+		String script_path = p_class->get_datatype().script_path;
+		Ref<GDScriptParserRef> parser_ref = parser->get_depended_parser_for(script_path);
+		if (parser_ref.is_null()) {
+			push_error(vformat(R"(Could not find script "%s".)", script_path), p_source);
+			return;
+		}
+
+		Error err = parser_ref->raise_status(GDScriptParserRef::PARSED);
+		if (err) {
+			push_error(vformat(R"(Could not resolve script "%s": %s.)", script_path, error_names[err]), p_source);
+			return;
+		}
+
+		ERR_FAIL_COND_MSG(!parser_ref->get_parser()->has_class(p_class), R"(Parser bug: Mismatched external parser.)");
+
+		GDScriptAnalyzer *other_analyzer = parser_ref->get_analyzer();
+		GDScriptParser *other_parser = parser_ref->get_parser();
+
+		int error_count = other_parser->errors.size();
+		other_analyzer->resolve_class_body(p_class);
+		if (other_parser->errors.size() > error_count) {
+			push_error(vformat(R"(Could not resolve class "%s".)", p_class->fqcn), p_source);
+		}
+		return;
+	}
+
+	p_class->resolving_uses = true;
+
+	Vector<GDScriptParser::ClassNode *> used_traits;
+	for (GDScriptParser::UsesNode *uses : p_class->traits) {
+		GDScriptParser::ClassNode *trait = nullptr;
+
+		// Find trait used.
+		String trait_name = uses->path;
+		GDScriptParser::Node *trait_name_node = uses;
+		Ref<GDScriptParserRef> ext_parser_ref;
+		int use_index = 0;
+		if (uses->name.is_empty()) {
+			if (uses->path.is_empty()) {
+				push_error("Could not resolve an empty trait path.", uses);
+				continue;
+			}
+			if (uses->path.is_relative_path()) {
+				uses->path = parser->script_path.get_base_dir().path_join(uses->path).simplify_path();
+			}
+			ext_parser_ref = parser->get_depended_parser_for(uses->path);
+			if (ext_parser_ref.is_null()) {
+				push_error(vformat(R"(Could not resolve trait's path "%s".)", uses->path), uses);
+				continue;
+			}
+			Error err = ext_parser_ref->raise_status(GDScriptParserRef::BODY_SOLVED);
+			if (err) {
+				push_error(vformat(R"(Could not resolve trait's body from "%s".)", uses->path), uses);
+				continue;
+			}
+			trait = ext_parser_ref->get_parser()->head;
+		} else {
+			_warn_experimental_trait(uses);
+			GDScriptParser::IdentifierNode *id = uses->name[use_index++];
+			_warn_experimental_trait(id);
+			const StringName &name = id->name;
+			trait_name = name;
+			trait_name_node = id;
+			if (ScriptServer::is_global_class(name)) {
+				String base_path = ScriptServer::get_global_class_path(name);
+				uses->path = base_path;
+				ext_parser_ref = parser->get_depended_parser_for(base_path);
+				if (ext_parser_ref.is_null()) {
+					push_error(vformat(R"(Could not resolve trait "%s".)", name), id);
+					continue;
+				}
+				Error err = ext_parser_ref->raise_status(GDScriptParserRef::BODY_SOLVED);
+				if (err) {
+					push_error(vformat(R"(Could not resolve trait's body from "%s".)", name), id);
+					continue;
+				}
+				trait = ext_parser_ref->get_parser()->head;
+			} else if (ProjectSettings::get_singleton()->has_autoload(name) && ProjectSettings::get_singleton()->get_autoload(name).is_singleton) {
+				push_error(vformat(R"("%s" is an autoload, so it cannot be used as a trait.)", name), id);
+				continue;
+			} else if (class_exists(name)) {
+				push_error(vformat(R"(Native class "%s" cannot be used as a trait.)", name), id);
+				continue;
+			} else {
+				// Look for other classes in script.
+				bool found = false;
+				Error err = OK;
+				List<GDScriptParser::ClassNode *> script_classes;
+				get_class_node_current_scope_classes(p_class, &script_classes, id);
+				for (GDScriptParser::ClassNode *look_class : script_classes) {
+					int error_count = parser->errors.size();
+					if (look_class->identifier && look_class->identifier->name == name) {
+						resolve_class_inheritance(look_class, id);
+						resolve_class_uses(look_class, id);
+						resolve_class_interface(look_class, id);
+						resolve_class_body(look_class, id);
+						if (parser->errors.size() > error_count) {
+							break;
+						}
+						trait = look_class;
+						found = true;
+						break;
+					}
+					if (look_class->has_member(name)) {
+						resolve_class_member(look_class, name, id);
+						GDScriptParser::ClassNode::Member member = look_class->get_member(name);
+						GDScriptParser::DataType member_datatype = member.get_datatype();
+						switch (member.type) {
+							case GDScriptParser::ClassNode::Member::TRAIT:
+							case GDScriptParser::ClassNode::Member::CLASS:
+								resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+								resolve_class_uses(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+								resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+								resolve_class_body(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+								break;
+							case GDScriptParser::ClassNode::Member::CONSTANT:
+								if (member_datatype.kind != GDScriptParser::DataType::SCRIPT && member_datatype.kind != GDScriptParser::DataType::TRAIT) {
+									push_error(vformat(R"(Constant "%s" is not a preloaded script or trait.)", name), id);
+									err = ERR_PARSE_ERROR;
+								}
+								break;
+							default:
+								push_error(vformat(R"(Cannot use %s "%s" in uses chain.)", member.get_type_name(), name), id);
+								err = ERR_PARSE_ERROR;
+						}
+						if (err || parser->errors.size() > error_count) {
+							break;
+						}
+						trait = member.m_class;
+						found = true;
+						break;
+					}
+				}
+				if (!found) {
+					if (err == OK) {
+						push_error(vformat(R"(Could not find trait "%s".)", name), id);
+					}
+					continue;
+				}
+				uses->path = parser->script_path;
+			}
+		}
+		Error err = OK;
+		for (; use_index < uses->name.size(); use_index++) {
+			GDScriptParser::IdentifierNode *id = uses->name[use_index];
+			const StringName &name = id->name;
+			trait_name += "." + name;
+			trait_name_node = id;
+			if (trait->has_member(name)) {
+				GDScriptParser::ClassNode::Member member = trait->get_member(name);
+				GDScriptParser::DataType member_datatype = member.get_datatype();
+				int error_count = parser->errors.size();
+				switch (member.type) {
+					case GDScriptParser::ClassNode::Member::CLASS:
+					case GDScriptParser::ClassNode::Member::TRAIT: {
+						if (ext_parser_ref.is_null()) {
+							// class/trait is in script.
+							resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+							resolve_class_uses(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+							resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+							resolve_class_body(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()), id);
+						} else {
+							GDScriptAnalyzer *ext_analyzer = ext_parser_ref->get_analyzer();
+							GDScriptParser *ext_parser = ext_parser_ref->get_parser();
+							int ext_error_count = ext_parser->errors.size();
+							ext_analyzer->resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()));
+							ext_analyzer->resolve_class_uses(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()));
+							ext_analyzer->resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()));
+							ext_analyzer->resolve_class_body(static_cast<GDScriptParser::ClassNode *>(member.get_source_node()));
+							if (ext_parser->errors.size() > ext_error_count) {
+								push_error(vformat(R"(Could not resolve external %s member "%s".)", member.get_type_name(), member.get_name()), id);
+								err = ERR_PARSE_ERROR;
+							}
+						}
+					} break;
+					case GDScriptParser::ClassNode::Member::CONSTANT:
+						if (member_datatype.kind != GDScriptParser::DataType::SCRIPT && member_datatype.kind != GDScriptParser::DataType::TRAIT) {
+							push_error(vformat(R"(Constant "%s" is not a preloaded script or trait.)", name), id);
+							err = ERR_PARSE_ERROR;
+						}
+						break;
+					default:
+						push_error(vformat(R"(Cannot use %s "%s" in uses chain.)", member.get_type_name(), name), id);
+						err = ERR_PARSE_ERROR;
+				}
+
+				if (parser->errors.size() > error_count) {
+					push_error(vformat(R"(Could not resolve "%s" chain.)", trait_name), trait_name_node);
+					err = ERR_PARSE_ERROR;
+				}
+				if (err) {
+					break;
+				}
+				trait = member.m_class;
+			} else {
+				push_error(vformat(R"(Could not resolve "%s" chain.)", trait_name), trait_name_node);
+				err = ERR_PARSE_ERROR;
+			}
+		}
+		if (err) {
+			continue;
+		}
+		uses->fqtn = trait->fqcn;
+
+		if (trait->type != GDScriptParser::Node::TRAIT) {
+			push_error(vformat(R"("%s" is not a trait.)", trait_name), trait_name_node);
+			continue;
+		}
+
+		if (p_class->fqcn == trait->fqcn) {
+			push_error(vformat(R"("%s" trait can not use itself.)", trait_name), trait_name_node);
+			continue;
+		}
+
+		// Skip if trait is already implemented traits.
+		if (p_class->traits_fqtn.has(trait->fqcn)) {
+			if (used_traits.has(trait)) {
+				push_error(vformat(R"("%s" trait use is already declared.)", trait_name), trait_name_node);
+			} else {
+				used_traits.push_back(trait);
+			}
+			continue;
+		}
+
+		// Do not allows cyclic use of traits: TraitA uses TraitB and TraitB uses TraitA.
+		if (p_class->type == GDScriptParser::Node::TRAIT && trait->traits_fqtn.has(p_class->fqcn)) {
+			push_error(vformat(R"(Cyclic use of trait. "%s" trait can not use trait that uses it.)", trait_name), trait_name_node);
+			trait->resolved_uses = false; // Trigger same error on the other trait.
+			continue;
+		}
+
+		if (!trait->resolved_uses) {
+			if (!trait->resolving_uses) {
+				push_error(vformat(R"(Could not resolve trait's uses from "%s".)", trait_name), trait_name_node);
+			}
+			continue;
+		}
+
+		// Check for cohesion with implemented traits.
+		bool trait_cohesion = true;
+		for (const GDScriptParser::ClassNode *used_trait : used_traits) {
+			for (auto &key_value : used_trait->members_indices) {
+				const StringName &member_name = key_value.key;
+				if (trait->has_member(member_name)) {
+					// Check if copied over from a common trait.
+					GDScriptParser::ClassNode::Member trait_member = trait->get_member(member_name);
+					bool copied_over = trait_member.get_source_node()->trait_origin.has(p_class->fqcn);
+					for (const StringName &trait_fqcn : p_class->traits_fqtn) {
+						if (!copied_over && trait_member.get_source_node()->trait_origin.has(trait_fqcn)) {
+							copied_over = true;
+							break;
+						}
+					}
+					if (!copied_over) {
+						trait_cohesion = false;
+					}
+				}
+			}
+			if (!trait_cohesion) {
+				break;
+			}
+		}
+		if (!trait_cohesion) {
+			push_error(vformat(R"(Can not use "%s" trait since it shadows members from previous traits.)", trait_name), trait_name_node);
+			continue;
+		}
+
+		// Check for inheritance is compatible.
+		bool inheritance_match = true;
+		if (trait->extends_used) {
+			const GDScriptParser::DataType trait_base_type = trait->base_type;
+			if (!p_class->extends_used) {
+				if (trait_base_type.kind != GDScriptParser::DataType::NATIVE) {
+					inheritance_match = false;
+				} else if (trait_base_type.native_type != SNAME("RefCounted") && !ClassDB::is_parent_class(SNAME("RefCounted"), trait_base_type.native_type)) {
+					inheritance_match = false;
+				}
+			} else {
+				const GDScriptParser::DataType class_base_type = p_class->base_type;
+				if (trait_base_type.kind == GDScriptParser::DataType::NATIVE) {
+					if (class_base_type.class_type != nullptr) {
+						GDScriptParser::ClassNode *parent = class_base_type.class_type;
+						while (parent != nullptr) {
+							if (parent->base_type.kind == GDScriptParser::DataType::NATIVE) {
+								if (trait_base_type.native_type == parent->base_type.native_type) {
+									inheritance_match = true;
+								} else {
+									inheritance_match = ClassDB::is_parent_class(parent->base_type.native_type, trait_base_type.native_type);
+								}
+								break;
+							}
+							parent = parent->base_type.class_type;
+						}
+					} else {
+						if (trait_base_type.native_type == class_base_type.native_type) {
+							inheritance_match = true;
+						} else {
+							inheritance_match = ClassDB::is_parent_class(class_base_type.native_type, trait_base_type.native_type);
+						}
+					}
+				} else {
+					inheritance_match = trait_base_type == class_base_type;
+					if (!inheritance_match && class_base_type.class_type != nullptr) {
+						GDScriptParser::ClassNode *parent = class_base_type.class_type;
+						while (parent != nullptr) {
+							if (trait_base_type == parent->base_type) {
+								inheritance_match = true;
+								break;
+							}
+							parent = parent->base_type.class_type;
+						}
+					}
+				}
+			}
+		} else if (p_class->extends_used) {
+			GDScriptParser::DataType class_base_type = p_class->base_type;
+			if (class_base_type.kind == GDScriptParser::DataType::NATIVE && class_base_type.native_type != SNAME("RefCounted")) {
+				for (const GDScriptParser::ClassNode::Member &member : trait->members) {
+					if (ClassDB::has_enum(class_base_type.native_type, member.get_name()) ||
+							ClassDB::has_signal(class_base_type.native_type, member.get_name()) ||
+							ClassDB::has_method(class_base_type.native_type, member.get_name()) ||
+							ClassDB::has_integer_constant(class_base_type.native_type, member.get_name())) {
+						inheritance_match = false;
+						break;
+					}
+				}
+			} else if (class_base_type.class_type != nullptr) {
+				for (const GDScriptParser::ClassNode::Member &member : trait->members) {
+					if (class_base_type.class_type->has_member(member.get_name())) {
+						inheritance_match = false;
+						break;
+					}
+				}
+			}
+		}
+		if (!inheritance_match) {
+			String trait_extends_name = "RefCounted";
+			if (trait->extends_used) {
+				trait_extends_name = trait->base_type.to_string();
+			}
+			push_error(vformat(R"("%s" trait extending "%s" does not match class inheritance.)", trait_name, trait_extends_name), trait_name_node);
+			continue;
+		}
+
+		// Trait Copy over, Extending and overriding class members.
+		extend_class(p_class, trait, trait_name_node, trait_name);
+
+		// Ensures cached external parser class, resolving dependencies issues.
+		if (!ext_parser_ref.is_null()) {
+			for (const KeyValue<const GDScriptParser::ClassNode *, Ref<GDScriptParserRef>> &E : ext_parser_ref->get_analyzer()->external_class_parser_cache) {
+				external_class_parser_cache.insert(E.key, E.value);
+			}
+		}
+
+		// Store references to used traits for type checks.
+		p_class->traits_fqtn.append(trait->fqcn);
+		for (StringName other_trait_fqcn : trait->traits_fqtn) {
+			if (!p_class->traits_fqtn.has(other_trait_fqcn)) {
+				p_class->traits_fqtn.append(other_trait_fqcn);
+			}
+		}
+		uses->traits_fqtn = trait->traits_fqtn;
+
+		used_traits.append(trait);
+	}
+
+	p_class->resolving_uses = false;
+	p_class->resolved_uses = true;
+}
+
+void GDScriptAnalyzer::resolve_class_uses(GDScriptParser::ClassNode *p_class, bool p_recursive) {
+	resolve_class_uses(p_class);
+
+	if (p_recursive) {
+		for (int i = 0; i < p_class->members.size(); i++) {
+			switch (p_class->members[i].type) {
+				case GDScriptParser::ClassNode::Member::TRAIT:
+				case GDScriptParser::ClassNode::Member::CLASS:
+					resolve_class_uses(p_class->members[i].m_class, true);
+					break;
+				default:
+					break;
 			}
 		}
 	}
 }
 
+void GDScriptAnalyzer::_warn_experimental_trait(const GDScriptParser::Node *p_source) {
+	// show experimental warning
+#ifdef TOOLS_ENABLED
+	// @todo: remove experimental tag in 27.1-rc.1
+	if (!experimental_traits_warned) {
+		experimental_traits_warned = true;
+		bool show_warning = GLOBAL_GET("debug/gdscript/warnings/show_experimental_trait_warning");
+		if (show_warning) {
+			parser->push_warning(p_source, GDScriptWarning::EXPERIMENTAL_TRAIT);
+		}
+	}
+#endif
+}
+
 void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root) {
 	ERR_FAIL_NULL_MSG(p_node, "Trying to resolve type of a null node.");
 
 	switch (p_node->type) {
 		case GDScriptParser::Node::NONE:
 			break; // Unreachable.
+		case GDScriptParser::Node::TRAIT:
 		case GDScriptParser::Node::CLASS:
 			// NOTE: Currently this route is never executed, `resolve_class_*()` is called directly.
 			if (OK == resolve_class_inheritance(static_cast<GDScriptParser::ClassNode *>(p_node), true)) {
+				resolve_class_uses(static_cast<GDScriptParser::ClassNode *>(p_node), true);
 				resolve_class_interface(static_cast<GDScriptParser::ClassNode *>(p_node), true);
 				resolve_class_body(static_cast<GDScriptParser::ClassNode *>(p_node), true);
 			}
@@ -1671,6 +2155,7 @@ void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node, bool p_is_root
 		case GDScriptParser::Node::FUNCTION:
 		case GDScriptParser::Node::PASS:
 		case GDScriptParser::Node::SIGNAL:
+		case GDScriptParser::Node::USES:
 			// Nothing to do.
 			break;
 	}
@@ -1739,7 +2224,7 @@ void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode *
 
 	StringName function_name = p_function->identifier != nullptr ? p_function->identifier->name : StringName();
 
-	if (p_function->get_datatype().is_resolving()) {
+	if (p_function->get_datatype().is_resolving() && parser->head->type != GDScriptParser::Node::TRAIT) {
 		push_error(vformat(R"(Could not resolve function "%s": Cyclic reference.)", function_name), p_source);
 		return;
 	}
@@ -1787,7 +2272,7 @@ void GDScriptAnalyzer::resolve_function_signature(GDScriptParser::FunctionNode *
 		resolve_parameter(p_function->parameters[i]);
 		method_info.arguments.push_back(p_function->parameters[i]->get_datatype().to_property_info(p_function->parameters[i]->identifier->name));
 #ifdef DEBUG_ENABLED
-		if (p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_") && !p_function->is_abstract) {
+		if (!p_function->is_bodyless && p_function->parameters[i]->usages == 0 && !String(p_function->parameters[i]->identifier->name).begins_with("_") && !p_function->is_abstract) {
 			parser->push_warning(p_function->parameters[i]->identifier, GDScriptWarning::UNUSED_PARAMETER, function_visible_name, p_function->parameters[i]->identifier->name);
 		}
 		is_shadowing(p_function->parameters[i]->identifier, "function parameter", true);
@@ -1996,19 +2481,19 @@ void GDScriptAnalyzer::resolve_function_body(GDScriptParser::FunctionNode *p_fun
 	p_function->resolved_body = true;
 
 	if (p_function->body->statements.is_empty()) {
-		// Non-abstract functions must have a body.
-		if (p_function->source_lambda != nullptr) {
-			push_error(R"(A lambda function must have a ":" followed by a body.)", p_function);
-		} else if (!p_function->is_abstract) {
-			push_error(R"(A function must either have a ":" followed by a body, or be marked as "@abstract".)", p_function);
-		}
-		return;
-	} else {
-		// Abstract functions must not have a body.
-		if (p_function->is_abstract) {
-			push_error(R"(An abstract function cannot have a body.)", p_function->body);
+		if (parser->current_class->type != GDScriptParser::Node::TRAIT) {
+			// Non-abstract functions must have a body.
+			if (p_function->source_lambda != nullptr) {
+				push_error(R"(A lambda function must have a ":" followed by a body.)", p_function);
+			} else if (!p_function->is_abstract) {
+				push_error(R"(A function must either have a ":" followed by a body, or be marked as "@abstract".)", p_function);
+			}
 			return;
 		}
+	} else if (p_function->is_abstract) {
+		// Abstract functions must not have a body.
+		push_error(R"(An abstract function cannot have a body.)", p_function->body);
+		return;
 	}
 
 	GDScriptParser::FunctionNode *previous_function = parser->current_function;
@@ -2023,7 +2508,7 @@ void GDScriptAnalyzer::resolve_function_body(GDScriptParser::FunctionNode *p_fun
 		// Use the suite inferred type if return isn't explicitly set.
 		p_function->set_datatype(p_function->body->get_datatype());
 	} else if (p_function->get_datatype().is_hard_type() && (p_function->get_datatype().kind != GDScriptParser::DataType::BUILTIN || p_function->get_datatype().builtin_type != Variant::NIL)) {
-		if (!p_function->body->has_return && (p_is_lambda || p_function->identifier->name != GDScriptLanguage::get_singleton()->strings._init)) {
+		if (!p_function->is_bodyless && !p_function->body->has_return && (p_is_lambda || p_function->identifier->name != GDScriptLanguage::get_singleton()->strings._init)) {
 			push_error(R"(Not all code paths return a value.)", p_function);
 		}
 	}
@@ -2667,6 +3152,7 @@ void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expre
 		case GDScriptParser::Node::ASSERT:
 		case GDScriptParser::Node::BREAK:
 		case GDScriptParser::Node::BREAKPOINT:
+		case GDScriptParser::Node::TRAIT:
 		case GDScriptParser::Node::CLASS:
 		case GDScriptParser::Node::CONSTANT:
 		case GDScriptParser::Node::CONTINUE:
@@ -2685,6 +3171,7 @@ void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expre
 		case GDScriptParser::Node::TYPE:
 		case GDScriptParser::Node::VARIABLE:
 		case GDScriptParser::Node::WHILE:
+		case GDScriptParser::Node::USES:
 			ERR_FAIL_MSG("Reaching unreachable case");
 	}
 
@@ -2775,6 +3262,8 @@ void GDScriptAnalyzer::update_const_expression_builtin_type(GDScriptParser::Expr
 	p_expression->set_datatype(p_type);
 }
 
+// When an array literal is stored (or passed as function argument) to a typed context, we then assume the array is typed.
+// This function determines which type is that (if any).
 void GDScriptAnalyzer::update_array_literal_element_type(GDScriptParser::ArrayNode *p_array, const GDScriptParser::DataType &p_element_type) {
 	GDScriptParser::DataType expected_type = p_element_type;
 	expected_type.container_element_types.clear(); // Nested types (like `Array[Array[int]]`) are not currently supported.
@@ -2804,6 +3293,8 @@ void GDScriptAnalyzer::update_array_literal_element_type(GDScriptParser::ArrayNo
 	p_array->set_datatype(array_type);
 }
 
+// When a dictionary literal is stored (or passed as function argument) to a typed context, we then assume the dictionary is typed.
+// This function determines which type is that (if any).
 void GDScriptAnalyzer::update_dictionary_literal_element_type(GDScriptParser::DictionaryNode *p_dictionary, const GDScriptParser::DataType &p_key_element_type, const GDScriptParser::DataType &p_value_element_type) {
 	GDScriptParser::DataType expected_key_type = p_key_element_type;
 	GDScriptParser::DataType expected_value_type = p_value_element_type;
@@ -2915,9 +3406,14 @@ void GDScriptAnalyzer::reduce_assignment(GDScriptParser::AssignmentNode *p_assig
 		return;
 	} else if (p_assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT && static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee)->base->is_constant) {
 		const GDScriptParser::DataType &base_type = static_cast<GDScriptParser::SubscriptNode *>(p_assignment->assignee)->base->datatype;
-		if (base_type.kind != GDScriptParser::DataType::SCRIPT && base_type.kind != GDScriptParser::DataType::CLASS) { // Static variables.
-			push_error("Cannot assign a new value to a constant.", p_assignment->assignee);
-			return;
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::SCRIPT:
+			case GDScriptParser::DataType::TRAIT:
+			case GDScriptParser::DataType::CLASS: // Static variables.
+				break;
+			default:
+				push_error("Cannot assign a new value to a constant.", p_assignment->assignee);
+				return;
 		}
 	} else if (assignee_type.is_read_only) {
 		push_error("Cannot assign a new value to a read-only property.", p_assignment->assignee);
@@ -3106,7 +3602,13 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 	}
 
 #ifdef DEBUG_ENABLED
-	if (p_binary_op->variant_op == Variant::OP_DIVIDE && left_type.builtin_type == Variant::INT && right_type.builtin_type == Variant::INT) {
+	if (p_binary_op->variant_op == Variant::OP_DIVIDE &&
+			(left_type.builtin_type == Variant::INT ||
+					left_type.builtin_type == Variant::VECTOR2I ||
+					left_type.builtin_type == Variant::VECTOR3I ||
+					left_type.builtin_type == Variant::VECTOR4I) &&
+			(right_type.builtin_type == Variant::INT ||
+					right_type.builtin_type == left_type.builtin_type)) {
 		parser->push_warning(p_binary_op, GDScriptWarning::INTEGER_DIVISION);
 	}
 #endif // DEBUG_ENABLED
@@ -3603,6 +4105,11 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_a
 		return;
 	}
 
+	if (!is_self && base_type.is_constant && base_type.kind == GDScriptParser::DataType::TRAIT) {
+		push_error(vformat(R"*(Cannot call a trait's functions directly; call through a class that uses it instead.)*"), p_call);
+		return;
+	}
+
 	int default_arg_count = 0;
 	BitField<MethodFlags> method_flags = {};
 	GDScriptParser::DataType return_type;
@@ -3797,6 +4304,24 @@ void GDScriptAnalyzer::reduce_cast(GDScriptParser::CastNode *p_cast) {
 				cast_type.get_container_element_type_or_variant(0), cast_type.get_container_element_type_or_variant(1));
 	}
 
+	if ((p_cast->operand->get_datatype().kind == GDScriptParser::DataType::CLASS || p_cast->operand->get_datatype().kind == GDScriptParser::DataType::TRAIT) && cast_type.kind == GDScriptParser::DataType::TRAIT) {
+		if (p_cast->operand->is_constant) {
+			push_error(vformat(R"(Invalid cast. Cannot convert from "%s" to "%s".)", p_cast->operand->get_datatype().to_string(), cast_type.to_string()), p_cast->cast_type);
+		} else {
+			GDScriptParser::DataType operand_type = p_cast->operand->get_datatype();
+			bool is_using_trait = false;
+			if (operand_type.class_type && cast_type.class_type) {
+				is_using_trait = operand_type.class_type->traits_fqtn.has(cast_type.class_type->fqcn);
+			}
+			if (operand_type.is_hard_type() && !is_using_trait && operand_type.kind != GDScriptParser::DataType::VARIANT) {
+				push_error(vformat(R"(Invalid cast. Cannot convert from "%s" to "%s".)", p_cast->operand->get_datatype().to_string(), cast_type.to_string()), p_cast->cast_type);
+			} else {
+				mark_node_unsafe(p_cast);
+			}
+		}
+		return;
+	}
+
 	if (!cast_type.is_variant()) {
 		GDScriptParser::DataType op_type = p_cast->operand->get_datatype();
 		if (op_type.is_variant() || !op_type.is_hard_type()) {
@@ -3880,7 +4405,6 @@ void GDScriptAnalyzer::reduce_get_node(GDScriptParser::GetNodeNode *p_get_node)
 
 GDScriptParser::DataType GDScriptAnalyzer::make_global_class_meta_type(const StringName &p_class_name, const GDScriptParser::Node *p_source) {
 	GDScriptParser::DataType type;
-
 	String path = ScriptServer::get_global_class_path(p_class_name);
 	String ext = path.get_extension();
 	if (ext == GDScriptLanguage::get_singleton()->get_extension()) {
@@ -3892,7 +4416,7 @@ GDScriptParser::DataType GDScriptAnalyzer::make_global_class_meta_type(const Str
 			return type;
 		}
 
-		Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+		Error err = ref->raise_status(GDScriptParserRef::USES_SOLVED);
 		if (err) {
 			push_error(vformat(R"(Could not resolve class "%s", because of a parser error.)", p_class_name), p_source);
 			type.type_source = GDScriptParser::DataType::UNDETECTED;
@@ -4163,7 +4687,11 @@ void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNod
 		if (p_base == nullptr && script_class->identifier && script_class->identifier->name == name) {
 			reduce_identifier_from_base_set_class(p_identifier, script_class->get_datatype());
 			if (script_class->outer != nullptr) {
-				p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
+				if (script_class->type == GDScriptParser::Node::CLASS) {
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
+				} else if (script_class->type == GDScriptParser::Node::TRAIT) {
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_TRAIT;
+				}
 			}
 			return;
 		}
@@ -4232,6 +4760,12 @@ void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNod
 					}
 				} break;
 
+				case GDScriptParser::ClassNode::Member::TRAIT: {
+					reduce_identifier_from_base_set_class(p_identifier, member.get_datatype());
+					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_TRAIT;
+					return;
+				}
+
 				case GDScriptParser::ClassNode::Member::CLASS: {
 					reduce_identifier_from_base_set_class(p_identifier, member.get_datatype());
 					p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CLASS;
@@ -4436,6 +4970,7 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 		} break;
 		case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
 		case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
+		case GDScriptParser::IdentifierNode::MEMBER_TRAIT:
 		case GDScriptParser::IdentifierNode::MEMBER_CLASS:
 		case GDScriptParser::IdentifierNode::NATIVE_CLASS:
 			break;
@@ -4505,6 +5040,7 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 				case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
 				case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
 				case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
+				case GDScriptParser::IdentifierNode::MEMBER_TRAIT:
 				case GDScriptParser::IdentifierNode::MEMBER_CLASS:
 				case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
 				case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
@@ -4562,10 +5098,10 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 			result.kind = GDScriptParser::DataType::NATIVE;
 			result.builtin_type = Variant::OBJECT;
 			result.native_type = SNAME("Node");
-			if (ResourceLoader::get_resource_type(autoload.path) == "GDScript") {
+			if (ResourceLoader::get_resource_type(autoload.path) == "GDScript" || ResourceLoader::get_resource_type(autoload.path) == "GDScriptTrait") {
 				Ref<GDScriptParserRef> single_parser = parser->get_depended_parser_for(autoload.path);
 				if (single_parser.is_valid()) {
-					Error err = single_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+					Error err = single_parser->raise_status(GDScriptParserRef::USES_SOLVED);
 					if (err == OK) {
 						result = type_from_metatype(single_parser->get_parser()->head->get_datatype());
 					}
@@ -4579,7 +5115,7 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
 						if (scr.is_valid()) {
 							Ref<GDScriptParserRef> single_parser = parser->get_depended_parser_for(scr->get_script_path());
 							if (single_parser.is_valid()) {
-								Error err = single_parser->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+								Error err = single_parser->raise_status(GDScriptParserRef::USES_SOLVED);
 								if (err == OK) {
 									result = type_from_metatype(single_parser->get_parser()->head->get_datatype());
 								}
@@ -4728,7 +5264,7 @@ void GDScriptAnalyzer::reduce_preload(GDScriptParser::PreloadNode *p_preload) {
 			// Must load GDScript separately to permit cyclic references
 			// as ResourceLoader::load() detects and rejects those.
 			const String &res_type = ResourceLoader::get_resource_type(p_preload->resolved_path);
-			if (res_type == "GDScript") {
+			if (res_type == "GDScript" || res_type == "GDScriptTrait") {
 				Error err = OK;
 				Ref<GDScript> res = get_depended_shallow_script(p_preload->resolved_path, err);
 				p_preload->resource = res;
@@ -4784,6 +5320,12 @@ void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscri
 		}
 
 		GDScriptParser::DataType base_type = p_subscript->base->get_datatype();
+
+		if (base_type.is_constant && base_type.kind == GDScriptParser::DataType::TRAIT) {
+			push_error(vformat(R"*(Cannot access a trait's members directly; access through a class that uses it instead.)*"), p_subscript->attribute);
+			return;
+		}
+
 		bool valid = false;
 
 		// If the base is a metatype, use the analyzer instead.
@@ -5194,6 +5736,29 @@ void GDScriptAnalyzer::reduce_type_test(GDScriptParser::TypeTestNode *p_type_tes
 		return;
 	}
 
+	if (test_type.kind == GDScriptParser::DataType::TRAIT) {
+		bool is_using_trait = false;
+		if (operand_type.class_type && test_type.class_type) {
+			is_using_trait = operand_type.class_type->traits_fqtn.has(test_type.class_type->fqcn);
+		}
+
+		if (p_type_test->operand->is_constant) {
+			p_type_test->is_constant = true;
+			p_type_test->reduced_value = is_using_trait;
+
+			if (!p_type_test->reduced_value) {
+				push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)", operand_type.to_string(), test_type.to_string()), p_type_test->operand);
+			}
+		} else {
+			if (operand_type.is_hard_type() && !is_using_trait && operand_type.kind != GDScriptParser::DataType::VARIANT) {
+				push_error(vformat(R"(Expression is of type "%s" so it can't be of type "%s".)", operand_type.to_string(), test_type.to_string()), p_type_test->operand);
+			} else {
+				downgrade_node_type_source(p_type_test->operand);
+			}
+		}
+		return;
+	}
+
 	if (p_type_test->operand->is_constant) {
 		p_type_test->is_constant = true;
 		p_type_test->reduced_value = false;
@@ -5417,7 +5982,7 @@ Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::D
 
 	if (p_element_datatype.builtin_type == Variant::OBJECT) {
 		Ref<Script> script_type = p_element_datatype.script_type;
-		if (p_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
+		if ((p_element_datatype.kind == GDScriptParser::DataType::CLASS || p_element_datatype.kind == GDScriptParser::DataType::TRAIT) && script_type.is_null()) {
 			Error err = OK;
 			Ref<GDScript> scr = get_depended_shallow_script(p_element_datatype.script_path, err);
 			if (err) {
@@ -5571,7 +6136,7 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_va
 					error_type.kind = GDScriptParser::DataType::VARIANT;
 					return error_type;
 				}
-				Error err = ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+				Error err = ref->raise_status(GDScriptParserRef::USES_SOLVED);
 				GDScriptParser::ClassNode *found = nullptr;
 				if (err == OK) {
 					found = ref->get_parser()->find_class(gds->fully_qualified_name);
@@ -5587,6 +6152,9 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_variant(const Variant &p_va
 				}
 
 				result.kind = GDScriptParser::DataType::CLASS;
+				if (found->type == GDScriptParser::Node::TRAIT) {
+					result.kind = GDScriptParser::DataType::TRAIT;
+				}
 				result.native_type = found->get_datatype().native_type;
 				result.class_type = found;
 				result.script_path = ref->get_parser()->script_path;
@@ -5833,6 +6401,7 @@ bool GDScriptAnalyzer::get_function_signature(GDScriptParser::Node *p_source, bo
 		}
 
 		resolve_class_inheritance(base_class, p_source);
+		resolve_class_uses(base_class, p_source);
 		base_class = base_class->base_type.class_type;
 	}
 
@@ -6215,7 +6784,7 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 			}
 			break;
 		case GDScriptParser::DataType::SCRIPT:
-			if (p_target.kind == GDScriptParser::DataType::CLASS) {
+			if (p_target.kind == GDScriptParser::DataType::CLASS || p_target.kind == GDScriptParser::DataType::TRAIT) {
 				// A script type cannot be a subtype of a GDScript class.
 				return false;
 			}
@@ -6229,6 +6798,7 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 				src_native = src_script->get_instance_base_type();
 			}
 			break;
+		case GDScriptParser::DataType::TRAIT:
 		case GDScriptParser::DataType::CLASS:
 			if (p_source.is_meta_type) {
 				src_native = GDScript::get_class_static();
@@ -6268,6 +6838,7 @@ bool GDScriptAnalyzer::check_type_compatibility(const GDScriptParser::DataType &
 				src_script = src_script->get_base_script();
 			}
 			return false;
+		case GDScriptParser::DataType::TRAIT:
 		case GDScriptParser::DataType::CLASS:
 			if (p_target.is_meta_type) {
 				return ClassDB::is_parent_class(src_native, GDScript::get_class_static());
@@ -6405,6 +6976,261 @@ bool GDScriptAnalyzer::class_exists(const StringName &p_class) const {
 	return ClassDB::class_exists(p_class) && ClassDB::is_class_exposed(p_class);
 }
 
+void GDScriptAnalyzer::override_member_function(GDScriptParser::FunctionNode *p_target_function, const GDScriptParser::FunctionNode *p_source_function, const String &p_trait_name) {
+	resolve_function_signature(p_target_function);
+
+	// Check function signature.
+	String function_signature = p_source_function->identifier->name;
+	function_signature += "(";
+	int par_count_diff = p_source_function->parameters.size() - p_target_function->parameters.size();
+	bool signature_match = par_count_diff >= 0;
+	for (int j = 0; j < p_source_function->parameters.size(); j++) {
+		function_signature += p_source_function->parameters[j]->get_datatype().to_string_strict();
+		if (j > 0) {
+			function_signature += ",";
+		}
+
+		if (j > p_target_function->parameters.size() - 1) {
+			signature_match = false;
+			continue;
+		}
+
+		if (signature_match) {
+			if (p_source_function->parameters[j]->get_datatype().is_hard_type() && p_source_function->parameters[j]->get_datatype().is_variant()) {
+				signature_match = p_target_function->parameters[j]->get_datatype().is_variant();
+			} else {
+				signature_match = is_type_compatible(p_target_function->parameters[j]->get_datatype(), p_source_function->parameters[j]->get_datatype());
+			}
+		}
+	}
+
+	// Return type.
+	if (p_target_function->return_type != nullptr) {
+		// Check return type covariance.
+		GDScriptParser::DataType class_return_type = p_target_function->get_datatype();
+		GDScriptParser::DataType trait_return_type = p_source_function->get_datatype();
+		if (class_return_type.is_variant()) {
+			// `is_type_compatible()` returns `true` if one of the types is `Variant`.
+			// Don't allow an explicitly specified `Variant` if the parent return type is narrower.
+			signature_match = signature_match && trait_return_type.is_variant();
+		} else if (class_return_type.kind == GDScriptParser::DataType::BUILTIN && class_return_type.builtin_type == Variant::NIL) {
+			// `is_type_compatible()` returns `true` if target is an `Object` and source is `null`.
+			// Don't allow `void` if the parent return type is a hard non-`void` type.
+			if (trait_return_type.is_hard_type() && !(trait_return_type.kind == GDScriptParser::DataType::BUILTIN && trait_return_type.builtin_type == Variant::NIL)) {
+				signature_match = false;
+			}
+		} else {
+			signature_match = signature_match && is_type_compatible(trait_return_type, class_return_type);
+		}
+	} else if (p_source_function->return_type != nullptr) {
+		signature_match = false;
+	}
+
+	function_signature += ") -> ";
+	const String return_type = p_source_function->get_datatype().to_string();
+	if (return_type == "null") {
+		function_signature += "void";
+	} else {
+		function_signature += return_type;
+	}
+	if (!signature_match) {
+		push_error(vformat(R"(Function signature of "%s" should be "%s" as declared in trait "%s".)", p_source_function->identifier->name, function_signature, p_trait_name), p_target_function);
+	}
+
+	if (p_source_function->is_static && !p_target_function->is_static) {
+#ifdef DEBUG_ENABLED
+		parser->push_warning(p_target_function, GDScriptWarning::UNUSED_STATIC_OVERRIDING_TRAIT);
+#endif
+		p_target_function->is_static = true;
+	}
+	if (p_target_function->rpc_config.get_type() == Variant::NIL) {
+		p_target_function->rpc_config = p_source_function->rpc_config;
+	}
+#ifdef TOOLS_ENABLED
+	copy_over_member_doc_data(p_target_function->doc_data, p_source_function->doc_data);
+#endif
+}
+
+void GDScriptAnalyzer::extend_class(GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_trait, const GDScriptParser::Node *p_trait_name_node, const String &p_trait_name) {
+	for (int i = 0; i < p_trait->members.size(); i++) {
+		GDScriptParser::ClassNode::Member trait_member = p_trait->members[i];
+		if (trait_member.type == GDScriptParser::ClassNode::Member::TRAIT) {
+			continue;
+		}
+
+		if (!p_class->base_type.native_type.is_empty()) {
+			MethodBind *native_method = ClassDB::get_method(p_class->base_type.native_type, trait_member.get_name());
+			if (native_method) {
+				push_error(vformat(R"("%s" %s from trait "%s" conflicts with an already-existing native method of the using class.)", trait_member.get_name(), trait_member.get_type_name(), p_trait_name), p_trait_name_node);
+				return;
+			}
+			if (has_member_name_conflict_in_native_type(trait_member.get_name(), p_class->base_type.native_type)) {
+				push_error(vformat(R"("%s" %s from trait "%s" conflicts with an already-existing native member of the using class.)", trait_member.get_name(), trait_member.get_type_name(), p_trait_name), p_trait_name_node);
+				return;
+			}
+		}
+		if (p_trait->extends_used && p_class->extends_used) {
+			const GDScriptParser::DataType trait_base_type = p_trait->base_type;
+			const GDScriptParser::DataType class_base_type = p_class->base_type;
+			if (trait_base_type != class_base_type && class_base_type.class_type != nullptr) {
+				GDScriptParser::ClassNode *parent = class_base_type.class_type;
+				while (parent != nullptr) {
+					// check the parent classes in between excluding compatibility class for conflict
+					if (parent->has_member(trait_member.get_name())) {
+						push_error(vformat(R"("%s" %s from trait "%s" conflicts with an already-existing member inherited from parent of using class.)", trait_member.get_name(), trait_member.get_type_name(), p_trait_name), p_trait_name_node);
+						return;
+					}
+					if (trait_base_type == parent->base_type) {
+						break;
+					} else if (
+							trait_base_type.kind == GDScriptParser::DataType::NATIVE &&
+							parent->base_type.kind == GDScriptParser::DataType::NATIVE &&
+							(trait_base_type.native_type == parent->base_type.native_type ||
+									ClassDB::is_parent_class(parent->base_type.native_type, trait_base_type.native_type))) {
+						break;
+					}
+					parent = parent->base_type.class_type;
+				}
+			}
+		}
+
+		// Copy over.
+		if (!p_class->has_member(trait_member.get_name())) {
+			if (trait_member.type == GDScriptParser::ClassNode::Member::FUNCTION && trait_member.function->is_bodyless && p_class->type == GDScriptParser::Node::CLASS) {
+				// Unimplemented (Bodyless) Functions.
+				GDScriptParser::FunctionNode *trait_function = trait_member.function;
+				String function_signature = trait_member.get_name() + "(";
+				for (int j = 0; j < trait_function->parameters.size(); j++) {
+					function_signature += trait_function->parameters[j]->get_datatype().to_string_strict();
+					if (j > 0) {
+						function_signature += ",";
+					}
+				}
+				function_signature += ") -> ";
+				const String return_type = trait_function->get_datatype().to_string_strict();
+				if (return_type == "null") {
+					function_signature += "void";
+				} else {
+					function_signature += return_type;
+				}
+				push_error(vformat(R"(Class uses trait "%s" but does not implement function "%s".)", p_trait_name, function_signature), p_trait_name_node);
+				continue;
+			}
+			switch (trait_member.type) {
+				case GDScriptParser::ClassNode::Member::CONSTANT:
+					// Copied over trait constant.
+					p_class->add_member(trait_member.constant);
+					break;
+				case GDScriptParser::ClassNode::Member::VARIABLE:
+					// Copied over trait variable.
+					p_class->add_member(trait_member.variable);
+					if (trait_member.variable->is_static && !p_class->has_static_data) {
+						p_class->has_static_data = true;
+					}
+					if (trait_member.variable->onready && !p_class->onready_used) {
+						p_class->onready_used = true;
+					}
+					break;
+				case GDScriptParser::ClassNode::Member::FUNCTION:
+					// Copied over trait function.
+					p_class->add_member(trait_member.function);
+					if (trait_member.function->is_static && !p_class->has_static_data) {
+						p_class->has_static_data = true;
+					}
+					break;
+				case GDScriptParser::ClassNode::Member::ENUM:
+					// Copied over trait enum.
+					p_class->add_member(trait_member.m_enum);
+					break;
+				case GDScriptParser::ClassNode::Member::ENUM_VALUE:
+					// Copied over trait enum_values.
+					p_class->add_member(trait_member.enum_value);
+					break;
+				case GDScriptParser::ClassNode::Member::SIGNAL:
+					// Copied over trait signal.
+					p_class->add_member(trait_member.signal);
+					break;
+				case GDScriptParser::ClassNode::Member::GROUP:
+					// Copied over trait annotation.
+					p_class->add_member_group(trait_member.annotation);
+					break;
+				default:
+					continue;
+			}
+
+			// Add trait origin to copied over members.
+			if (!trait_member.get_source_node()->trait_origin.has(p_trait->fqcn)) {
+				trait_member.get_source_node()->trait_origin.append(p_trait->fqcn);
+			}
+			continue;
+		}
+
+		GDScriptParser::ClassNode::Member class_member = p_class->get_member(trait_member.get_name());
+		if (class_member.type != trait_member.type) {
+			push_error(vformat(R"("%s" %s conflicts with an already-existing %s in trait "%s".)", class_member.get_name(), class_member.get_type_name(), trait_member.get_type_name(), p_trait_name), class_member.get_source_node());
+			continue;
+		}
+
+		// Skip already copied members by other traits used.
+		if (trait_member.get_source_node()->trait_origin.has(p_class->fqcn)) {
+			continue;
+		}
+		bool copied_over = false;
+		for (const StringName &trait_fqcn : p_class->traits_fqtn) {
+			if (trait_member.get_source_node()->trait_origin.has(trait_fqcn)) {
+				copied_over = true;
+				break;
+			}
+		}
+		if (copied_over) {
+			continue;
+		}
+
+		// Traits are not allowed to extenting or overriding members traits.
+		if (p_class->type == GDScriptParser::Node::TRAIT) {
+			push_error(vformat(R"("%s" %s is already declared in trait "%s". Traits do not extend/override members from using traits.)", trait_member.get_name(), trait_member.get_type_name(), p_trait_name), class_member.get_source_node());
+			continue;
+		}
+
+		// Extending or overriding members.
+		switch (trait_member.type) {
+			case GDScriptParser::ClassNode::Member::FUNCTION: {
+				override_member_function(class_member.function, trait_member.function, p_trait_name);
+				if (trait_member.function->is_static && !p_class->has_static_data) {
+					p_class->has_static_data = true;
+				}
+			} break;
+			case GDScriptParser::ClassNode::Member::GROUP:
+			case GDScriptParser::ClassNode::Member::UNDEFINED:
+				continue;
+			default:
+				push_error(vformat(R"("%s" %s conflicts with an already-existing %s in trait "%s".)", class_member.get_name(), class_member.get_type_name(), trait_member.get_type_name(), p_trait_name), class_member.get_source_node());
+				continue;
+		}
+
+		// Add trait origin to extended or overridden members.
+		if (!class_member.get_source_node()->trait_origin.has(p_trait->fqcn)) {
+			class_member.get_source_node()->trait_origin.append(p_trait->fqcn);
+		}
+	}
+}
+
+#ifdef TOOLS_ENABLED
+void GDScriptAnalyzer::copy_over_member_doc_data(GDScriptParser::MemberDocData &p_target_doc_data, const GDScriptParser::MemberDocData &p_source_doc_data) {
+	p_target_doc_data.is_deprecated = p_source_doc_data.is_deprecated;
+	p_target_doc_data.is_experimental = p_source_doc_data.is_experimental;
+	if (p_target_doc_data.description.is_empty()) {
+		p_target_doc_data.description = p_source_doc_data.description;
+	}
+	if (p_target_doc_data.deprecated_message.is_empty()) {
+		p_target_doc_data.deprecated_message = p_source_doc_data.deprecated_message;
+	}
+	if (p_target_doc_data.experimental_message.is_empty()) {
+		p_target_doc_data.experimental_message = p_source_doc_data.experimental_message;
+	}
+}
+#endif
+
 Error GDScriptAnalyzer::resolve_inheritance() {
 	return resolve_class_inheritance(parser->head, true);
 }
@@ -6414,6 +7240,11 @@ Error GDScriptAnalyzer::resolve_interface() {
 	return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
 }
 
+Error GDScriptAnalyzer::resolve_uses() {
+	resolve_class_uses(parser->head, true);
+	return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
+}
+
 Error GDScriptAnalyzer::resolve_body() {
 	resolve_class_body(parser->head, true);
 
@@ -6430,7 +7261,7 @@ Error GDScriptAnalyzer::resolve_dependencies() {
 		if (K.value.is_null()) {
 			return ERR_PARSE_ERROR;
 		}
-		K.value->raise_status(GDScriptParserRef::INHERITANCE_SOLVED);
+		K.value->raise_status(GDScriptParserRef::USES_SOLVED);
 	}
 
 	return parser->errors.is_empty() ? OK : ERR_PARSE_ERROR;
@@ -6444,6 +7275,7 @@ Error GDScriptAnalyzer::analyze() {
 		return err;
 	}
 
+	resolve_uses();
 	resolve_interface();
 	err = resolve_body();
 	if (err) {
diff --git a/modules/gdscript/gdscript_analyzer.h b/modules/gdscript/gdscript_analyzer.h
index f5937597277..28978c83c8b 100644
--- a/modules/gdscript/gdscript_analyzer.h
+++ b/modules/gdscript/gdscript_analyzer.h
@@ -65,6 +65,10 @@ class GDScriptAnalyzer {
 	HashMap<const GDScriptParser::ClassNode *, Ref<GDScriptParserRef>> external_class_parser_cache;
 	bool static_context = false;
 
+#ifdef TOOLS_ENABLED
+	//Traits are new and still experimental. Emit a warning once during analysis if their usage is detected.
+	bool experimental_traits_warned = false; // @todo: remove experimental tag in 27.1-rc.1
+#endif
 	/// @name Tests for detecting invalid overloading of script members
 	/// @{
 	static _FORCE_INLINE_ bool has_member_name_conflict_in_script_class(const StringName &p_name, const GDScriptParser::ClassNode *p_current_class_node, const GDScriptParser::Node *p_member);
@@ -88,6 +92,10 @@ class GDScriptAnalyzer {
 	void resolve_class_interface(GDScriptParser::ClassNode *p_class, bool p_recursive);
 	void resolve_class_body(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source = nullptr);
 	void resolve_class_body(GDScriptParser::ClassNode *p_class, bool p_recursive);
+	void resolve_class_uses(GDScriptParser::ClassNode *p_class, const GDScriptParser::Node *p_source = nullptr);
+	void resolve_class_uses(GDScriptParser::ClassNode *p_class, bool p_recursive);
+	// Prints a warning the first time a trait is discovered unless the warning is suppressed
+	void _warn_experimental_trait(const GDScriptParser::Node *p_source);
 	void resolve_function_signature(GDScriptParser::FunctionNode *p_function, const GDScriptParser::Node *p_source = nullptr, bool p_is_lambda = false);
 	void resolve_function_body(GDScriptParser::FunctionNode *p_function, bool p_is_lambda = false);
 	void resolve_node(GDScriptParser::Node *p_node, bool p_is_root = true);
@@ -176,9 +184,17 @@ class GDScriptAnalyzer {
 	void is_shadowing(GDScriptParser::IdentifierNode *p_identifier, const String &p_context, const bool p_in_local_scope);
 #endif
 
+	// Resolving Traits Helpers.
+	void override_member_function(GDScriptParser::FunctionNode *p_target_function, const GDScriptParser::FunctionNode *p_source_function, const String &p_trait_name);
+	void extend_class(GDScriptParser::ClassNode *p_class, const GDScriptParser::ClassNode *p_trait, const GDScriptParser::Node *p_trait_name_node, const String &p_trait_name);
+#ifdef TOOLS_ENABLED
+	void copy_over_member_doc_data(GDScriptParser::MemberDocData &p_target_doc_data, const GDScriptParser::MemberDocData &p_source_doc_data);
+#endif
+
 public:
 	Error resolve_inheritance();
 	Error resolve_interface();
+	Error resolve_uses();
 	Error resolve_body();
 	Error resolve_dependencies();
 	Error analyze();
diff --git a/modules/gdscript/gdscript_byte_codegen.cpp b/modules/gdscript/gdscript_byte_codegen.cpp
index e6ecef1d58b..377db9f8af2 100644
--- a/modules/gdscript/gdscript_byte_codegen.cpp
+++ b/modules/gdscript/gdscript_byte_codegen.cpp
@@ -682,6 +682,12 @@ void GDScriptByteCodeGenerator::write_type_test(const Address &p_target, const A
 			append(p_source);
 			append(p_type.native_type);
 		} break;
+		case GDScriptDataType::GDTRAIT: {
+			append_opcode(GDScriptFunction::OPCODE_TYPE_TEST_TRAIT);
+			append(p_target);
+			append(p_source);
+			append(p_type.trait_type);
+		} break;
 		case GDScriptDataType::SCRIPT:
 		case GDScriptDataType::GDSCRIPT: {
 			const Variant &script = p_type.script_type;
@@ -1057,6 +1063,13 @@ void GDScriptByteCodeGenerator::write_cast(const Address &p_target, const Addres
 			append_opcode(GDScriptFunction::OPCODE_CAST_TO_NATIVE);
 			index = get_constant_pos(nc) | (GDScriptFunction::ADDR_TYPE_CONSTANT << GDScriptFunction::ADDR_BITS);
 		} break;
+		case GDScriptDataType::GDTRAIT: {
+			append_opcode(GDScriptFunction::OPCODE_CAST_TO_TRAIT);
+			append(p_source);
+			append(p_target);
+			append(p_target.type.trait_type);
+			return;
+		} break;
 		case GDScriptDataType::SCRIPT:
 		case GDScriptDataType::GDSCRIPT: {
 			Variant script = p_type.script_type;
diff --git a/modules/gdscript/gdscript_cache.cpp b/modules/gdscript/gdscript_cache.cpp
index 5acbd1cc481..919f93864ff 100644
--- a/modules/gdscript/gdscript_cache.cpp
+++ b/modules/gdscript/gdscript_cache.cpp
@@ -99,13 +99,21 @@ Error GDScriptParserRef::raise_status(Status p_new_status) {
 				result = get_analyzer()->resolve_inheritance();
 			} break;
 			case INHERITANCE_SOLVED: {
+				status = USES_SOLVED;
+				result = get_analyzer()->resolve_uses();
+			} break;
+			case USES_SOLVED: {
 				status = INTERFACE_SOLVED;
 				result = get_analyzer()->resolve_interface();
 			} break;
 			case INTERFACE_SOLVED: {
-				status = FULLY_SOLVED;
+				status = BODY_SOLVED;
 				result = get_analyzer()->resolve_body();
 			} break;
+			case BODY_SOLVED: {
+				status = FULLY_SOLVED;
+				result = get_analyzer()->resolve_dependencies();
+			} break;
 			case FULLY_SOLVED: {
 				return result;
 			}
diff --git a/modules/gdscript/gdscript_cache.h b/modules/gdscript/gdscript_cache.h
index 632dfff9300..f95485accc5 100644
--- a/modules/gdscript/gdscript_cache.h
+++ b/modules/gdscript/gdscript_cache.h
@@ -56,7 +56,9 @@ class GDScriptParserRef : public RefCounted {
 		EMPTY,
 		PARSED,
 		INHERITANCE_SOLVED,
+		USES_SOLVED,
 		INTERFACE_SOLVED,
+		BODY_SOLVED,
 		FULLY_SOLVED,
 	};
 
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index eef9045bd68..2ae473f6d7b 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -147,6 +147,10 @@ GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::D
 			result.script_type = result.script_type_ref.ptr();
 			result.native_type = p_datatype.native_type;
 		} break;
+		case GDScriptParser::DataType::TRAIT: {
+			result.kind = GDScriptDataType::GDTRAIT;
+			result.trait_type = p_datatype.class_type->fqcn;
+		} break;
 		case GDScriptParser::DataType::CLASS: {
 			if (p_handle_metatype && p_datatype.is_meta_type) {
 				result.kind = GDScriptDataType::NATIVE;
@@ -366,6 +370,7 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 					}
 				} break;
 				case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
+				case GDScriptParser::IdentifierNode::MEMBER_TRAIT:
 				case GDScriptParser::IdentifierNode::MEMBER_CLASS: {
 					// Try class constants.
 					GDScript *owner = codegen.script;
@@ -3000,6 +3005,11 @@ Error GDScriptCompiler::_prepare_compilation(GDScript *p_script, const GDScriptP
 }
 
 Error GDScriptCompiler::_compile_class(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+	if (p_class->type == GDScriptParser::Node::TRAIT) {
+		// No need to compile traits.
+		return OK;
+	}
+
 	// Compile member functions, getters, and setters.
 	for (int i = 0; i < p_class->members.size(); i++) {
 		const GDScriptParser::ClassNode::Member &member = p_class->members[i];
@@ -3148,6 +3158,7 @@ void GDScriptCompiler::make_scripts(GDScript *p_script, const GDScriptParser::Cl
 	p_script->local_name = p_class->identifier ? p_class->identifier->name : StringName();
 	p_script->global_name = p_class->get_global_name();
 	p_script->simplified_icon_path = p_class->simplified_icon_path;
+	p_script->traits_fqtn = p_class->traits_fqtn;
 
 	HashMap<StringName, Ref<GDScript>> old_subclasses;
 
@@ -3325,6 +3336,11 @@ Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_scri
 	// Create scripts for subclasses beforehand so they can be referenced
 	make_scripts(p_script, root, p_keep_state);
 
+	if (parser->is_file_trait()) {
+		// No need to compile traits.
+		return GDScriptCache::finish_compiling(main_script->path);
+	}
+
 	main_script->_owner = nullptr;
 	Error err = _prepare_compilation(main_script, parser->get_tree(), p_keep_state);
 
diff --git a/modules/gdscript/gdscript_disassembler.cpp b/modules/gdscript/gdscript_disassembler.cpp
index 5c0e0fb0519..7e21b6411dc 100644
--- a/modules/gdscript/gdscript_disassembler.cpp
+++ b/modules/gdscript/gdscript_disassembler.cpp
@@ -235,6 +235,16 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 
 				incr += 4;
 			} break;
+			case OPCODE_TYPE_TEST_TRAIT: {
+				text += "type test ";
+				text += DADDR(1);
+				text += " = ";
+				text += DADDR(2);
+				text += " is trait ";
+				text += get_global_name(_code_ptr[ip + 3]);
+
+				incr += 4;
+			} break;
 			case OPCODE_TYPE_TEST_SCRIPT: {
 				text += "type test ";
 				text += DADDR(1);
@@ -508,6 +518,16 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 
 				incr += 4;
 			} break;
+			case OPCODE_CAST_TO_TRAIT: {
+				text += "cast trait ";
+				text += DADDR(2);
+				text += " = ";
+				text += DADDR(1);
+				text += " as trait ";
+				text += get_global_name(_code_ptr[ip + 3]);
+
+				incr += 4;
+			} break;
 			case OPCODE_CAST_TO_SCRIPT: {
 				text += "cast ";
 				text += DADDR(2);
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 3ca66ef3146..970c80933ac 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -963,13 +963,13 @@ static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_a
 			r_result.insert(option.display, option);
 		}
 
-		List<StringName> global_script_classes;
-		ScriptServer::get_global_class_list(&global_script_classes);
-		for (const StringName &E : global_script_classes) {
-			if (!ClassDB::is_parent_class(ScriptServer::get_global_class_native_base(E), "Node")) {
+		LocalVector<StringName> global_script_classes;
+		ScriptServer::get_global_class_list(global_script_classes);
+		for (const StringName &class_name : global_script_classes) {
+			if (!ClassDB::is_parent_class(ScriptServer::get_global_class_native_base(class_name), "Node")) {
 				continue;
 			}
-			ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
+			ScriptLanguage::CodeCompletionOption option(class_name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 			option.insert_text = option.display.quote(p_quote_style);
 			r_result.insert(option.display, option);
 		}
@@ -1053,15 +1053,15 @@ static void _find_global_enums(HashMap<String, ScriptLanguage::CodeCompletionOpt
 	}
 }
 
-static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
+static void _list_available_types(bool p_inherit_only, bool p_include_trait, GDScriptParser::CompletionContext &p_context, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	// Built-in Variant Types
 	_find_built_in_variants(r_result, true);
 
-	List<StringName> native_types;
-	ClassDB::get_class_list(&native_types);
-	for (const StringName &E : native_types) {
-		if (ClassDB::is_class_exposed(E) && !Engine::get_singleton()->has_singleton(E)) {
-			ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
+	LocalVector<StringName> native_types;
+	ClassDB::get_class_list(native_types);
+	for (const StringName &type : native_types) {
+		if (ClassDB::is_class_exposed(type) && !Engine::get_singleton()->has_singleton(type)) {
+			ScriptLanguage::CodeCompletionOption option(type, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 			r_result.insert(option.display, option);
 		}
 	}
@@ -1089,6 +1089,12 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 						ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_LOCAL + location_offset);
 						r_result.insert(option.display, option);
 					} break;
+					case GDScriptParser::ClassNode::Member::TRAIT: {
+						if (p_include_trait) {
+							ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_LOCAL + location_offset);
+							r_result.insert(option.display, option);
+						}
+					} break;
 					case GDScriptParser::ClassNode::Member::ENUM: {
 						if (!p_inherit_only) {
 							ScriptLanguage::CodeCompletionOption option(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM, ScriptLanguage::LOCATION_LOCAL + location_offset);
@@ -1111,10 +1117,10 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 	}
 
 	// Global scripts
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
-	for (const StringName &E : global_classes) {
-		ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
+	for (const StringName &class_name : global_classes) {
+		ScriptLanguage::CodeCompletionOption option(class_name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
 		r_result.insert(option.display, option);
 	}
 
@@ -1186,6 +1192,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 							option.default_value = member.constant->initializer->reduced_value;
 						}
 						break;
+					case GDScriptParser::ClassNode::Member::TRAIT:
 					case GDScriptParser::ClassNode::Member::CLASS:
 						if (p_only_functions) {
 							continue;
@@ -1266,6 +1273,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 
 	while (!base_type.has_no_type()) {
 		switch (base_type.kind) {
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS: {
 				_find_identifiers_in_class(base_type.class_type, p_only_functions, p_types_only, base_type.is_meta_type, false, p_add_braces, r_result, p_recursion_depth);
 				// This already finds all parent identifiers, so we are done.
@@ -1570,7 +1578,7 @@ static void _find_identifiers(const GDScriptParser::CompletionContext &p_context
 	}
 
 	static const char *_keywords_with_space[] = {
-		"and", "not", "or", "in", "as", "class", "class_name", "extends", "is", "func", "signal", "await",
+		"and", "not", "or", "in", "as", "class", "class_name", "trait", "trait_name", "extends", "uses", "is", "func", "signal", "await",
 		"const", "enum", "static", "var", "if", "elif", "else", "for", "match", "when", "while",
 		nullptr
 	};
@@ -1634,10 +1642,10 @@ static void _find_identifiers(const GDScriptParser::CompletionContext &p_context
 	_find_global_enums(r_result);
 
 	// Global classes
-	List<StringName> global_classes;
-	ScriptServer::get_global_class_list(&global_classes);
-	for (const StringName &E : global_classes) {
-		ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
+	LocalVector<StringName> global_classes;
+	ScriptServer::get_global_class_list(global_classes);
+	for (const StringName &class_name : global_classes) {
+		ScriptLanguage::CodeCompletionOption option(class_name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
 		r_result.insert(option.display, option);
 	}
 }
@@ -1897,6 +1905,7 @@ static bool _guess_expression_type(GDScriptParser::CompletionContext &p_context,
 		r_type = _type_from_variant(p_expression->reduced_value, p_context);
 		switch (p_expression->get_datatype().kind) {
 			case GDScriptParser::DataType::ENUM:
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS:
 				r_type.type = p_expression->get_datatype();
 				break;
@@ -2273,7 +2282,7 @@ static bool _guess_expression_type(GDScriptParser::CompletionContext &p_context,
 	}
 
 	// If the found type was not fully analyzed we analyze it now.
-	if (found && r_type.type.kind == GDScriptParser::DataType::CLASS && !r_type.type.class_type->resolved_body) {
+	if (found && (r_type.type.kind == GDScriptParser::DataType::CLASS || r_type.type.kind == GDScriptParser::DataType::TRAIT) && !r_type.type.class_type->resolved_body) {
 		Error err;
 		Ref<GDScriptParserRef> r = GDScriptCache::get_parser(r_type.type.script_path, GDScriptParserRef::FULLY_SOLVED, err);
 	}
@@ -2311,6 +2320,7 @@ static bool _guess_identifier_type(GDScriptParser::CompletionContext &p_context,
 		case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
 		case GDScriptParser::IdentifierNode::MEMBER_FUNCTION:
 		case GDScriptParser::IdentifierNode::MEMBER_SIGNAL:
+		case GDScriptParser::IdentifierNode::MEMBER_TRAIT:
 		case GDScriptParser::IdentifierNode::MEMBER_CLASS:
 		case GDScriptParser::IdentifierNode::INHERITED_VARIABLE:
 		case GDScriptParser::IdentifierNode::STATIC_VARIABLE:
@@ -2436,6 +2446,7 @@ static bool _guess_identifier_type(GDScriptParser::CompletionContext &p_context,
 		GDScriptParser::DataType base_type = p_context.current_class->base_type;
 		while (base_type.is_set()) {
 			switch (base_type.kind) {
+				case GDScriptParser::DataType::TRAIT:
 				case GDScriptParser::DataType::CLASS:
 					if (base_type.class_type->has_function(p_context.current_function->identifier->name)) {
 						GDScriptParser::FunctionNode *parent_function = base_type.class_type->get_member(p_context.current_function->identifier->name).function;
@@ -2547,6 +2558,7 @@ static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &
 	bool is_static = base_type.is_meta_type;
 	while (base_type.is_set()) {
 		switch (base_type.kind) {
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS:
 				if (base_type.class_type->has_member(p_identifier)) {
 					const GDScriptParser::ClassNode::Member &member = base_type.class_type->get_member(p_identifier);
@@ -2607,6 +2619,12 @@ static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &
 							}
 							r_type = _callable_type_from_method_info(member.function->info);
 							return true;
+						case GDScriptParser::ClassNode::Member::TRAIT:
+							r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+							r_type.type.kind = GDScriptParser::DataType::TRAIT;
+							r_type.type.class_type = member.m_class;
+							r_type.type.is_meta_type = true;
+							return true;
 						case GDScriptParser::ClassNode::Member::CLASS:
 							r_type.type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
 							r_type.type.kind = GDScriptParser::DataType::CLASS;
@@ -2805,6 +2823,7 @@ static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContex
 
 	while (base_type.is_set() && !base_type.is_variant()) {
 		switch (base_type.kind) {
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS:
 				if (base_type.class_type->has_function(p_method)) {
 					GDScriptParser::FunctionNode *method = base_type.class_type->get_member(p_method).function;
@@ -2958,6 +2977,7 @@ static void _list_call_arguments(GDScriptParser::CompletionContext &p_context, c
 
 	while (base_type.is_set() && !base_type.is_variant()) {
 		switch (base_type.kind) {
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS: {
 				if (base_type.is_meta_type && method == SNAME("new")) {
 					const GDScriptParser::ClassNode *current = base_type.class_type;
@@ -3102,6 +3122,7 @@ static void _list_call_arguments(GDScriptParser::CompletionContext &p_context, c
 								n++;
 							}
 						} break;
+						case GDScriptParser::DataType::TRAIT:
 						case GDScriptParser::DataType::CLASS: {
 							GDScriptParser::ClassNode *clss = tweened_object->datatype.class_type;
 							native_type = clss->base_type.native_type;
@@ -3527,7 +3548,30 @@ ::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_pa
 			}
 		} break;
 		case GDScriptParser::COMPLETION_INHERIT_TYPE: {
-			_list_available_types(true, completion_context, options);
+			_list_available_types(true, false, completion_context, options);
+			r_forced = true;
+		} break;
+		case GDScriptParser::COMPLETION_USES_TYPE: {
+			const GDScriptParser::ClassNode *current = completion_context.current_class;
+			for (const GDScriptParser::ClassNode::Member &member : current->members) {
+				switch (member.type) {
+					case GDScriptParser::ClassNode::Member::TRAIT:
+					case GDScriptParser::ClassNode::Member::CLASS:
+						if (member.m_class && member.m_class->identifier) {
+							ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_LOCAL);
+							options.insert(option.display, option);
+						}
+						break;
+					default:
+						break;
+				}
+			}
+			LocalVector<StringName> global_classes;
+			ScriptServer::get_global_class_list(global_classes);
+			for (const StringName &E : global_classes) {
+				ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS, ScriptLanguage::LOCATION_OTHER_USER_CODE);
+				options.insert(option.display, option);
+			}
 			r_forced = true;
 		} break;
 		case GDScriptParser::COMPLETION_TYPE_NAME_OR_VOID: {
@@ -3536,11 +3580,11 @@ ::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_pa
 		}
 			[[fallthrough]];
 		case GDScriptParser::COMPLETION_TYPE_NAME: {
-			_list_available_types(false, completion_context, options);
+			_list_available_types(false, true, completion_context, options);
 			r_forced = true;
 		} break;
 		case GDScriptParser::COMPLETION_PROPERTY_DECLARATION_OR_TYPE: {
-			_list_available_types(false, completion_context, options);
+			_list_available_types(false, false, completion_context, options);
 			ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(get.display, get);
 			ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
@@ -3950,6 +3994,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 
 	while (true) {
 		switch (base_type.kind) {
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS: {
 				ERR_FAIL_NULL_V(base_type.class_type, ERR_BUG);
 
@@ -3969,6 +4014,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					case GDScriptParser::ClassNode::Member::UNDEFINED:
 					case GDScriptParser::ClassNode::Member::GROUP:
 						return ERR_BUG;
+					case GDScriptParser::ClassNode::Member::TRAIT:
 					case GDScriptParser::ClassNode::Member::CLASS: {
 						String doc_type_name;
 						String doc_enum_name;
@@ -4603,7 +4649,7 @@ ::Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symb
 				}
 				prev = E;
 			}
-			if (base_type.kind != GDScriptParser::DataType::CLASS) {
+			if (base_type.kind != GDScriptParser::DataType::CLASS && base_type.kind != GDScriptParser::DataType::TRAIT) {
 				GDScriptCompletionIdentifier base;
 				if (!_guess_expression_type(context, prev, base)) {
 					break;
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index 6b6cccff16a..4b4b55f2fe2 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -61,6 +61,7 @@ class GDScriptDataType {
 		NATIVE,
 		SCRIPT,
 		GDSCRIPT,
+		GDTRAIT,
 	};
 
 	Kind kind = UNINITIALIZED;
@@ -68,6 +69,7 @@ class GDScriptDataType {
 	bool has_type = false;
 	Variant::Type builtin_type = Variant::NIL;
 	StringName native_type;
+	StringName trait_type;
 	Script *script_type = nullptr;
 	Ref<Script> script_type_ref;
 
@@ -77,6 +79,8 @@ class GDScriptDataType {
 		}
 
 		switch (kind) {
+			case GDTRAIT:
+				break;
 			case UNINITIALIZED:
 				break;
 			case BUILTIN: {
@@ -260,6 +264,7 @@ class GDScriptDataType {
 		has_type = p_other.has_type;
 		builtin_type = p_other.builtin_type;
 		native_type = p_other.native_type;
+		trait_type = p_other.trait_type;
 		script_type = p_other.script_type;
 		script_type_ref = p_other.script_type_ref;
 		container_element_types = p_other.container_element_types;
@@ -281,6 +286,7 @@ class GDScriptFunction {
 		OPCODE_TYPE_TEST_ARRAY,
 		OPCODE_TYPE_TEST_DICTIONARY,
 		OPCODE_TYPE_TEST_NATIVE,
+		OPCODE_TYPE_TEST_TRAIT,
 		OPCODE_TYPE_TEST_SCRIPT,
 		OPCODE_SET_KEYED,
 		OPCODE_SET_KEYED_VALIDATED,
@@ -307,6 +313,7 @@ class GDScriptFunction {
 		OPCODE_ASSIGN_TYPED_SCRIPT,
 		OPCODE_CAST_TO_BUILTIN,
 		OPCODE_CAST_TO_NATIVE,
+		OPCODE_CAST_TO_TRAIT,
 		OPCODE_CAST_TO_SCRIPT,
 		OPCODE_CONSTRUCT, ///< Only for basic types!
 		OPCODE_CONSTRUCT_VALIDATED, ///< Only for basic types!
@@ -578,6 +585,7 @@ class GDScriptFunction {
 	String _get_call_error(const String &p_where, const Variant **p_argptrs, int p_argcount, const Variant &p_ret, const Callable::CallError &p_err) const;
 	String _get_callable_call_error(const String &p_where, const Callable &p_callable, const Variant **p_argptrs, int p_argcount, const Variant &p_ret, const Callable::CallError &p_err) const;
 	Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type);
+	bool _is_class_using_trait(Script *p_class_script, const StringName &trait_type);
 
 public:
 	static constexpr int MAX_CALL_DEPTH = 2048; ///< Limit to try to avoid crash because of a stack overflow.
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index c33a332620c..37fb146faf3 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -535,6 +535,7 @@ void GDScriptParser::synchronize() {
 
 		switch (current.type) {
 			case GDScriptTokenizer::Token::CLASS:
+			case GDScriptTokenizer::Token::TRAIT:
 			case GDScriptTokenizer::Token::FUNC:
 			case GDScriptTokenizer::Token::STATIC:
 			case GDScriptTokenizer::Token::VAR:
@@ -675,8 +676,8 @@ void GDScriptParser::parse_program() {
 		}
 	}
 
-	if (current.type == GDScriptTokenizer::Token::CLASS_NAME || current.type == GDScriptTokenizer::Token::EXTENDS) {
-		// Set range of the class to only start at extends or class_name if present.
+	if (current.type == GDScriptTokenizer::Token::TRAIT_NAME || current.type == GDScriptTokenizer::Token::CLASS_NAME || current.type == GDScriptTokenizer::Token::EXTENDS) {
+		// Set range of the class/trait to only start at extends or class_name or trait_name if present.
 		reset_extents(head, current);
 	}
 
@@ -687,11 +688,23 @@ void GDScriptParser::parse_program() {
 				PUSH_PENDING_ANNOTATIONS_TO_HEAD;
 				advance();
 				if (head->identifier != nullptr) {
-					push_error(R"("class_name" can only be used once.)");
+					push_error(R"("class_name"/ "trait_name" can only be used once.)");
 				} else {
 					parse_class_name();
 				}
 				break;
+			case GDScriptTokenizer::Token::TRAIT_NAME:
+				PUSH_PENDING_ANNOTATIONS_TO_HEAD;
+				advance();
+				if (head->identifier != nullptr) {
+					push_error(R"("trait_name"/ "class_name"  can only be used once.)");
+				} else {
+					_is_trait_file = true;
+					_is_trait = true;
+					head->type = Node::TRAIT;
+					parse_class_name();
+				}
+				break;
 			case GDScriptTokenizer::Token::EXTENDS:
 				PUSH_PENDING_ANNOTATIONS_TO_HEAD;
 				advance();
@@ -702,6 +715,12 @@ void GDScriptParser::parse_program() {
 					end_statement("superclass");
 				}
 				break;
+			case GDScriptTokenizer::Token::USES:
+				PUSH_PENDING_ANNOTATIONS_TO_HEAD;
+				advance();
+				parse_uses();
+				end_statement("superclass");
+				break;
 			case GDScriptTokenizer::Token::TK_EOF:
 				PUSH_PENDING_ANNOTATIONS_TO_HEAD;
 				can_have_class_or_extends = false;
@@ -815,7 +834,7 @@ GDScriptParser::ClassNode *GDScriptParser::find_class(const String &p_qualified_
 	} else if (head->has_member(first)) {
 		class_names = p_qualified_name.split("::");
 		GDScriptParser::ClassNode::Member member = head->get_member(first);
-		if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
+		if (member.type == GDScriptParser::ClassNode::Member::CLASS || member.type == GDScriptParser::ClassNode::Member::TRAIT) {
 			result = member.m_class;
 		}
 	}
@@ -826,7 +845,7 @@ GDScriptParser::ClassNode *GDScriptParser::find_class(const String &p_qualified_
 		GDScriptParser::ClassNode *next = nullptr;
 		if (result->has_member(current_name)) {
 			GDScriptParser::ClassNode::Member member = result->get_member(current_name);
-			if (member.type == GDScriptParser::ClassNode::Member::CLASS) {
+			if (member.type == GDScriptParser::ClassNode::Member::CLASS || member.type == GDScriptParser::ClassNode::Member::TRAIT) {
 				next = member.m_class;
 			}
 		}
@@ -847,7 +866,12 @@ bool GDScriptParser::has_class(const GDScriptParser::ClassNode *p_class) const {
 }
 
 GDScriptParser::ClassNode *GDScriptParser::parse_class(bool p_is_static) {
-	ClassNode *n_class = alloc_node<ClassNode>();
+	ClassNode *n_class;
+	if (_is_trait) {
+		n_class = alloc_node<TraitNode>();
+	} else {
+		n_class = alloc_node<ClassNode>();
+	}
 
 	ClassNode *previous_class = current_class;
 	current_class = n_class;
@@ -888,6 +912,11 @@ GDScriptParser::ClassNode *GDScriptParser::parse_class(bool p_is_static) {
 		end_statement("superclass");
 	}
 
+	while (match(GDScriptTokenizer::Token::USES)) {
+		parse_uses();
+		end_statement("superclass");
+	}
+
 	parse_class_body(multiline);
 	complete_extents(n_class);
 
@@ -946,6 +975,48 @@ void GDScriptParser::parse_extends() {
 	}
 }
 
+void GDScriptParser::parse_uses() {
+	while (true) {
+		UsesNode *uses = alloc_node<UsesNode>();
+		int chain_index = 0;
+
+		if (match(GDScriptTokenizer::Token::LITERAL)) {
+			if (previous.literal.get_type() != Variant::STRING) {
+				push_error(vformat(R"(Only strings or identifiers can be used after "uses", found "%s" instead.)", Variant::get_type_name(previous.literal.get_type())));
+			}
+			uses->path = previous.literal;
+
+			if (!match(GDScriptTokenizer::Token::PERIOD)) {
+				current_class->traits.push_back(uses);
+				complete_extents(uses);
+				return;
+			}
+		}
+
+		make_completion_context(COMPLETION_USES_TYPE, current_class, chain_index++);
+
+		if (!consume(GDScriptTokenizer::Token::IDENTIFIER, R"(Expected trait name after "uses".)")) {
+			complete_extents(uses);
+			return;
+		}
+		uses->name.push_back(parse_identifier());
+
+		while (match(GDScriptTokenizer::Token::PERIOD)) {
+			make_completion_context(COMPLETION_USES_TYPE, current_class, chain_index++);
+			if (!consume(GDScriptTokenizer::Token::IDENTIFIER, R"(Expected trait name after ".".)")) {
+				complete_extents(uses);
+				return;
+			}
+			uses->name.push_back(parse_identifier());
+		}
+		current_class->traits.push_back(uses);
+		complete_extents(uses);
+		if (!match(GDScriptTokenizer::Token::COMMA)) {
+			return;
+		}
+	}
+}
+
 template <typename T>
 void GDScriptParser::parse_class_member(T *(GDScriptParser::*p_parse_function)(bool), AnnotationInfo::TargetKind p_target, const String &p_member_kind, bool p_is_static) {
 	advance();
@@ -1039,8 +1110,17 @@ void GDScriptParser::parse_class_body(bool p_is_multiline) {
 				parse_class_member(&GDScriptParser::parse_function, AnnotationInfo::FUNCTION, "function", next_is_static);
 				break;
 			case GDScriptTokenizer::Token::CLASS:
+				if (_is_trait) {
+					push_error(R"(class can not be a member of a trait.)");
+				}
 				parse_class_member(&GDScriptParser::parse_class, AnnotationInfo::CLASS, "class");
 				break;
+			case GDScriptTokenizer::Token::TRAIT: {
+				bool previous_parsing_trait = _is_trait;
+				_is_trait = true;
+				parse_class_member(&GDScriptParser::parse_class, AnnotationInfo::TRAIT, "trait");
+				_is_trait = previous_parsing_trait; // covers the case of a trait inside a trait.
+			} break;
 			case GDScriptTokenizer::Token::ENUM:
 				parse_class_member(&GDScriptParser::parse_enum, AnnotationInfo::NONE, "enum");
 				break;
@@ -1661,9 +1741,12 @@ bool GDScriptParser::parse_function_signature(FunctionNode *p_function, SuiteNod
 	}
 #endif // TOOLS_ENABLED
 
-	/// @todo Improve token consumption so it synchronizes to a statement boundary. This way we can get into the function body with unrecognized tokens.
-	if (p_type == "lambda") {
-		return consume(GDScriptTokenizer::Token::COLON, R"(Expected ":" after lambda declaration.)");
+	if (_is_trait && !check(GDScriptTokenizer::Token::COLON)) {
+		p_function->is_bodyless = true;
+		return false;
+	} else if (p_type == "lambda") {
+		/// @todo Improve token consumption so it synchronizes to a statement boundary. This way we can get into the function body with unrecognized tokens.
+		return consume(GDScriptTokenizer::Token::COLON, vformat(R"(Expected ":" after %s declaration.)", p_type));
 	}
 	// The colon may not be present in the case of abstract functions.
 	return match(GDScriptTokenizer::Token::COLON);
@@ -1847,6 +1930,15 @@ GDScriptParser::SuiteNode *GDScriptParser::parse_suite(const String &p_context,
 		multiline = true;
 	}
 
+	if (current_function->is_bodyless) {
+		if (check(GDScriptTokenizer::Token::INDENT)) {
+			push_error(R"(Expected ":" after "function" declaration.)");
+		}
+		current_suite = suite->parent_block;
+		complete_extents(suite);
+		return suite;
+	}
+
 	if (multiline) {
 		if (!consume(GDScriptTokenizer::Token::INDENT, vformat(R"(Expected indented block after %s.)", p_context))) {
 			current_suite = suite->parent_block;
@@ -4204,6 +4296,8 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // STATIC,
 		{ &GDScriptParser::parse_call,						nullptr,                                        PREC_NONE }, // SUPER,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // TRAIT,
+		{ nullptr,                                          nullptr,                                        PREC_NONE }, // TRAIT_NAME,
+		{ nullptr,                                          nullptr,                                        PREC_NONE }, // USES,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // VAR,
 		{ nullptr,                                          nullptr,                                        PREC_NONE }, // TK_VOID,
 		{ &GDScriptParser::parse_yield,                     nullptr,                                        PREC_NONE }, // YIELD,
@@ -4515,6 +4609,7 @@ static StringName _find_narrowest_native_or_global_class(const GDScriptParser::D
 
 			return _find_narrowest_native_or_global_class(base_type);
 		} break;
+		case GDScriptParser::DataType::TRAIT:
 		case GDScriptParser::DataType::CLASS: {
 			if (p_type.is_meta_type) {
 				return GDScript::get_class_static();
@@ -4684,6 +4779,7 @@ bool GDScriptParser::export_annotations(AnnotationNode *p_annotation, Node *p_ta
 				break;
 			case GDScriptParser::DataType::NATIVE:
 			case GDScriptParser::DataType::SCRIPT:
+			case GDScriptParser::DataType::TRAIT:
 			case GDScriptParser::DataType::CLASS: {
 				const StringName class_name = _find_narrowest_native_or_global_class(export_type);
 				if (ClassDB::is_parent_class(export_type.native_type, SNAME("Resource"))) {
@@ -4761,6 +4857,7 @@ bool GDScriptParser::export_annotations(AnnotationNode *p_annotation, Node *p_ta
 					break;
 				case GDScriptParser::DataType::NATIVE:
 				case GDScriptParser::DataType::SCRIPT:
+				case GDScriptParser::DataType::TRAIT:
 				case GDScriptParser::DataType::CLASS: {
 					const StringName class_name = _find_narrowest_native_or_global_class(export_type);
 					if (ClassDB::is_parent_class(export_type.native_type, SNAME("Resource"))) {
@@ -5030,6 +5127,7 @@ bool GDScriptParser::warning_ignore_annotation(AnnotationNode *p_annotation, Nod
 				SIMPLE_CASE(Node::WHILE, WhileNode, condition)
 #undef SIMPLE_CASE
 
+				case Node::TRAIT:
 				case Node::CLASS: {
 					end_line = p_target->start_line;
 					for (const AnnotationNode *annotation : p_target->annotations) {
@@ -5230,6 +5328,7 @@ String GDScriptParser::DataType::to_string() const {
 				return GDScriptNativeClass::get_class_static();
 			}
 			return native_type.operator String();
+		case TRAIT:
 		case CLASS:
 			if (class_type->identifier != nullptr) {
 				return class_type->identifier->name.operator String();
@@ -5294,6 +5393,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 							result.hint_string = elem_type.native_type;
 						}
 						break;
+					case TRAIT:
 					case CLASS:
 						result.hint = PROPERTY_HINT_ARRAY_TYPE;
 						if (elem_type.class_type != nullptr && elem_type.class_type->get_global_name() != StringName()) {
@@ -5333,6 +5433,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 							key_hint = key_type.native_type;
 						}
 						break;
+					case TRAIT:
 					case CLASS:
 						if (key_type.class_type != nullptr && key_type.class_type->get_global_name() != StringName()) {
 							key_hint = key_type.class_type->get_global_name();
@@ -5361,6 +5462,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 							value_hint = value_type.native_type;
 						}
 						break;
+					case TRAIT:
 					case CLASS:
 						if (value_type.class_type != nullptr && value_type.class_type->get_global_name() != StringName()) {
 							value_hint = value_type.class_type->get_global_name();
@@ -5397,6 +5499,7 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 				result.class_name = native_type;
 			}
 			break;
+		case TRAIT:
 		case CLASS:
 			result.type = Variant::OBJECT;
 			if (is_meta_type) {
@@ -5773,7 +5876,11 @@ void GDScriptParser::TreePrinter::print_class(ClassNode *p_class) {
 	for (const AnnotationNode *E : p_class->annotations) {
 		print_annotation(E);
 	}
-	push_text("Class ");
+	if (p_class->type == Node::TRAIT) {
+		push_text("Trait ");
+	} else {
+		push_text("Class ");
+	}
 	if (p_class->identifier == nullptr) {
 		push_text("<unnamed>");
 	} else {
@@ -5799,12 +5906,33 @@ void GDScriptParser::TreePrinter::print_class(ClassNode *p_class) {
 
 	push_line(" :");
 
+	if (!p_class->traits.is_empty()) {
+		push_text("Uses ");
+		for (int i = 0; i < p_class->traits.size(); i++) {
+			if (i > 0) {
+				push_text(", ");
+			}
+			UsesNode *trait = p_class->traits[i];
+			if (!trait->path.is_empty()) {
+				push_text(vformat(R"("%s")", trait->path));
+			}
+			for (int j = 0; j < trait->name.size(); j++) {
+				if (j > 0) {
+					push_text(".");
+				}
+				push_text(trait->name[j]->name);
+			}
+		}
+		push_line();
+	}
+
 	increase_indent();
 
 	for (int i = 0; i < p_class->members.size(); i++) {
 		const ClassNode::Member &m = p_class->members[i];
 
 		switch (m.type) {
+			case ClassNode::Member::TRAIT:
 			case ClassNode::Member::CLASS:
 				print_class(m.m_class);
 				break;
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 50d0757d054..445c8e84cfd 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -100,9 +100,11 @@ class GDScriptParser {
 	struct SubscriptNode;
 	struct SuiteNode;
 	struct TernaryOpNode;
+	struct TraitNode;
 	struct TypeNode;
 	struct TypeTestNode;
 	struct UnaryOpNode;
+	struct UsesNode;
 	struct VariableNode;
 	struct WhileNode;
 
@@ -115,6 +117,7 @@ class GDScriptParser {
 			NATIVE,
 			SCRIPT,
 			CLASS, ///< GDScript.
+			TRAIT, ///< GDTrait.
 			ENUM, ///< Enumeration.
 			VARIANT, ///< Can be any type.
 			RESOLVING, ///< Currently resolving.
@@ -225,6 +228,7 @@ class GDScriptParser {
 				case SCRIPT:
 					return script_type == p_other.script_type;
 				case CLASS:
+				case TRAIT:
 					return class_type == p_other.class_type || class_type->fqcn == p_other.class_type->fqcn;
 				case RESOLVING:
 				case UNRESOLVED:
@@ -337,9 +341,11 @@ class GDScriptParser {
 			SUBSCRIPT,
 			SUITE,
 			TERNARY_OPERATOR,
+			TRAIT,
 			TYPE,
 			TYPE_TEST,
 			UNARY_OPERATOR,
+			USES,
 			VARIABLE,
 			WHILE,
 		};
@@ -352,6 +358,8 @@ class GDScriptParser {
 
 		DataType datatype;
 
+		Vector<String> trait_origin; // Indicates origin of Node if copied over from trait.
+
 		virtual DataType get_datatype() const { return datatype; }
 		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
 
@@ -567,6 +575,7 @@ class GDScriptParser {
 			enum Type {
 				UNDEFINED,
 				CLASS,
+				TRAIT,
 				CONSTANT,
 				FUNCTION,
 				SIGNAL,
@@ -594,7 +603,8 @@ class GDScriptParser {
 					case UNDEFINED:
 						return "<undefined member>";
 					case CLASS:
-						// All class-type members have an id.
+					case TRAIT:
+						// All class/trait-type members have an id.
 						return m_class->identifier->name;
 					case CONSTANT:
 						return constant->identifier->name;
@@ -621,6 +631,8 @@ class GDScriptParser {
 						return "???";
 					case CLASS:
 						return "class";
+					case TRAIT:
+						return "trait";
 					case CONSTANT:
 						return "constant";
 					case FUNCTION:
@@ -642,6 +654,7 @@ class GDScriptParser {
 			int get_line() const {
 				switch (type) {
 					case CLASS:
+					case TRAIT:
 						return m_class->start_line;
 					case CONSTANT:
 						return constant->start_line;
@@ -666,6 +679,7 @@ class GDScriptParser {
 			DataType get_datatype() const {
 				switch (type) {
 					case CLASS:
+					case TRAIT:
 						return m_class->get_datatype();
 					case CONSTANT:
 						return constant->get_datatype();
@@ -690,6 +704,7 @@ class GDScriptParser {
 			Node *get_source_node() const {
 				switch (type) {
 					case CLASS:
+					case TRAIT:
 						return m_class;
 					case CONSTANT:
 						return constant;
@@ -714,7 +729,11 @@ class GDScriptParser {
 			Member() {}
 
 			Member(ClassNode *p_class) {
-				type = CLASS;
+				if (p_class->type == Node::TRAIT) {
+					type = TRAIT;
+				} else {
+					type = CLASS;
+				}
 				m_class = p_class;
 			}
 			Member(ConstantNode *p_constant) {
@@ -746,7 +765,6 @@ class GDScriptParser {
 				annotation = p_annotation;
 			}
 		};
-
 		IdentifierNode *identifier = nullptr;
 		String icon_path;
 		String simplified_icon_path;
@@ -762,6 +780,9 @@ class GDScriptParser {
 		Vector<IdentifierNode *> extends; ///< List for indexing: extends A.B.C
 		DataType base_type;
 		String fqcn; ///< Fully-qualified class name. Identifies uniquely any class in the project.
+		// Used Traits.
+		Vector<UsesNode *> traits;
+		Vector<StringName> traits_fqtn; // Fully-qualified trait names. Identifies uniquely any trait used by this class.
 #ifdef TOOLS_ENABLED
 		ClassDocData doc_data;
 
@@ -772,6 +793,8 @@ class GDScriptParser {
 		}
 #endif // TOOLS_ENABLED
 
+		bool resolving_uses = false;
+		bool resolved_uses = false;
 		bool resolved_interface = false;
 		bool resolved_body = false;
 
@@ -862,6 +885,7 @@ class GDScriptParser {
 		ParameterNode *rest_parameter = nullptr;
 		TypeNode *return_type = nullptr;
 		SuiteNode *body = nullptr;
+		bool is_bodyless = false; // Used for Traits with no body.
 		bool is_abstract = false;
 		bool is_static = false; ///< For lambdas it's determined in the analyzer.
 		bool is_coroutine = false;
@@ -910,6 +934,7 @@ class GDScriptParser {
 			MEMBER_FUNCTION,
 			MEMBER_SIGNAL,
 			MEMBER_CLASS,
+			MEMBER_TRAIT,
 			INHERITED_VARIABLE,
 			STATIC_VARIABLE,
 			NATIVE_CLASS,
@@ -1208,6 +1233,13 @@ class GDScriptParser {
 		}
 	};
 
+	struct TraitNode : public ClassNode {
+		// Extends ClassNode to maintain Class features (so parsed by same methods) without duplication.
+		TraitNode() {
+			type = TRAIT;
+		}
+	};
+
 	struct TypeNode : public Node {
 		Vector<IdentifierNode *> type_chain;
 		Vector<TypeNode *> container_types;
@@ -1248,6 +1280,17 @@ class GDScriptParser {
 		}
 	};
 
+	struct UsesNode : public Node {
+		String path;
+		Vector<IdentifierNode *> name; // List for indexing Trait: uses A.B.C
+		String fqtn; // Fully-qualified trait names.
+		Vector<StringName> traits_fqtn; // From traits used by this trait.
+
+		UsesNode() {
+			type = USES;
+		}
+	};
+
 	struct VariableNode : public AssignableNode {
 		enum PropertyStyle {
 			PROP_NONE,
@@ -1302,6 +1345,7 @@ class GDScriptParser {
 		COMPLETION_GET_NODE, ///< Get node with $ notation.
 		COMPLETION_IDENTIFIER, ///< List available identifiers in scope.
 		COMPLETION_INHERIT_TYPE, ///< Type after extends. Exclude non-viable types (built-ins, enums, void). Includes subtypes using the argument index.
+		COMPLETION_USES_TYPE, // Type after uses.Includes traits and sub-traits using the argument index.
 		COMPLETION_METHOD, ///< List available methods in scope.
 		COMPLETION_OVERRIDE_METHOD, ///< Override implementation, also for native virtuals.
 		COMPLETION_PROPERTY_DECLARATION, ///< Property declaration (get, set).
@@ -1342,6 +1386,8 @@ class GDScriptParser {
 	friend class GDScriptAnalyzer;
 	friend class GDScriptParserRef;
 
+	bool _is_trait = false; // True when parsing a trait, not a class.
+	bool _is_trait_file = false;
 	bool _is_tool = false;
 	String script_path;
 	bool for_completion = false;
@@ -1392,13 +1438,14 @@ class GDScriptParser {
 			NONE = 0,
 			SCRIPT = 1 << 0,
 			CLASS = 1 << 1,
-			VARIABLE = 1 << 2,
-			CONSTANT = 1 << 3,
-			SIGNAL = 1 << 4,
-			FUNCTION = 1 << 5,
-			STATEMENT = 1 << 6,
-			STANDALONE = 1 << 7,
-			CLASS_LEVEL = CLASS | VARIABLE | CONSTANT | SIGNAL | FUNCTION,
+			TRAIT = 1 << 2,
+			VARIABLE = 1 << 3,
+			CONSTANT = 1 << 4,
+			SIGNAL = 1 << 5,
+			FUNCTION = 1 << 6,
+			STATEMENT = 1 << 7,
+			STANDALONE = 1 << 8,
+			CLASS_LEVEL = CLASS | TRAIT | VARIABLE | CONSTANT | SIGNAL | FUNCTION,
 		};
 		uint32_t target_kind = 0; ///< Flags.
 		AnnotationAction apply = nullptr;
@@ -1455,6 +1502,12 @@ class GDScriptParser {
 		node->next = list;
 		list = node;
 
+		if (_is_trait) {
+			if (current_class) {
+				node->trait_origin.append(current_class->fqcn);
+			}
+		}
+
 		reset_extents(node, previous);
 		nodes_in_progress.push_back(node);
 
@@ -1520,6 +1573,7 @@ class GDScriptParser {
 	ClassNode *parse_class(bool p_is_static);
 	void parse_class_name();
 	void parse_extends();
+	void parse_uses();
 	void parse_class_body(bool p_is_multiline);
 	template <typename T>
 	void parse_class_member(T *(GDScriptParser::*p_parse_function)(bool), AnnotationInfo::TargetKind p_target, const String &p_member_kind, bool p_is_static = false);
@@ -1617,6 +1671,7 @@ class GDScriptParser {
 	Error parse_binary(const Vector<uint8_t> &p_binary, const String &p_script_path);
 	ClassNode *get_tree() const { return head; }
 	bool is_tool() const { return _is_tool; }
+	bool is_file_trait() const { return _is_trait_file; }
 	Ref<GDScriptParserRef> get_depended_parser_for(const String &p_path);
 	const HashMap<String, Ref<GDScriptParserRef>> &get_depended_parsers();
 	ClassNode *find_class(const String &p_qualified_name) const;
diff --git a/modules/gdscript/gdscript_tokenizer.cpp b/modules/gdscript/gdscript_tokenizer.cpp
index 5a17cbba03e..92a9a944a65 100644
--- a/modules/gdscript/gdscript_tokenizer.cpp
+++ b/modules/gdscript/gdscript_tokenizer.cpp
@@ -128,6 +128,8 @@ static const char *token_names[] = {
 	"static", // STATIC,
 	"super", // SUPER,
 	"trait", // TRAIT,
+	"trait_name", // TRAIT_NAME,
+	"uses", // USES,
 	"var", // VAR,
 	"void", // TK_VOID,
 	"yield", // YIELD,
@@ -257,6 +259,8 @@ bool GDScriptTokenizer::Token::is_node_name() const {
 		case STATIC:
 		case SUPER:
 		case TRAIT:
+		case TRAIT_NAME:
+		case USES:
 		case UNDERSCORE:
 		case VAR:
 		case TK_VOID:
@@ -539,6 +543,9 @@ GDScriptTokenizer::Token GDScriptTokenizerText::annotation() {
 	KEYWORD("super", Token::SUPER)           \
 	KEYWORD_GROUP('t')                       \
 	KEYWORD("trait", Token::TRAIT)           \
+	KEYWORD("trait_name", Token::TRAIT_NAME) \
+	KEYWORD_GROUP('u')                       \
+	KEYWORD("uses", Token::USES)             \
 	KEYWORD_GROUP('v')                       \
 	KEYWORD("var", Token::VAR)               \
 	KEYWORD("void", Token::TK_VOID)          \
diff --git a/modules/gdscript/gdscript_tokenizer.h b/modules/gdscript/gdscript_tokenizer.h
index fbbbdbc9e35..181c69a9bd2 100644
--- a/modules/gdscript/gdscript_tokenizer.h
+++ b/modules/gdscript/gdscript_tokenizer.h
@@ -133,6 +133,8 @@ class GDScriptTokenizer {
 			STATIC,
 			SUPER,
 			TRAIT,
+			TRAIT_NAME,
+			USES,
 			VAR,
 			TK_VOID, ///< Conflict with WinAPI.
 			YIELD,
diff --git a/modules/gdscript/gdscript_tokenizer_buffer.h b/modules/gdscript/gdscript_tokenizer_buffer.h
index 1d76842ef06..59e096e8683 100644
--- a/modules/gdscript/gdscript_tokenizer_buffer.h
+++ b/modules/gdscript/gdscript_tokenizer_buffer.h
@@ -47,7 +47,7 @@ class GDScriptTokenizerBuffer : public GDScriptTokenizer {
 		COMPRESS_ZSTD,
 	};
 
-	static constexpr uint32_t TOKENIZER_VERSION = 101;
+	static constexpr uint32_t TOKENIZER_VERSION = 102;
 	static constexpr uint32_t TOKEN_BYTE_MASK = 0x80;
 	static constexpr uint32_t TOKEN_BITS = 8;
 	static constexpr uint32_t TOKEN_MASK = (1 << (TOKEN_BITS - 1)) - 1;
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 505d6406934..28d53010f58 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -215,6 +215,14 @@ String GDScriptFunction::_get_callable_call_error(const String &p_where, const C
 	}
 }
 
+bool GDScriptFunction::_is_class_using_trait(Script *p_class_script, const StringName &trait_type) {
+	GDScript *gdscript = Object::cast_to<GDScript>(p_class_script);
+	if (gdscript && gdscript->traits_fqtn.has(trait_type)) {
+		return true;
+	}
+	return false;
+}
+
 void (*type_init_function_table[])(Variant *) = {
 	nullptr, // NIL (shouldn't be called).
 	&VariantInitializer<bool>::init, // BOOL.
@@ -266,6 +274,7 @@ void (*type_init_function_table[])(Variant *) = {
 		&&OPCODE_TYPE_TEST_ARRAY,                        \
 		&&OPCODE_TYPE_TEST_DICTIONARY,                   \
 		&&OPCODE_TYPE_TEST_NATIVE,                       \
+		&&OPCODE_TYPE_TEST_TRAIT,                        \
 		&&OPCODE_TYPE_TEST_SCRIPT,                       \
 		&&OPCODE_SET_KEYED,                              \
 		&&OPCODE_SET_KEYED_VALIDATED,                    \
@@ -292,6 +301,7 @@ void (*type_init_function_table[])(Variant *) = {
 		&&OPCODE_ASSIGN_TYPED_SCRIPT,                    \
 		&&OPCODE_CAST_TO_BUILTIN,                        \
 		&&OPCODE_CAST_TO_NATIVE,                         \
+		&&OPCODE_CAST_TO_TRAIT,                          \
 		&&OPCODE_CAST_TO_SCRIPT,                         \
 		&&OPCODE_CONSTRUCT,                              \
 		&&OPCODE_CONSTRUCT_VALIDATED,                    \
@@ -946,6 +956,34 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			}
 			DISPATCH_OPCODE;
 
+			OPCODE(OPCODE_TYPE_TEST_TRAIT) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(dst, 0);
+				GET_VARIANT_PTR(value, 1);
+
+				int trait_type_idx = _code_ptr[ip + 3];
+				GD_ERR_BREAK(trait_type_idx < 0 || trait_type_idx >= _global_names_count);
+				const StringName trait_type = _global_names_ptr[trait_type_idx];
+
+				bool was_freed = false;
+				Object *object = value->get_validated_object_with_check(was_freed);
+				if (was_freed) {
+					err_text = "Left operand of 'is' is a previously freed instance.";
+					OPCODE_BREAK;
+				}
+
+				bool result = false;
+				if (object && object->get_script_instance()) {
+					Script *script_ptr = object->get_script_instance()->get_script().ptr();
+					result = _is_class_using_trait(script_ptr, trait_type);
+				}
+
+				*dst = result;
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
 			OPCODE(OPCODE_TYPE_TEST_SCRIPT) {
 				CHECK_SPACE(4);
 
@@ -1679,6 +1717,47 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			}
 			DISPATCH_OPCODE;
 
+			OPCODE(OPCODE_CAST_TO_TRAIT) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(src, 0);
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(to_type, 2);
+
+				int trait_type_idx = _code_ptr[ip + 3];
+				GD_ERR_BREAK(trait_type_idx < 0 || trait_type_idx >= _global_names_count);
+				const StringName trait_type = _global_names_ptr[trait_type_idx];
+
+#ifdef DEBUG_ENABLED
+				if (src->operator Object *() && !src->get_validated_object()) {
+					err_text = "Trying to cast a freed object.";
+					OPCODE_BREAK;
+				}
+				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
+					err_text = "Trying to assign a non-object value to a variable of trait '" + String(trait_type).replace("::", ".") + "'.";
+					OPCODE_BREAK;
+				}
+#endif
+				bool valid = false;
+
+				if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
+					ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
+
+					if (scr_inst) {
+						Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
+						valid = _is_class_using_trait(src_type, trait_type);
+					}
+				}
+
+				if (valid) {
+					*dst = *src; // Valid cast, copy the source object
+				} else {
+					*dst = Variant(); // invalid cast, assign NULL
+				}
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
 			OPCODE(OPCODE_CAST_TO_SCRIPT) {
 				CHECK_SPACE(4);
 				GET_VARIANT_PTR(src, 0);
diff --git a/modules/gdscript/gdscript_warning.cpp b/modules/gdscript/gdscript_warning.cpp
index 57ac5972077..8485d99d71b 100644
--- a/modules/gdscript/gdscript_warning.cpp
+++ b/modules/gdscript/gdscript_warning.cpp
@@ -170,6 +170,12 @@ String GDScriptWarning::get_message() const {
 			return vformat(R"*(The default value uses "%s" which won't return nodes in the scene tree before "_ready()" is called. Use the "@onready" annotation to solve this.)*", symbols[0]);
 		case ONREADY_WITH_EXPORT:
 			return R"("@onready" will set the default value after "@export" takes effect and will override it.)";
+		case UNUSED_STATIC_OVERRIDING_TRAIT:
+			return R"(Overridden static without using "static" keyword.)";
+		case EXPERIMENTAL_TRAIT: // @todo: remove experimental tag in 27.1-rc.1
+			return "Trait usage detected. This feature is still experimental and potentially subject to change in future versions.\n"
+				   "If you run into any issues please open an issue on GitHub: https://github.com/Redot-Engine/redot-engine/issues\n"
+				   "This message can be disabled in Project Settings > Debug > GDScript > Show Experimental Trait Warning.";
 #ifndef DISABLE_DEPRECATED
 		// Never produced. These warnings migrated from 3.x by mistake.
 		case PROPERTY_USED_AS_FUNCTION: // There is already an error.
@@ -246,6 +252,8 @@ String GDScriptWarning::get_name_from_code(Code p_code) {
 		PNAME("NATIVE_METHOD_OVERRIDE"),
 		PNAME("GET_NODE_DEFAULT_WITHOUT_ONREADY"),
 		PNAME("ONREADY_WITH_EXPORT"),
+		PNAME("UNUSED_STATIC_OVERRIDING_TRAIT"),
+		PNAME("EXPERIMENTAL_TRAIT"),
 #ifndef DISABLE_DEPRECATED
 		"PROPERTY_USED_AS_FUNCTION",
 		"CONSTANT_USED_AS_FUNCTION",
diff --git a/modules/gdscript/gdscript_warning.h b/modules/gdscript/gdscript_warning.h
index 5bcd45541ee..e5e1bdfbf58 100644
--- a/modules/gdscript/gdscript_warning.h
+++ b/modules/gdscript/gdscript_warning.h
@@ -97,6 +97,8 @@ class GDScriptWarning {
 		NATIVE_METHOD_OVERRIDE, //< The script method overrides a native one, this may not work as intended.
 		GET_NODE_DEFAULT_WITHOUT_ONREADY, //< A class variable uses `get_node()` (or the `$` notation) as its default value, but does not use the @onready annotation.
 		ONREADY_WITH_EXPORT, //< The `@onready` annotation will set the value after `@export` which is likely not intended.
+		UNUSED_STATIC_OVERRIDING_TRAIT, // Overridden static without using "static" keyword.
+		EXPERIMENTAL_TRAIT, //< Traits are still experimental, and their syntax and behavior may change in future releases.
 #ifndef DISABLE_DEPRECATED
 		PROPERTY_USED_AS_FUNCTION, //< Function not found, but there's a property with the same name.
 		CONSTANT_USED_AS_FUNCTION, //< Function not found, but there's a constant with the same name.
@@ -154,6 +156,8 @@ class GDScriptWarning {
 		ERROR, // NATIVE_METHOD_OVERRIDE // May not work as expected.
 		ERROR, // GET_NODE_DEFAULT_WITHOUT_ONREADY // May not work as expected.
 		ERROR, // ONREADY_WITH_EXPORT // May not work as expected.
+		WARN, // UNUSED_STATIC_OVERRIDING_TRAIT
+		WARN, // EXPERIMENTAL_TRAIT
 #ifndef DISABLE_DEPRECATED
 		WARN, // PROPERTY_USED_AS_FUNCTION
 		WARN, // CONSTANT_USED_AS_FUNCTION
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index b354129c8ac..562f96099b7 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -466,6 +466,7 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 				parse_function_symbol(m.function, symbol);
 				r_symbol.children.push_back(symbol);
 			} break;
+			case ClassNode::Member::TRAIT:
 			case ClassNode::Member::CLASS: {
 				LSP::DocumentSymbol symbol;
 				parse_class_symbol(m.m_class, symbol);
@@ -946,6 +947,7 @@ Dictionary ExtendGDScriptParser::dump_class_api(const GDScriptParser::ClassNode
 	for (int i = 0; i < p_class->members.size(); i++) {
 		const ClassNode::Member &m = p_class->members[i];
 		switch (m.type) {
+			case ClassNode::Member::TRAIT:
 			case ClassNode::Member::CLASS:
 				nested_classes.push_back(dump_class_api(m.m_class));
 				break;
diff --git a/modules/gdscript/tests/gdscript_test_runner.cpp b/modules/gdscript/tests/gdscript_test_runner.cpp
index 51b6d717afd..c3a05ff19e5 100644
--- a/modules/gdscript/tests/gdscript_test_runner.cpp
+++ b/modules/gdscript/tests/gdscript_test_runner.cpp
@@ -139,6 +139,19 @@ void finish_language() {
 
 StringName GDScriptTestRunner::test_function_name;
 
+bool GDScriptTestRunner::suppress_trait_warning() {
+	bool originalState = GLOBAL_GET("debug/gdscript/warnings/show_experimental_trait_warning");
+	ProjectSettings::get_singleton()->set_setting("debug/gdscript/warnings/show_experimental_trait_warning", false);
+	return originalState;
+}
+
+void GDScriptTestRunner::restore_trait_warnings(const bool originalState) {
+	ProjectSettings *singleton = ProjectSettings::get_singleton();
+	if (singleton->has_setting("debug/gdscript/warnings/show_experimental_trait_warning")) {
+		singleton->set_setting("debug/gdscript/warnings/show_experimental_trait_warning", originalState);
+	}
+}
+
 GDScriptTestRunner::GDScriptTestRunner(const String &p_source_dir, bool p_init_language, bool p_print_filenames, bool p_use_binary_tokens) {
 	test_function_name = StringName("test");
 	do_init_languages = p_init_language;
@@ -194,13 +207,18 @@ static String strip_warnings(const String &p_expected) {
 #endif
 
 int GDScriptTestRunner::run_tests() {
+	// need to suppress warnings for traits tests
+	bool traitWarn = suppress_trait_warning();
+
 	if (!make_tests()) {
 		FAIL("An error occurred while making the tests.");
+		restore_trait_warnings(traitWarn);
 		return -1;
 	}
 
 	if (!generate_class_index()) {
 		FAIL("An error occurred while generating class index.");
+		restore_trait_warnings(traitWarn);
 		return -1;
 	}
 
@@ -224,19 +242,23 @@ int GDScriptTestRunner::run_tests() {
 
 		CHECK_MESSAGE(result.passed, (result.passed ? String() : result.output));
 	}
-
+	restore_trait_warnings(traitWarn);
 	return failed;
 }
 
 bool GDScriptTestRunner::generate_outputs() {
 	is_generating = true;
+	// need to suppress warnings for traits tests
+	bool traitWarn = suppress_trait_warning();
 
 	if (!make_tests()) {
 		print_line("Failed to generate a test output.");
+		restore_trait_warnings(traitWarn);
 		return false;
 	}
 
 	if (!generate_class_index()) {
+		restore_trait_warnings(traitWarn);
 		return false;
 	}
 
@@ -252,10 +274,12 @@ bool GDScriptTestRunner::generate_outputs() {
 
 		if (!result) {
 			print_line("\nCould not generate output for " + test.get_source_file());
+			restore_trait_warnings(traitWarn);
 			return false;
 		}
 	}
 	print_line("\nGenerated output files for " + itos(tests.size()) + " tests successfully.");
+	restore_trait_warnings(traitWarn);
 
 	return true;
 }
diff --git a/modules/gdscript/tests/gdscript_test_runner.h b/modules/gdscript/tests/gdscript_test_runner.h
index e20f2c78532..a533292f9c7 100644
--- a/modules/gdscript/tests/gdscript_test_runner.h
+++ b/modules/gdscript/tests/gdscript_test_runner.h
@@ -138,6 +138,8 @@ class GDScriptTestRunner {
 	int run_tests();
 	bool generate_outputs();
 
+	static bool suppress_trait_warning();
+	static void restore_trait_warnings(bool originalState);
 	GDScriptTestRunner(const String &p_source_dir, bool p_init_language, bool p_print_filenames = false, bool p_use_binary_tokens = false);
 	~GDScriptTestRunner();
 };
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.gd b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.gd
new file mode 100644
index 00000000000..7e96179e350
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.gd
@@ -0,0 +1,22 @@
+trait Shearable:
+	func shear() -> void:
+		print("Sheared")
+
+trait Milkable:
+	func milk() -> void:
+		print("Milked")
+
+class FluffySheep:
+	uses Shearable, Milkable
+
+class FluffyRam:
+	uses Shearable
+
+class Hen:
+	pass
+
+func test():
+	print(Hen is Shearable)
+	print(Hen.new() is Milkable)
+	print(FluffySheep as Shearable)
+	print(FluffyRam.new() as Milkable)
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.out b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.out
new file mode 100644
index 00000000000..c8c22fab042
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_test_and_cast.out
@@ -0,0 +1,5 @@
+GDTEST_ANALYZER_ERROR
+>> ERROR at line 19: Expression is of type "Hen" so it can't be of type "Shearable".
+>> ERROR at line 20: Expression is of type "Hen" so it can't be of type "Milkable".
+>> ERROR at line 21: Invalid cast. Cannot convert from "FluffySheep" to "Shearable".
+>> ERROR at line 22: Invalid cast. Cannot convert from "FluffyRam" to "Milkable".
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.gd b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.gd
new file mode 100644
index 00000000000..f9532207d42
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.gd
@@ -0,0 +1,46 @@
+trait TraitA:
+	func some_func()
+
+	func some_func_2(_param: Node):
+		print("some func")
+
+	func some_func_3(_param1, _param2):
+		print("some func")
+
+	func some_func_4():
+		print("some func")
+
+trait BadTrait extends CollisionObject2D:
+	func move_and_collide()
+
+trait BadTrait2:
+	func some_func():
+		print("some func")
+
+trait BadTrait3:
+	uses TraitA
+
+	func some_func(): # Trait do not override trait function. hence, error.
+		print("some func")
+
+class SomeClass extends CharacterBody2D:
+	uses TraitA
+	# Implementing function some_func() is skipped. Since bodyless in trait leads to an error.
+
+	uses TraitA # Using the same trait again in same class, leads to error.
+	uses BadTrait # Trait has 'move_and_collide()' but function shadows native from CharacterBody2D, hence an error.
+	uses BadTrait2 # Trait has 'some_func()' but function shadows member of trait TraitA already used in class, hence an error. (trait cohesion mismatch)
+
+	var some_func_4 # Can not shadow trait members.
+
+	# Can not override trait function with different _parameter type.
+	func some_func_2(_param: Node2D): # in case _param type as Node or its Node class Parent classes are accepted(i.e Object).
+		print("overridden some func")
+
+	# Can not override trait function with different _parameter size.
+	func some_func_3(_param1):
+		print("overridden some func")
+
+	func _ready():
+		var instance = TraitA.new() # Can not instance trait.
+		TraitA.some_func() # Can not access trait members directly.
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.out b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.out
new file mode 100644
index 00000000000..2373c96a61c
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_function.out
@@ -0,0 +1,11 @@
+GDTEST_ANALYZER_ERROR
+>> ERROR at line 23: "some_func" function is already declared in trait "TraitA". Traits do not extend/override members from using traits.
+>> ERROR at line 27: Class uses trait "TraitA" but does not implement function "some_func() -> Variant".
+>> ERROR at line 37: Function signature of "some_func_2" should be "some_func_2(Node) -> Variant" as declared in trait "TraitA".
+>> ERROR at line 41: Function signature of "some_func_3" should be "some_func_3(VariantVariant,) -> Variant" as declared in trait "TraitA".
+>> ERROR at line 34: "some_func_4" variable conflicts with an already-existing function in trait "TraitA".
+>> ERROR at line 30: "TraitA" trait use is already declared.
+>> ERROR at line 31: "move_and_collide" function from trait "BadTrait" conflicts with an already-existing native method of the using class.
+>> ERROR at line 32: Can not use "BadTrait2" trait since it shadows members from previous traits.
+>> ERROR at line 45: Cannot call a trait's functions directly; call through a class that uses it instead.
+>> ERROR at line 46: Cannot call a trait's functions directly; call through a class that uses it instead.
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.gd b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.gd
new file mode 100644
index 00000000000..69efe59c40b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.gd
@@ -0,0 +1,5 @@
+trait TraitA extends Node:
+	pass
+
+class ClassA extends TraitA:
+	pass
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.out b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.out
new file mode 100644
index 00000000000..0a7df8f4c5b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_inheritance.out
@@ -0,0 +1,2 @@
+GDTEST_ANALYZER_ERROR
+>> ERROR at line 4: Could not inherit from trait "TraitA".
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.gd b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.gd
new file mode 100644
index 00000000000..1e383114b61
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.gd
@@ -0,0 +1,28 @@
+trait TraitA extends Node:
+	pass
+
+class ClassA:
+	pass
+
+class ClassB extends Object:
+	uses TraitA # Using a trait that extends Node but the class extends Object.
+    # This should raise an error because inheritance mismatch.
+    # in this case, Node or children classes of Node would be accepted as using class inheritance.
+
+class ClassC:
+	uses ClassA # Class cannot be used as a trait. Should raise an error.
+
+class Actor extends Intermediate:
+	uses Interactable # compatible since both are children of BaseCharacter
+	# However, "Intermediate" & "Interactable" conflict over func interact() raising error
+
+class Intermediate extends BaseCharacter:
+	func interact():
+		print("Interactable")
+
+class BaseCharacter extends Node:
+	pass
+
+trait Interactable extends BaseCharacter:
+	func interact():
+		print("Interactable")
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.out b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.out
new file mode 100644
index 00000000000..34d4df4b120
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/errors/invalid_trait_uses.out
@@ -0,0 +1,4 @@
+GDTEST_ANALYZER_ERROR
+>> ERROR at line 8: "TraitA" trait extending "Node" does not match class inheritance.
+>> ERROR at line 13: "ClassA" is not a trait.
+>> ERROR at line 16: "interact" function from trait "Interactable" conflicts with an already-existing member inherited from parent of using class.
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/global_trait.notest.gd b/modules/gdscript/tests/scripts/Traits/analyzer/features/global_trait.notest.gd
new file mode 100644
index 00000000000..10bf566ef82
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/global_trait.notest.gd
@@ -0,0 +1,4 @@
+trait_name GlobalTrait
+
+func func_from_global_trait() -> void:
+    print("function from global trait")
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.gd b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.gd
new file mode 100644
index 00000000000..81a9260d6de
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.gd
@@ -0,0 +1,63 @@
+extends Node
+uses TraitA, TraitB
+uses TraitC, TraitC.TraitD, ClassA.TraitE
+uses GlobalTrait
+
+trait TraitA extends Object:
+	func func_one():
+		print("function one")
+
+trait TraitB:
+	func func_two():
+		print("function two")
+
+trait TraitC:
+	static func func_three():
+		print("function three")
+
+	func func_four()
+
+	trait TraitD:
+		uses TraitC
+		signal signal_one(args)
+		enum EnumOne { VALUE_ONE, VALUE_TWO }
+
+class ClassA:
+	trait TraitE:
+		uses TraitC.TraitD
+		var var_one: String = "trait variable"
+		const const_one: String = "trait constant"
+
+static func func_three(): # override using 'static' keyword is optional but result in warning.
+	print("overridden function three")
+
+func func_four():
+	print("function four implemented in class")
+
+
+class Actor extends Intermediate:
+	uses Interactable
+
+class Intermediate extends BaseCharacter: pass
+
+class BaseCharacter extends Node: pass
+
+trait Interactable extends BaseCharacter:
+	func interact():
+		print("Interactable")
+
+func test():
+	print("signal connect:", signal_one.connect(print) == OK)
+	signal_one.emit("test signal")
+	print(var_one)
+	print(const_one)
+	print("Trait Enum value:", EnumOne.VALUE_ONE)
+	print("Trait Enum value:", EnumOne.VALUE_TWO)
+	func_one()
+	func_two()
+	func_three()
+	func_four()
+	var act = Actor.new()
+	act.interact()
+	act.free()
+	print("ok")
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.out b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.out
new file mode 100644
index 00000000000..747b524fb8a
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_cohesion.out
@@ -0,0 +1,13 @@
+GDTEST_OK
+signal connect:true
+test signal
+trait variable
+trait constant
+Trait Enum value:0
+Trait Enum value:1
+function one
+function two
+overridden function three
+function four implemented in class
+Interactable
+ok
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.gd b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.gd
new file mode 100644
index 00000000000..a4986756c28
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.gd
@@ -0,0 +1,48 @@
+trait Shearable:
+	func shear() -> void:
+		print("Sheared")
+
+trait Milkable:
+	func milk() -> void:
+		print("Milked")
+
+class FluffySheep:
+	uses Shearable, Milkable
+
+class FluffyRam:
+	uses Shearable
+
+class Hen:
+	pass
+
+func test():
+	var my_animals : Array = []
+	my_animals.append(FluffySheep.new())
+	my_animals.append(FluffyRam.new())
+	my_animals.append(Hen.new())
+
+	# 'is' operator tests
+	print("FluffySheep is Shearable:", FluffySheep is Shearable)
+	print("FluffySheep is Milkable:", FluffySheep is Milkable)
+
+	var Ram = FluffyRam.new()
+	print("FluffyRam is Shearable:", Ram is Shearable)
+	print("FluffyRam is Milkable:", Ram is Milkable)
+	print()
+
+	var count := 1
+	for animal in my_animals:
+		# test 'as' casts
+		print("Animal: " + str(count))
+		var cast1 = animal as Shearable
+		var cast2 = animal as Milkable
+		print("Success Shearable cast : ", cast1 != null)
+		print("Success Milkable cast : ", cast2 != null)
+
+		if animal is Shearable:
+			animal.shear()
+		if animal is Milkable:
+			animal.milk()
+		count += 1
+
+	print("ok")
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.out b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.out
new file mode 100644
index 00000000000..2b33b387209
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_test_and_cast.out
@@ -0,0 +1,23 @@
+GDTEST_OK
+~~ WARNING at line 37: (UNSAFE_CAST) Casting "Variant" to "Shearable" is unsafe.
+~~ WARNING at line 38: (UNSAFE_CAST) Casting "Variant" to "Milkable" is unsafe.
+~~ WARNING at line 43: (UNSAFE_METHOD_ACCESS) The method "shear()" is not present on the inferred type "Variant" (but may be present on a subtype).
+~~ WARNING at line 45: (UNSAFE_METHOD_ACCESS) The method "milk()" is not present on the inferred type "Variant" (but may be present on a subtype).
+FluffySheep is Shearable:true
+FluffySheep is Milkable:true
+FluffyRam is Shearable:true
+FluffyRam is Milkable:false
+
+Animal: 1
+Success Shearable cast : true
+Success Milkable cast : true
+Sheared
+Milked
+Animal: 2
+Success Shearable cast : true
+Success Milkable cast : false
+Sheared
+Animal: 3
+Success Shearable cast : false
+Success Milkable cast : false
+ok
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.gd b/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.gd
new file mode 100644
index 00000000000..fac866652e7
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.gd
@@ -0,0 +1,12 @@
+
+uses TraitA
+
+trait TraitA:
+	static func func_one():
+		print("function one")
+
+func func_one():
+	print("override function one")
+
+func test():
+	pass
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.out b/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.out
new file mode 100644
index 00000000000..e743314b0cf
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/warnings/trait_static_function.out
@@ -0,0 +1,2 @@
+GDTEST_OK
+~~ WARNING at line 8: (UNUSED_STATIC_OVERRIDING_TRAIT) Overridden static without using "static" keyword.
diff --git a/modules/mono/class_db_api_json.cpp b/modules/mono/class_db_api_json.cpp
index c1d3e7bf601..e6140e5fb32 100644
--- a/modules/mono/class_db_api_json.cpp
+++ b/modules/mono/class_db_api_json.cpp
@@ -48,13 +48,11 @@
 void class_db_api_to_json(const String &p_output_file, ClassDB::APIType p_api) {
 	Dictionary classes_dict;
 
-	List<StringName> class_list;
-	ClassDB::get_class_list(&class_list);
-	// Must be alphabetically sorted for hash to compute.
-	class_list.sort_custom<StringName::AlphCompare>();
+	LocalVector<StringName> class_list;
+	ClassDB::get_class_list(class_list);
 
-	for (const StringName &E : class_list) {
-		ClassDB::ClassInfo *t = ClassDB::classes.getptr(E);
+	for (const StringName &class_name : class_list) {
+		ClassDB::ClassInfo *t = ClassDB::classes.getptr(class_name);
 		ERR_FAIL_NULL(t);
 		if (t->api != p_api || !t->exposed) {
 			continue;
diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index 9e627a6dbee..d2a2f4fe542 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -3858,35 +3858,28 @@ struct SortMethodWithHashes {
 bool BindingsGenerator::_populate_object_type_interfaces() {
 	obj_types.clear();
 
-	List<StringName> class_list;
-	ClassDB::get_class_list(&class_list);
-	class_list.sort_custom<StringName::AlphCompare>();
-
-	while (class_list.size()) {
-		StringName type_cname = class_list.front()->get();
+	LocalVector<StringName> class_list;
+	ClassDB::get_class_list(class_list);
 
+	for (const StringName &type_cname : class_list) {
 		ClassDB::APIType api_type = ClassDB::get_api_type(type_cname);
 
 		if (api_type == ClassDB::API_NONE) {
-			class_list.pop_front();
 			continue;
 		}
 
 		if (ignored_types.has(type_cname)) {
 			_log("Ignoring type '%s' because it's in the list of ignored types\n", String(type_cname).utf8().get_data());
-			class_list.pop_front();
 			continue;
 		}
 
 		if (!ClassDB::is_class_exposed(type_cname)) {
 			_log("Ignoring type '%s' because it's not exposed\n", String(type_cname).utf8().get_data());
-			class_list.pop_front();
 			continue;
 		}
 
 		if (!ClassDB::is_class_enabled(type_cname)) {
 			_log("Ignoring type '%s' because it's not enabled\n", String(type_cname).utf8().get_data());
-			class_list.pop_front();
 			continue;
 		}
 
@@ -4447,8 +4440,6 @@ bool BindingsGenerator::_populate_object_type_interfaces() {
 
 			obj_types.insert(itype.name + CS_SINGLETON_INSTANCE_SUFFIX, itype);
 		}
-
-		class_list.pop_front();
 	}
 
 	return true;
diff --git a/tests/core/object/test_class_db.h b/tests/core/object/test_class_db.h
index 015b9308a9f..7c5f842338e 100644
--- a/tests/core/object/test_class_db.h
+++ b/tests/core/object/test_class_db.h
@@ -518,29 +518,25 @@ void validate_class(const Context &p_context, const ExposedClass &p_exposed_clas
 }
 
 void add_exposed_classes(Context &r_context) {
-	List<StringName> class_list;
-	ClassDB::get_class_list(&class_list);
-	class_list.sort_custom<StringName::AlphCompare>();
+	LocalVector<StringName> class_list;
+	ClassDB::get_class_list(class_list);
 
-	while (class_list.size()) {
-		StringName class_name = class_list.front()->get();
+	for (uint32_t class_list_idx = 0; class_list_idx < class_list.size(); class_list_idx++) {
+		StringName class_name = class_list[class_list_idx];
 
 		ClassDB::APIType api_type = ClassDB::get_api_type(class_name);
 
 		if (api_type == ClassDB::API_NONE) {
-			class_list.pop_front();
 			continue;
 		}
 
 		if (!ClassDB::is_class_exposed(class_name)) {
 			INFO(vformat("Ignoring class '%s' because it's not exposed.", class_name));
-			class_list.pop_front();
 			continue;
 		}
 
 		if (!ClassDB::is_class_enabled(class_name)) {
 			INFO(vformat("Ignoring class '%s' because it's not enabled.", class_name));
-			class_list.pop_front();
 			continue;
 		}
 
@@ -817,7 +813,6 @@ void add_exposed_classes(Context &r_context) {
 		}
 
 		r_context.exposed_classes.insert(class_name, exposed_class);
-		class_list.pop_front();
 	}
 }