diff --git a/core/object/script_language.h b/core/object/script_language.h
index 40159eb8fe8..66a5422879b 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -170,6 +170,10 @@ class Script : public Resource {
 	virtual Ref<Script> get_base_script() const = 0; //< For script inheritance
 	virtual StringName get_global_name() const = 0;
 	virtual bool inherits_script(const Ref<Script> &p_script) const = 0;
+	/// Returns whether this script defines a trait.
+	virtual bool is_trait() const { return false; }
+	/// Returns whether instances of this script implement the named trait.
+	virtual bool has_trait(const StringName &p_trait) const { return false; }
 
 	virtual StringName get_instance_base_type() const = 0; ///< This may not work in all scripts, will return empty if so
 	virtual ScriptInstance *instance_create(Object *p_this) = 0;
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index adebd2674f5..38365dd98b0 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -233,9 +233,8 @@ void Array::assign(const Array &p_array) {
 	const Variant *source = p_array._p->array.ptr();
 	int size = p_array._p->array.size();
 
-	if ((source_typed.type == Variant::NIL && typed.type == Variant::OBJECT) || (source_typed.type == Variant::OBJECT && source_typed.can_reference(typed))) {
-		// from variants to objects or
-		// from base classes to subclasses
+	if ((source_typed.type == Variant::NIL && typed.type == Variant::OBJECT) || (source_typed.type == Variant::OBJECT && typed.type == Variant::OBJECT)) {
+		// From variants or another object type, validate each element against the destination type.
 		for (int i = 0; i < size; i++) {
 			const Variant &element = source[i];
 			if (element.get_type() != Variant::NIL && (element.get_type() != Variant::OBJECT || !typed.validate_object(element, "assign"))) {
diff --git a/core/variant/container_type_validate.h b/core/variant/container_type_validate.h
index 0055ba6c2fa..45f5b5d7116 100644
--- a/core/variant/container_type_validate.h
+++ b/core/variant/container_type_validate.h
@@ -121,8 +121,12 @@ struct ContainerTypeValidate {
 
 		const StringName &obj_class = object->get_class_name();
 		if (obj_class != class_name && !ClassDB::is_parent_class(obj_class, class_name)) {
+			Ref<Script> object_script = object->get_script();
+			if (object_script.is_valid() && object_script->has_trait(class_name)) {
+				return true;
+			}
 			if (p_output_errors) {
-				ERR_FAIL_V_MSG(false, vformat("Attempted to %s an object of type '%s' into a %s, which does not inherit from '%s'.", String(p_operation), object->get_class(), where, String(class_name)));
+				ERR_FAIL_V_MSG(false, vformat("Attempted to %s an object of type '%s' into a %s, which does not inherit from or use '%s'.", String(p_operation), object->get_class(), where, String(class_name)));
 			} else {
 				return false;
 			}
diff --git a/core/variant/variant_parser.cpp b/core/variant/variant_parser.cpp
index aeb15360360..830b489f9d4 100644
--- a/core/variant/variant_parser.cpp
+++ b/core/variant/variant_parser.cpp
@@ -1354,10 +1354,11 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			}
 
 			get_token(p_stream, token, line, r_err_str);
-			if (token.type != TK_IDENTIFIER) {
-				r_err_str = "Expected type identifier for key";
+			if (token.type != TK_IDENTIFIER && token.type != TK_STRING) {
+				r_err_str = "Expected type identifier or string for key";
 				return ERR_PARSE_ERROR;
 			}
+			const bool quoted_key_class_name = token.type == TK_STRING;
 
 			static HashMap<StringName, Variant::Type> builtin_types;
 			if (builtin_types.is_empty()) {
@@ -1371,7 +1372,10 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			StringName key_class_name;
 			Variant key_script;
 			bool got_comma_token = false;
-			if (builtin_types.has(token.value)) {
+			if (quoted_key_class_name) {
+				key_type = Variant::OBJECT;
+				key_class_name = token.value;
+			} else if (builtin_types.has(token.value)) {
 				key_type = builtin_types.get(token.value);
 			} else if (token.value == "Resource" || token.value == "SubResource" || token.value == "ExtResource") {
 				Variant resource;
@@ -1397,6 +1401,12 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			} else if (ClassDB::class_exists(token.value)) {
 				key_type = Variant::OBJECT;
 				key_class_name = token.value;
+			} else if (ScriptServer::is_global_class(token.value)) {
+				Ref<Script> trait_script = ResourceLoader::load(ScriptServer::get_global_class_path(token.value));
+				if (trait_script.is_valid() && trait_script->is_trait()) {
+					key_type = Variant::OBJECT;
+					key_class_name = token.value;
+				}
 			}
 
 			if (!got_comma_token) {
@@ -1408,16 +1418,20 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			}
 
 			get_token(p_stream, token, line, r_err_str);
-			if (token.type != TK_IDENTIFIER) {
-				r_err_str = "Expected type identifier for value";
+			if (token.type != TK_IDENTIFIER && token.type != TK_STRING) {
+				r_err_str = "Expected type identifier or string for value";
 				return ERR_PARSE_ERROR;
 			}
+			const bool quoted_value_class_name = token.type == TK_STRING;
 
 			Variant::Type value_type = Variant::NIL;
 			StringName value_class_name;
 			Variant value_script;
 			bool got_bracket_token = false;
-			if (builtin_types.has(token.value)) {
+			if (quoted_value_class_name) {
+				value_type = Variant::OBJECT;
+				value_class_name = token.value;
+			} else if (builtin_types.has(token.value)) {
 				value_type = builtin_types.get(token.value);
 			} else if (token.value == "Resource" || token.value == "SubResource" || token.value == "ExtResource") {
 				Variant resource;
@@ -1443,6 +1457,12 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			} else if (ClassDB::class_exists(token.value)) {
 				value_type = Variant::OBJECT;
 				value_class_name = token.value;
+			} else if (ScriptServer::is_global_class(token.value)) {
+				Ref<Script> trait_script = ResourceLoader::load(ScriptServer::get_global_class_path(token.value));
+				if (trait_script.is_valid() && trait_script->is_trait()) {
+					value_type = Variant::OBJECT;
+					value_class_name = token.value;
+				}
 			}
 
 			if (key_type != Variant::NIL || value_type != Variant::NIL) {
@@ -1494,10 +1514,11 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 			}
 
 			get_token(p_stream, token, line, r_err_str);
-			if (token.type != TK_IDENTIFIER) {
-				r_err_str = "Expected type identifier";
+			if (token.type != TK_IDENTIFIER && token.type != TK_STRING) {
+				r_err_str = "Expected type identifier or string";
 				return ERR_PARSE_ERROR;
 			}
+			const bool quoted_class_name = token.type == TK_STRING;
 
 			static HashMap<String, Variant::Type> builtin_types;
 			if (builtin_types.is_empty()) {
@@ -1508,7 +1529,9 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 
 			Array array = Array();
 			bool got_bracket_token = false;
-			if (builtin_types.has(token.value)) {
+			if (quoted_class_name) {
+				array.set_typed(Variant::OBJECT, token.value, Variant());
+			} else if (builtin_types.has(token.value)) {
 				array.set_typed(builtin_types.get(token.value), StringName(), Variant());
 			} else if (token.value == "Resource" || token.value == "SubResource" || token.value == "ExtResource") {
 				if (!p_allow_objects) {
@@ -1535,6 +1558,11 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream,
 				}
 			} else if (ClassDB::class_exists(token.value)) {
 				array.set_typed(Variant::OBJECT, token.value, Variant());
+			} else if (ScriptServer::is_global_class(token.value)) {
+				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(token.value));
+				if (script.is_valid() && script->is_trait()) {
+					array.set_typed(Variant::OBJECT, token.value, Variant());
+				}
 			}
 
 			if (!got_bracket_token) {
@@ -2446,7 +2474,8 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
 						p_store_string_func(p_store_string_ud, key_class_name);
 					}
 				} else if (key_class_name != StringName()) {
-					p_store_string_func(p_store_string_ud, key_class_name);
+					String type_name = key_class_name;
+					p_store_string_func(p_store_string_ud, type_name.is_valid_identifier() ? type_name : "\"" + type_name.c_escape() + "\"");
 				} else if (key_builtin_type == Variant::NIL) {
 					p_store_string_func(p_store_string_ud, "Variant");
 				} else {
@@ -2475,7 +2504,8 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
 						p_store_string_func(p_store_string_ud, value_class_name);
 					}
 				} else if (value_class_name != StringName()) {
-					p_store_string_func(p_store_string_ud, value_class_name);
+					String type_name = value_class_name;
+					p_store_string_func(p_store_string_ud, type_name.is_valid_identifier() ? type_name : "\"" + type_name.c_escape() + "\"");
 				} else if (value_builtin_type == Variant::NIL) {
 					p_store_string_func(p_store_string_ud, "Variant");
 				} else {
@@ -2590,7 +2620,8 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
 						p_store_string_func(p_store_string_ud, class_name);
 					}
 				} else if (class_name != StringName()) {
-					p_store_string_func(p_store_string_ud, class_name);
+					String type_name = class_name;
+					p_store_string_func(p_store_string_ud, type_name.is_valid_identifier() ? type_name : "\"" + type_name.c_escape() + "\"");
 				} else {
 					p_store_string_func(p_store_string_ud, Variant::get_type_name(builtin_type));
 				}
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index fd5c280dde9..0660b947cf4 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -5350,6 +5350,9 @@ bool EditorNode::is_object_of_custom_type(const Object *p_object, const StringNa
 	}
 
 	if (scr.is_valid()) {
+		if (scr->has_trait(p_class)) {
+			return true;
+		}
 		Ref<Script> base_script = scr;
 		while (base_script.is_valid()) {
 			StringName name = EditorNode::get_editor_data().script_class_get_name(base_script->get_path());
diff --git a/editor/inspector/editor_properties_array_dict.cpp b/editor/inspector/editor_properties_array_dict.cpp
index b9ecd2ccc6d..304b3318608 100644
--- a/editor/inspector/editor_properties_array_dict.cpp
+++ b/editor/inspector/editor_properties_array_dict.cpp
@@ -40,6 +40,8 @@
 
 #include "core/input/input.h"
 #include "core/io/marshalls.h"
+#include "core/io/resource_loader.h"
+#include "core/object/script_language.h"
 #include "core/variant/struct.h"
 #include "core/variant/struct_info.h"
 #include "editor/docks/inspector_dock.h"
@@ -243,15 +245,40 @@ String EditorPropertyDictionaryObject::get_label_for_index(int p_index) {
 
 ///////////////////// ARRAY ///////////////////////////
 
+static void _resolve_typed_object_hint(const String &p_hint_string, StringName &r_class, Ref<Script> &r_script) {
+	if (p_hint_string.is_empty()) {
+		return;
+	}
+	if (ClassDB::class_exists(p_hint_string)) {
+		r_class = p_hint_string;
+		return;
+	}
+
+	String script_path = p_hint_string;
+	if (ScriptServer::is_global_class(p_hint_string)) {
+		script_path = ScriptServer::get_global_class_path(p_hint_string);
+	} else if (script_path.contains("::")) {
+		script_path = script_path.get_slice("::", 0);
+	}
+	Ref<Script> hint_script;
+	if (script_path.is_resource_file()) {
+		hint_script = ResourceLoader::load(script_path);
+	}
+	if (hint_script.is_valid() && (hint_script->is_trait() || p_hint_string.contains("::"))) {
+		r_class = p_hint_string;
+	} else if (hint_script.is_valid()) {
+		r_class = hint_script->get_instance_base_type();
+		r_script = hint_script;
+	}
+}
+
 void EditorPropertyArray::initialize_array(Variant &p_array) {
 	if (array_type == Variant::ARRAY && subtype != Variant::NIL) {
 		Array array;
 		StringName subtype_class;
 		Ref<Script> subtype_script;
-		if (subtype == Variant::OBJECT && !subtype_hint_string.is_empty()) {
-			if (ClassDB::class_exists(subtype_hint_string)) {
-				subtype_class = subtype_hint_string;
-			}
+		if (subtype == Variant::OBJECT) {
+			_resolve_typed_object_hint(subtype_hint_string, subtype_class, subtype_script);
 		}
 		array.set_typed(subtype, subtype_class, subtype_script);
 		p_array = array;
@@ -993,13 +1020,13 @@ void EditorPropertyDictionary::initialize_dictionary(Variant &p_dictionary) {
 		Dictionary dict;
 		StringName key_subtype_class;
 		Ref<Script> key_subtype_script;
-		if (key_subtype == Variant::OBJECT && !key_subtype_hint_string.is_empty() && ClassDB::class_exists(key_subtype_hint_string)) {
-			key_subtype_class = key_subtype_hint_string;
+		if (key_subtype == Variant::OBJECT) {
+			_resolve_typed_object_hint(key_subtype_hint_string, key_subtype_class, key_subtype_script);
 		}
 		StringName value_subtype_class;
 		Ref<Script> value_subtype_script;
-		if (value_subtype == Variant::OBJECT && !value_subtype_hint_string.is_empty() && ClassDB::class_exists(value_subtype_hint_string)) {
-			value_subtype_class = value_subtype_hint_string;
+		if (value_subtype == Variant::OBJECT) {
+			_resolve_typed_object_hint(value_subtype_hint_string, value_subtype_class, value_subtype_script);
 		}
 		dict.set_typed(key_subtype, key_subtype_class, key_subtype_script, value_subtype, value_subtype_class, value_subtype_script);
 		p_dictionary = dict;
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index 4ad49113859..628b21ed041 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -252,7 +252,8 @@ class GDScript : public Script {
 	}
 
 	_FORCE_INLINE_ StringName get_local_name() const { return local_name; }
-	_FORCE_INLINE_ bool has_trait(const StringName &p_trait) const { return traits_fqtn.has(p_trait); }
+	_FORCE_INLINE_ bool has_trait(const StringName &p_trait) const override { return traits_fqtn.has(p_trait); }
+	_FORCE_INLINE_ bool is_trait() const override { return file_trait; }
 
 	void clear(GDScript::ClearData *p_clear_data = nullptr);
 
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 96a9a1014e5..ecfe1497c4e 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -6544,8 +6544,12 @@ Array GDScriptAnalyzer::make_array_from_element_datatype(const GDScriptParser::D
 	Array array;
 
 	if (p_element_datatype.builtin_type == Variant::OBJECT) {
+		if (p_element_datatype.kind == GDScriptParser::DataType::TRAIT) {
+			array.set_typed(Variant::OBJECT, p_element_datatype.class_type->fqcn, Variant());
+			return array;
+		}
 		Ref<Script> script_type = p_element_datatype.script_type;
-		if ((p_element_datatype.kind == GDScriptParser::DataType::CLASS || p_element_datatype.kind == GDScriptParser::DataType::TRAIT) && script_type.is_null()) {
+		if (p_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
 			Error err = OK;
 			Ref<GDScript> scr = get_depended_shallow_script(p_element_datatype.script_path, err);
 			if (err) {
@@ -6571,35 +6575,43 @@ Dictionary GDScriptAnalyzer::make_dictionary_from_element_datatype(const GDScrip
 	Variant value_script;
 
 	if (p_key_element_datatype.builtin_type == Variant::OBJECT) {
-		Ref<Script> script_type = p_key_element_datatype.script_type;
-		if (p_key_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
-			Error err = OK;
-			Ref<GDScript> scr = get_depended_shallow_script(p_key_element_datatype.script_path, err);
-			if (err) {
-				push_error(vformat(R"(Error while getting cache for script "%s".)", p_key_element_datatype.script_path), p_source_node);
-				return dictionary;
+		if (p_key_element_datatype.kind == GDScriptParser::DataType::TRAIT) {
+			key_name = p_key_element_datatype.class_type->fqcn;
+		} else {
+			Ref<Script> script_type = p_key_element_datatype.script_type;
+			if (p_key_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
+				Error err = OK;
+				Ref<GDScript> scr = get_depended_shallow_script(p_key_element_datatype.script_path, err);
+				if (err) {
+					push_error(vformat(R"(Error while getting cache for script "%s".)", p_key_element_datatype.script_path), p_source_node);
+					return dictionary;
+				}
+				script_type.reference_ptr(scr->find_class(p_key_element_datatype.class_type->fqcn));
 			}
-			script_type.reference_ptr(scr->find_class(p_key_element_datatype.class_type->fqcn));
-		}
 
-		key_name = p_key_element_datatype.native_type;
-		key_script = script_type;
+			key_name = p_key_element_datatype.native_type;
+			key_script = script_type;
+		}
 	}
 
 	if (p_value_element_datatype.builtin_type == Variant::OBJECT) {
-		Ref<Script> script_type = p_value_element_datatype.script_type;
-		if (p_value_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
-			Error err = OK;
-			Ref<GDScript> scr = get_depended_shallow_script(p_value_element_datatype.script_path, err);
-			if (err) {
-				push_error(vformat(R"(Error while getting cache for script "%s".)", p_value_element_datatype.script_path), p_source_node);
-				return dictionary;
+		if (p_value_element_datatype.kind == GDScriptParser::DataType::TRAIT) {
+			value_name = p_value_element_datatype.class_type->fqcn;
+		} else {
+			Ref<Script> script_type = p_value_element_datatype.script_type;
+			if (p_value_element_datatype.kind == GDScriptParser::DataType::CLASS && script_type.is_null()) {
+				Error err = OK;
+				Ref<GDScript> scr = get_depended_shallow_script(p_value_element_datatype.script_path, err);
+				if (err) {
+					push_error(vformat(R"(Error while getting cache for script "%s".)", p_value_element_datatype.script_path), p_source_node);
+					return dictionary;
+				}
+				script_type.reference_ptr(scr->find_class(p_value_element_datatype.class_type->fqcn));
 			}
-			script_type.reference_ptr(scr->find_class(p_value_element_datatype.class_type->fqcn));
-		}
 
-		value_name = p_value_element_datatype.native_type;
-		value_script = script_type;
+			value_name = p_value_element_datatype.native_type;
+			value_script = script_type;
+		}
 	}
 
 	dictionary.set_typed(p_key_element_datatype.builtin_type, key_name, key_script, p_value_element_datatype.builtin_type, value_name, value_script);
@@ -6813,6 +6825,36 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo
 	} else {
 		result.kind = GDScriptParser::DataType::BUILTIN;
 		result.builtin_type = p_property.type;
+		auto resolve_trait_hint = [&](const StringName &p_type_name, GDScriptParser::DataType &r_type) -> bool {
+			const String type_name = p_type_name;
+			String script_path;
+			if (ScriptServer::is_global_class(p_type_name)) {
+				script_path = ScriptServer::get_global_class_path(p_type_name);
+			} else if (type_name.contains("::")) {
+				script_path = type_name.get_slice("::", 0);
+			} else {
+				return false;
+			}
+			if (script_path.get_extension() != GDScriptLanguage::get_singleton()->get_extension()) {
+				return false;
+			}
+
+			GDScriptParser::ClassNode *trait = nullptr;
+			if (script_path == parser->script_path) {
+				trait = parser->find_class(type_name);
+			} else {
+				Ref<GDScriptParserRef> ref = parser->get_depended_parser_for(script_path);
+				if (ref.is_valid() && ref->raise_status(GDScriptParserRef::INHERITANCE_SOLVED) == OK) {
+					trait = ref->get_parser()->find_class(type_name);
+				}
+			}
+			if (trait == nullptr || trait->type != GDScriptParser::Node::TRAIT) {
+				return false;
+			}
+			r_type = type_from_metatype(trait->get_datatype());
+			r_type.type_source = GDScriptParser::DataType::ANNOTATED_EXPLICIT;
+			return true;
+		};
 		if (p_property.type == Variant::ARRAY && p_property.hint == PROPERTY_HINT_ARRAY_TYPE) {
 			// Check element type.
 			StringName elem_type_name = p_property.hint_string;
@@ -6828,15 +6870,14 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo
 				elem_type.kind = GDScriptParser::DataType::NATIVE;
 				elem_type.builtin_type = Variant::OBJECT;
 				elem_type.native_type = elem_type_name;
-			} else if (ScriptServer::is_global_class(elem_type_name)) {
+			} else if (!resolve_trait_hint(elem_type_name, elem_type)) {
+				ERR_FAIL_COND_V_MSG(!ScriptServer::is_global_class(elem_type_name), result, "Could not find element type from property hint of a typed array.");
 				// Just load this as it shouldn't be a GDScript.
 				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(elem_type_name));
 				elem_type.kind = GDScriptParser::DataType::SCRIPT;
 				elem_type.builtin_type = Variant::OBJECT;
 				elem_type.native_type = script->get_instance_base_type();
 				elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed array.");
 			}
 			elem_type.is_constant = false;
 			result.set_container_element_type(0, elem_type);
@@ -6855,15 +6896,14 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo
 				key_elem_type.kind = GDScriptParser::DataType::NATIVE;
 				key_elem_type.builtin_type = Variant::OBJECT;
 				key_elem_type.native_type = key_elem_type_name;
-			} else if (ScriptServer::is_global_class(key_elem_type_name)) {
+			} else if (!resolve_trait_hint(key_elem_type_name, key_elem_type)) {
+				ERR_FAIL_COND_V_MSG(!ScriptServer::is_global_class(key_elem_type_name), result, "Could not find element type from property hint of a typed dictionary.");
 				// Just load this as it shouldn't be a GDScript.
 				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(key_elem_type_name));
 				key_elem_type.kind = GDScriptParser::DataType::SCRIPT;
 				key_elem_type.builtin_type = Variant::OBJECT;
 				key_elem_type.native_type = script->get_instance_base_type();
 				key_elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed dictionary.");
 			}
 			key_elem_type.is_constant = false;
 
@@ -6880,15 +6920,14 @@ GDScriptParser::DataType GDScriptAnalyzer::type_from_property(const PropertyInfo
 				value_elem_type.kind = GDScriptParser::DataType::NATIVE;
 				value_elem_type.builtin_type = Variant::OBJECT;
 				value_elem_type.native_type = value_elem_type_name;
-			} else if (ScriptServer::is_global_class(value_elem_type_name)) {
+			} else if (!resolve_trait_hint(value_elem_type_name, value_elem_type)) {
+				ERR_FAIL_COND_V_MSG(!ScriptServer::is_global_class(value_elem_type_name), result, "Could not find element type from property hint of a typed dictionary.");
 				// Just load this as it shouldn't be a GDScript.
 				Ref<Script> script = ResourceLoader::load(ScriptServer::get_global_class_path(value_elem_type_name));
 				value_elem_type.kind = GDScriptParser::DataType::SCRIPT;
 				value_elem_type.builtin_type = Variant::OBJECT;
 				value_elem_type.native_type = script->get_instance_base_type();
 				value_elem_type.script_type = script;
-			} else {
-				ERR_FAIL_V_MSG(result, "Could not find element type from property hint of a typed dictionary.");
 			}
 			value_elem_type.is_constant = false;
 
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index ae27a7f44fb..91d3c1a76a8 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -153,6 +153,8 @@ GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::D
 		case GDScriptParser::DataType::TRAIT: {
 			result.kind = GDScriptDataType::GDTRAIT;
 			result.trait_type = p_datatype.class_type->fqcn;
+			result.builtin_type = Variant::OBJECT;
+			result.native_type = result.trait_type;
 		} break;
 		case GDScriptParser::DataType::CLASS: {
 			if (p_handle_metatype && p_datatype.is_meta_type) {
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index 58f2bc0067d..64c5670acb1 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -86,7 +86,7 @@ bool GDScriptDataType::is_type(const Variant &p_variant, bool p_allow_implicit_c
 					if (array_script_type_ref.is_valid()) {
 						valid = (elem_type.kind == SCRIPT || elem_type.kind == GDSCRIPT) && elem_type.script_type == array_script_type_ref.ptr();
 					} else if (array_native_type != StringName()) {
-						valid = elem_type.kind == NATIVE && elem_type.native_type == array_native_type;
+						valid = (elem_type.kind == NATIVE && elem_type.native_type == array_native_type) || (elem_type.kind == GDTRAIT && elem_type.trait_type == array_native_type);
 					} else {
 						valid = elem_type.kind == BUILTIN && elem_type.builtin_type == array_builtin_type;
 					}
@@ -105,7 +105,7 @@ bool GDScriptDataType::is_type(const Variant &p_variant, bool p_allow_implicit_c
 						if (key_script_type_ref.is_valid()) {
 							valid = (key.kind == SCRIPT || key.kind == GDSCRIPT) && key.script_type == key_script_type_ref.ptr();
 						} else if (key_native_type != StringName()) {
-							valid = key.kind == NATIVE && key.native_type == key_native_type;
+							valid = (key.kind == NATIVE && key.native_type == key_native_type) || (key.kind == GDTRAIT && key.trait_type == key_native_type);
 						} else {
 							valid = key.kind == BUILTIN && key.builtin_type == key_builtin_type;
 						}
@@ -120,7 +120,7 @@ bool GDScriptDataType::is_type(const Variant &p_variant, bool p_allow_implicit_c
 						if (value_script_type_ref.is_valid()) {
 							valid = (value.kind == SCRIPT || value.kind == GDSCRIPT) && value.script_type == value_script_type_ref.ptr();
 						} else if (value_native_type != StringName()) {
-							valid = value.kind == NATIVE && value.native_type == value_native_type;
+							valid = (value.kind == NATIVE && value.native_type == value_native_type) || (value.kind == GDTRAIT && value.trait_type == value_native_type);
 						} else {
 							valid = value.kind == BUILTIN && value.builtin_type == value_builtin_type;
 						}
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index 5f0ea268b3b..5c3deffcda7 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -4703,6 +4703,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:
+			return p_type.class_type != nullptr ? StringName(p_type.class_type->fqcn) : p_type.native_type;
 		case GDScriptParser::DataType::CLASS: {
 			if (p_type.is_meta_type) {
 				return GDScript::get_class_static();
@@ -5497,6 +5498,9 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 						}
 						break;
 					case TRAIT:
+						result.hint = PROPERTY_HINT_ARRAY_TYPE;
+						result.hint_string = elem_type.class_type != nullptr ? elem_type.class_type->fqcn : String(elem_type.native_type);
+						break;
 					case CLASS:
 						result.hint = PROPERTY_HINT_ARRAY_TYPE;
 						if (elem_type.class_type != nullptr && elem_type.class_type->get_global_name() != StringName()) {
@@ -5537,6 +5541,8 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 						}
 						break;
 					case TRAIT:
+						key_hint = key_type.class_type != nullptr ? key_type.class_type->fqcn : String(key_type.native_type);
+						break;
 					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();
@@ -5566,6 +5572,8 @@ PropertyInfo GDScriptParser::DataType::to_property_info(const String &p_name) co
 						}
 						break;
 					case TRAIT:
+						value_hint = value_type.class_type != nullptr ? value_type.class_type->fqcn : String(value_type.native_type);
+						break;
 					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();
diff --git a/modules/gdscript/tests/gdscript_test_runner_suite.h b/modules/gdscript/tests/gdscript_test_runner_suite.h
index bed252127ff..815a34c7a63 100644
--- a/modules/gdscript/tests/gdscript_test_runner_suite.h
+++ b/modules/gdscript/tests/gdscript_test_runner_suite.h
@@ -46,6 +46,8 @@
 
 #include "core/config/engine.h"
 #include "core/config/project_settings.h"
+#include "core/io/resource_loader.h"
+#include "scene/resources/packed_scene.h"
 
 #include "tests/test_macros.h"
 #include "tests/test_utils.h"
@@ -244,6 +246,79 @@ TEST_CASE("[Modules][GDScript] Trait edits refresh consumer exports") {
 }
 #endif // TOOLS_ENABLED
 
+#ifdef TOOLS_ENABLED
+TEST_CASE("[Modules][GDScript] Trait-typed exported arrays retain node references") {
+	if (ProjectSettings::get_singleton()->get_resource_path().is_empty()) {
+		REQUIRE(ProjectSettings::get_singleton()->setup("modules/gdscript/tests/scripts", String(), true) == OK);
+	}
+	GDScriptLanguage::get_singleton()->init();
+	const String script_path = ProjectSettings::get_singleton()->localize_path(TestUtils::get_executable_dir().path_join("../modules/gdscript/tests/scripts/Traits/analyzer/features/trait_exported_array_scene.notest.gd").simplify_path());
+	Ref<GDScript> script = ResourceLoader::load(script_path);
+	REQUIRE(script.is_valid());
+	REQUIRE(script->is_valid());
+	Ref<GDScript> owner_script = script->find_class("Owner");
+	Ref<GDScript> enemy_script = script->find_class("Enemy");
+	REQUIRE(owner_script.is_valid());
+	REQUIRE(enemy_script.is_valid());
+
+	Node *owner = memnew(Node);
+	owner->set_name("Owner");
+	owner->set_script(owner_script);
+	Node *enemy = memnew(Node);
+	enemy->set_name("Enemy");
+	enemy->set_script(enemy_script);
+	owner->add_child(enemy);
+	enemy->set_owner(owner);
+
+	Array targets = owner->get("targets");
+	const StringName damageable_trait = script->get_fully_qualified_name() + "::Damageable";
+	CHECK(targets.get_typed_builtin() == Variant::OBJECT);
+	CHECK(targets.get_typed_class_name() == damageable_trait);
+	CHECK(enemy_script->has_trait(targets.get_typed_class_name()));
+	targets.push_back(enemy);
+	CHECK(targets.size() == 1);
+	Array nodes;
+	nodes.set_typed(Variant::OBJECT, "Node", Variant());
+	nodes.assign(targets);
+	CHECK(nodes.size() == 1);
+	Array converted;
+	converted.set_typed(Variant::OBJECT, targets.get_typed_class_name(), Variant());
+	converted.assign(nodes);
+	CHECK(converted.size() == 1);
+
+	Node *unrelated = memnew(Node);
+	ERR_PRINT_OFF;
+	targets.push_back(unrelated);
+	ERR_PRINT_ON;
+	CHECK(targets.size() == 1);
+	nodes.push_back(unrelated);
+	ERR_PRINT_OFF;
+	converted.assign(nodes);
+	ERR_PRINT_ON;
+	CHECK(converted.size() == 1);
+	memdelete(unrelated);
+
+	bool valid = false;
+	owner->set("targets", targets, &valid);
+	CHECK(valid);
+	CHECK(Array(owner->get("targets")).size() == 1);
+
+	Ref<PackedScene> scene;
+	scene.instantiate();
+	CHECK(scene->pack(owner) == OK);
+	Node *loaded = scene->instantiate();
+	REQUIRE(loaded != nullptr);
+	Array loaded_targets = loaded->get("targets");
+	REQUIRE(loaded_targets.size() == 1);
+	CHECK(loaded_targets.get_typed_class_name() == targets.get_typed_class_name());
+	Object *loaded_target = loaded_targets[0];
+	CHECK(loaded_target == loaded->get_node(NodePath("Enemy")));
+
+	memdelete(loaded);
+	memdelete(owner);
+}
+#endif // TOOLS_ENABLED
+
 TEST_CASE("[Modules][GDScript] Load source code dynamically and run it") {
 	GDScriptLanguage::get_singleton()->init();
 	Ref<GDScript> gdscript = memnew(GDScript);
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_exported_array_scene.notest.gd b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_exported_array_scene.notest.gd
new file mode 100644
index 00000000000..1bb4ba7a3cd
--- /dev/null
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_exported_array_scene.notest.gd
@@ -0,0 +1,11 @@
+extends RefCounted
+
+trait Damageable extends Node:
+	func take_damage() -> void:
+		pass
+
+class Enemy extends Node:
+	uses Damageable
+
+class Owner extends Node:
+	@export var targets: Array[Damageable] = []
diff --git a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_runtime_type_checks.gd b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_runtime_type_checks.gd
index a56f91b17fc..a8279d1734d 100644
--- a/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_runtime_type_checks.gd
+++ b/modules/gdscript/tests/scripts/Traits/analyzer/features/trait_runtime_type_checks.gd
@@ -7,6 +7,9 @@ trait Damageable extends Node:
 class Enemy extends Node:
 	uses Damageable
 
+class Owner extends Node:
+	@export var targets: Array[Damageable] = []
+
 trait UnconstrainedDamageable:
 	func take_damage() -> void:
 		print("damaged")
@@ -27,6 +30,12 @@ func null_damageable() -> Damageable:
 	return null
 
 func test() -> void:
+	var empty_typed: Array[Damageable] = []
+	Utils.check(empty_typed.get_typed_builtin() == TYPE_OBJECT)
+	Utils.check(str_to_var(var_to_str(empty_typed)) is Array[Damageable])
+	var empty_dictionary: Dictionary[Damageable, Damageable] = {}
+	Utils.check(str_to_var(var_to_str(empty_dictionary)) is Dictionary[Damageable, Damageable])
+
 	var value: Node = Enemy.new()
 	var damageable := value as Damageable
 	print(damageable != null)