9 files changed, 481 insertions, 91 deletions

diff --git a/core/string/node_path.cpp b/core/string/node_path.cpp
index d3afa7b4dd..5fae13779e 100644
--- a/core/string/node_path.cpp
+++ b/core/string/node_path.cpp
@@ -240,19 +240,26 @@ NodePath NodePath::rel_path_to(const NodePath &p_np) const {
 	common_parent--;
 
 	Vector<StringName> relpath;
+	relpath.resize(src_dirs.size() + dst_dirs.size() + 1);
 
-	for (int i = src_dirs.size() - 1; i > common_parent; i--) {
-		relpath.push_back("..");
+	StringName *relpath_ptr = relpath.ptrw();
+
+	int path_size = 0;
+	StringName back_str("..");
+	for (int i = common_parent + 1; i < src_dirs.size(); i++) {
+		relpath_ptr[path_size++] = back_str;
 	}
 
 	for (int i = common_parent + 1; i < dst_dirs.size(); i++) {
-		relpath.push_back(dst_dirs[i]);
+		relpath_ptr[path_size++] = dst_dirs[i];
 	}
 
-	if (relpath.size() == 0) {
-		relpath.push_back(".");
+	if (path_size == 0) {
+		relpath_ptr[path_size++] = ".";
 	}
 
+	relpath.resize(path_size);
+
 	return NodePath(relpath, p_np.get_subnames(), false);
 }
 
diff --git a/core/string/optimized_translation.cpp b/core/string/optimized_translation.cpp
index 268562d971..5863bd1c46 100644
--- a/core/string/optimized_translation.cpp
+++ b/core/string/optimized_translation.cpp
@@ -66,9 +66,9 @@ void OptimizedTranslation::generate(const Ref<Translation> &p_from) {
 	int total_compression_size = 0;
 	int total_string_size = 0;
 
-	for (List<StringName>::Element *E = keys.front(); E; E = E->next()) {
+	for (const StringName &E : keys) {
 		//hash string
-		CharString cs = E->get().operator String().utf8();
+		CharString cs = E.operator String().utf8();
 		uint32_t h = hash(0, cs.get_data());
 		Pair<int, CharString> p;
 		p.first = idx;
@@ -76,7 +76,7 @@ void OptimizedTranslation::generate(const Ref<Translation> &p_from) {
 		buckets.write[h % size].push_back(p);
 
 		//compress string
-		CharString src_s = p_from->get_message(E->get()).operator String().utf8();
+		CharString src_s = p_from->get_message(E).operator String().utf8();
 		CompressedString ps;
 		ps.orig_len = src_s.size();
 		ps.offset = total_compression_size;
diff --git a/core/string/string_name.cpp b/core/string/string_name.cpp
index 14b87072bb..9024f60dae 100644
--- a/core/string/string_name.cpp
+++ b/core/string/string_name.cpp
@@ -41,13 +41,17 @@ StaticCString StaticCString::create(const char *p_ptr) {
 
 StringName::_Data *StringName::_table[STRING_TABLE_LEN];
 
-StringName _scs_create(const char *p_chr) {
-	return (p_chr[0] ? StringName(StaticCString::create(p_chr)) : StringName());
+StringName _scs_create(const char *p_chr, bool p_static) {
+	return (p_chr[0] ? StringName(StaticCString::create(p_chr), p_static) : StringName());
 }
 
 bool StringName::configured = false;
 Mutex StringName::mutex;
 
+#ifdef DEBUG_ENABLED
+bool StringName::debug_stringname = false;
+#endif
+
 void StringName::setup() {
 	ERR_FAIL_COND(configured);
 	for (int i = 0; i < STRING_TABLE_LEN; i++) {
@@ -59,12 +63,29 @@ void StringName::setup() {
 void StringName::cleanup() {
 	MutexLock lock(mutex);
 
+#ifdef DEBUG_ENABLED
+	if (unlikely(debug_stringname)) {
+		Vector<_Data *> data;
+		for (int i = 0; i < STRING_TABLE_LEN; i++) {
+			_Data *d = _table[i];
+			while (d) {
+				data.push_back(d);
+				d = d->next;
+			}
+		}
+		print_line("\nStringName Reference Ranking:\n");
+		data.sort_custom<DebugSortReferences>();
+		for (int i = 0; i < MIN(100, data.size()); i++) {
+			print_line(itos(i + 1) + ": " + data[i]->get_name() + " - " + itos(data[i]->debug_references));
+		}
+	}
+#endif
 	int lost_strings = 0;
 	for (int i = 0; i < STRING_TABLE_LEN; i++) {
 		while (_table[i]) {
 			_Data *d = _table[i];
 			lost_strings++;
-			if (OS::get_singleton()->is_stdout_verbose()) {
+			if (d->static_count.get() != d->refcount.get() && OS::get_singleton()->is_stdout_verbose()) {
 				if (d->cname) {
 					print_line("Orphan StringName: " + String(d->cname));
 				} else {
@@ -79,6 +100,7 @@ void StringName::cleanup() {
 	if (lost_strings) {
 		print_verbose("StringName: " + itos(lost_strings) + " unclaimed string names at exit.");
 	}
+	configured = false;
 }
 
 void StringName::unref() {
@@ -87,6 +109,13 @@ void StringName::unref() {
 	if (_data && _data->refcount.unref()) {
 		MutexLock lock(mutex);
 
+		if (_data->static_count.get() > 0) {
+			if (_data->cname) {
+				ERR_PRINT("BUG: Unreferenced static string to 0: " + String(_data->cname));
+			} else {
+				ERR_PRINT("BUG: Unreferenced static string to 0: " + String(_data->name));
+			}
+		}
 		if (_data->prev) {
 			_data->prev->next = _data->next;
 		} else {
@@ -153,7 +182,7 @@ StringName::StringName(const StringName &p_name) {
 	}
 }
 
-StringName::StringName(const char *p_name) {
+StringName::StringName(const char *p_name, bool p_static) {
 	_data = nullptr;
 
 	ERR_FAIL_COND(!configured);
@@ -181,25 +210,42 @@ StringName::StringName(const char *p_name) {
 	if (_data) {
 		if (_data->refcount.ref()) {
 			// exists
-			return;
+			if (p_static) {
+				_data->static_count.increment();
+			}
+#ifdef DEBUG_ENABLED
+			if (unlikely(debug_stringname)) {
+				_data->debug_references++;
+			}
+#endif
 		}
+
+		return;
 	}
 
 	_data = memnew(_Data);
 	_data->name = p_name;
 	_data->refcount.init();
+	_data->static_count.set(p_static ? 1 : 0);
 	_data->hash = hash;
 	_data->idx = idx;
 	_data->cname = nullptr;
 	_data->next = _table[idx];
 	_data->prev = nullptr;
+#ifdef DEBUG_ENABLED
+	if (unlikely(debug_stringname)) {
+		// Keep in memory, force static.
+		_data->refcount.ref();
+		_data->static_count.increment();
+	}
+#endif
 	if (_table[idx]) {
 		_table[idx]->prev = _data;
 	}
 	_table[idx] = _data;
 }
 
-StringName::StringName(const StaticCString &p_static_string) {
+StringName::StringName(const StaticCString &p_static_string, bool p_static) {
 	_data = nullptr;
 
 	ERR_FAIL_COND(!configured);
@@ -225,6 +271,14 @@ StringName::StringName(const StaticCString &p_static_string) {
 	if (_data) {
 		if (_data->refcount.ref()) {
 			// exists
+			if (p_static) {
+				_data->static_count.increment();
+			}
+#ifdef DEBUG_ENABLED
+			if (unlikely(debug_stringname)) {
+				_data->debug_references++;
+			}
+#endif
 			return;
 		}
 	}
@@ -232,18 +286,26 @@ StringName::StringName(const StaticCString &p_static_string) {
 	_data = memnew(_Data);
 
 	_data->refcount.init();
+	_data->static_count.set(p_static ? 1 : 0);
 	_data->hash = hash;
 	_data->idx = idx;
 	_data->cname = p_static_string.ptr;
 	_data->next = _table[idx];
 	_data->prev = nullptr;
+#ifdef DEBUG_ENABLED
+	if (unlikely(debug_stringname)) {
+		// Keep in memory, force static.
+		_data->refcount.ref();
+		_data->static_count.increment();
+	}
+#endif
 	if (_table[idx]) {
 		_table[idx]->prev = _data;
 	}
 	_table[idx] = _data;
 }
 
-StringName::StringName(const String &p_name) {
+StringName::StringName(const String &p_name, bool p_static) {
 	_data = nullptr;
 
 	ERR_FAIL_COND(!configured);
@@ -269,6 +331,14 @@ StringName::StringName(const String &p_name) {
 	if (_data) {
 		if (_data->refcount.ref()) {
 			// exists
+			if (p_static) {
+				_data->static_count.increment();
+			}
+#ifdef DEBUG_ENABLED
+			if (unlikely(debug_stringname)) {
+				_data->debug_references++;
+			}
+#endif
 			return;
 		}
 	}
@@ -276,11 +346,20 @@ StringName::StringName(const String &p_name) {
 	_data = memnew(_Data);
 	_data->name = p_name;
 	_data->refcount.init();
+	_data->static_count.set(p_static ? 1 : 0);
 	_data->hash = hash;
 	_data->idx = idx;
 	_data->cname = nullptr;
 	_data->next = _table[idx];
 	_data->prev = nullptr;
+#ifdef DEBUG_ENABLED
+	if (unlikely(debug_stringname)) {
+		// Keep in memory, force static.
+		_data->refcount.ref();
+		_data->static_count.increment();
+	}
+#endif
+
 	if (_table[idx]) {
 		_table[idx]->prev = _data;
 	}
@@ -311,6 +390,12 @@ StringName StringName::search(const char *p_name) {
 	}
 
 	if (_data && _data->refcount.ref()) {
+#ifdef DEBUG_ENABLED
+		if (unlikely(debug_stringname)) {
+			_data->debug_references++;
+		}
+#endif
+
 		return StringName(_data);
 	}
 
@@ -368,16 +453,17 @@ StringName StringName::search(const String &p_name) {
 	}
 
 	if (_data && _data->refcount.ref()) {
+#ifdef DEBUG_ENABLED
+		if (unlikely(debug_stringname)) {
+			_data->debug_references++;
+		}
+#endif
 		return StringName(_data);
 	}
 
 	return StringName(); //does not exist
 }
 
-StringName::~StringName() {
-	unref();
-}
-
 bool operator==(const String &p_name, const StringName &p_string_name) {
 	return p_name == p_string_name.operator String();
 }
diff --git a/core/string/string_name.h b/core/string/string_name.h
index 44d0ea14fa..ce7988744b 100644
--- a/core/string/string_name.h
+++ b/core/string/string_name.h
@@ -44,16 +44,19 @@ struct StaticCString {
 
 class StringName {
 	enum {
-		STRING_TABLE_BITS = 12,
+		STRING_TABLE_BITS = 16,
 		STRING_TABLE_LEN = 1 << STRING_TABLE_BITS,
 		STRING_TABLE_MASK = STRING_TABLE_LEN - 1
 	};
 
 	struct _Data {
 		SafeRefCount refcount;
+		SafeNumeric<uint32_t> static_count;
 		const char *cname = nullptr;
 		String name;
-
+#ifdef DEBUG_ENABLED
+		uint32_t debug_references = 0;
+#endif
 		String get_name() const { return cname ? String(cname) : name; }
 		int idx = 0;
 		uint32_t hash = 0;
@@ -79,6 +82,15 @@ class StringName {
 	static void setup();
 	static void cleanup();
 	static bool configured;
+#ifdef DEBUG_ENABLED
+	struct DebugSortReferences {
+		bool operator()(const _Data *p_left, const _Data *p_right) const {
+			return p_left->debug_references > p_right->debug_references;
+		}
+	};
+
+	static bool debug_stringname;
+#endif
 
 	StringName(_Data *p_data) { _data = p_data; }
 
@@ -146,12 +158,20 @@ public:
 	};
 
 	void operator=(const StringName &p_name);
-	StringName(const char *p_name);
+	StringName(const char *p_name, bool p_static = false);
 	StringName(const StringName &p_name);
-	StringName(const String &p_name);
-	StringName(const StaticCString &p_static_string);
+	StringName(const String &p_name, bool p_static = false);
+	StringName(const StaticCString &p_static_string, bool p_static = false);
 	StringName() {}
-	~StringName();
+	_FORCE_INLINE_ ~StringName() {
+		if (likely(configured) && _data) { //only free if configured
+			unref();
+		}
+	}
+
+#ifdef DEBUG_ENABLED
+	static void set_debug_stringnames(bool p_enable) { debug_stringname = p_enable; }
+#endif
 };
 
 bool operator==(const String &p_name, const StringName &p_string_name);
@@ -159,6 +179,8 @@ bool operator!=(const String &p_name, const StringName &p_string_name);
 bool operator==(const char *p_name, const StringName &p_string_name);
 bool operator!=(const char *p_name, const StringName &p_string_name);
 
-StringName _scs_create(const char *p_chr);
+StringName _scs_create(const char *p_chr, bool p_static = false);
+
+#define SNAME(m_arg) ([]() -> const StringName & { static StringName sname = _scs_create(m_arg, true); return sname; })()
 
 #endif // STRING_NAME_H
diff --git a/core/string/translation.cpp b/core/string/translation.cpp
index 153f0190fd..cb7d924556 100644
--- a/core/string/translation.cpp
+++ b/core/string/translation.cpp
@@ -84,6 +84,7 @@ static const char *locale_list[] = {
 	"ast_ES", //  Asturian (Spain)
 	"ayc_PE", //  Southern Aymara (Peru)
 	"ay_PE", //  Aymara (Peru)
+	"az", //  Azerbaijani
 	"az_AZ", //  Azerbaijani (Azerbaijan)
 	"be", //  Belarusian
 	"be_BY", //  Belarusian (Belarus)
@@ -240,6 +241,7 @@ static const char *locale_list[] = {
 	"ka_GE", //  Georgian (Georgia)
 	"kk_KZ", //  Kazakh (Kazakhstan)
 	"kl_GL", //  Kalaallisut (Greenland)
+	"km", //  Central Khmer
 	"km_KH", //  Central Khmer (Cambodia)
 	"kn_IN", //  Kannada (India)
 	"kok_IN", //  Konkani (India)
@@ -390,6 +392,7 @@ static const char *locale_list[] = {
 	"tr_CY", //  Turkish (Cyprus)
 	"tr_TR", //  Turkish (Turkey)
 	"ts_ZA", //  Tsonga (South Africa)
+	"tt", //  Tatar
 	"tt_RU", //  Tatar (Russia)
 	"tzm", // Central Atlas Tamazight
 	"tzm_MA", // Central Atlas Tamazight (Marrocos)
@@ -458,6 +461,7 @@ static const char *locale_names[] = {
 	"Asturian (Spain)",
 	"Southern Aymara (Peru)",
 	"Aymara (Peru)",
+	"Azerbaijani",
 	"Azerbaijani (Azerbaijan)",
 	"Belarusian",
 	"Belarusian (Belarus)",
@@ -614,6 +618,7 @@ static const char *locale_names[] = {
 	"Georgian (Georgia)",
 	"Kazakh (Kazakhstan)",
 	"Kalaallisut (Greenland)",
+	"Central Khmer",
 	"Central Khmer (Cambodia)",
 	"Kannada (India)",
 	"Konkani (India)",
@@ -764,6 +769,7 @@ static const char *locale_names[] = {
 	"Turkish (Cyprus)",
 	"Turkish (Turkey)",
 	"Tsonga (South Africa)",
+	"Tatar",
 	"Tatar (Russia)",
 	"Central Atlas Tamazight",
 	"Central Atlas Tamazight (Marrocos)",
@@ -835,8 +841,8 @@ Vector<String> Translation::_get_message_list() const {
 void Translation::_set_messages(const Dictionary &p_messages) {
 	List<Variant> keys;
 	p_messages.get_key_list(&keys);
-	for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
-		translation_map[E->get()] = p_messages[E->get()];
+	for (const Variant &E : keys) {
+		translation_map[E] = p_messages[E];
 	}
 }
 
@@ -923,6 +929,66 @@ void Translation::_bind_methods() {
 
 ///////////////////////////////////////////////
 
+struct _character_accent_pair {
+	const char32_t character;
+	const char32_t *accented_character;
+};
+
+static _character_accent_pair _character_to_accented[] = {
+	{ 'A', U"Å" },
+	{ 'B', U"ß" },
+	{ 'C', U"Ç" },
+	{ 'D', U"Ð" },
+	{ 'E', U"É" },
+	{ 'F', U"F́" },
+	{ 'G', U"Ĝ" },
+	{ 'H', U"Ĥ" },
+	{ 'I', U"Ĩ" },
+	{ 'J', U"Ĵ" },
+	{ 'K', U"ĸ" },
+	{ 'L', U"Ł" },
+	{ 'M', U"Ḿ" },
+	{ 'N', U"й" },
+	{ 'O', U"Ö" },
+	{ 'P', U"Ṕ" },
+	{ 'Q', U"Q́" },
+	{ 'R', U"Ř" },
+	{ 'S', U"Ŝ" },
+	{ 'T', U"Ŧ" },
+	{ 'U', U"Ũ" },
+	{ 'V', U"Ṽ" },
+	{ 'W', U"Ŵ" },
+	{ 'X', U"X́" },
+	{ 'Y', U"Ÿ" },
+	{ 'Z', U"Ž" },
+	{ 'a', U"á" },
+	{ 'b', U"ḅ" },
+	{ 'c', U"ć" },
+	{ 'd', U"d́" },
+	{ 'e', U"é" },
+	{ 'f', U"f́" },
+	{ 'g', U"ǵ" },
+	{ 'h', U"h̀" },
+	{ 'i', U"í" },
+	{ 'j', U"ǰ" },
+	{ 'k', U"ḱ" },
+	{ 'l', U"ł" },
+	{ 'm', U"m̀" },
+	{ 'n', U"ή" },
+	{ 'o', U"ô" },
+	{ 'p', U"ṕ" },
+	{ 'q', U"q́" },
+	{ 'r', U"ŕ" },
+	{ 's', U"š" },
+	{ 't', U"ŧ" },
+	{ 'u', U"ü" },
+	{ 'v', U"ṽ" },
+	{ 'w', U"ŵ" },
+	{ 'x', U"x́" },
+	{ 'y', U"ý" },
+	{ 'z', U"ź" },
+};
+
 bool TranslationServer::is_locale_valid(const String &p_locale) {
 	const char **ptr = locale_list;
 
@@ -1095,10 +1161,10 @@ StringName TranslationServer::translate(const StringName &p_message, const Strin
 	}
 
 	if (!res) {
-		return p_message;
+		return pseudolocalization_enabled ? pseudolocalize(p_message) : p_message;
 	}
 
-	return res;
+	return pseudolocalization_enabled ? pseudolocalize(res) : res;
 }
 
 StringName TranslationServer::translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
@@ -1211,7 +1277,18 @@ void TranslationServer::setup() {
 	} else {
 		set_locale(OS::get_singleton()->get_locale());
 	}
+
 	fallback = GLOBAL_DEF("internationalization/locale/fallback", "en");
+	pseudolocalization_enabled = GLOBAL_DEF("internationalization/pseudolocalization/use_pseudolocalization", false);
+	pseudolocalization_accents_enabled = GLOBAL_DEF("internationalization/pseudolocalization/replace_with_accents", true);
+	pseudolocalization_double_vowels_enabled = GLOBAL_DEF("internationalization/pseudolocalization/double_vowels", false);
+	pseudolocalization_fake_bidi_enabled = GLOBAL_DEF("internationalization/pseudolocalization/fake_bidi", false);
+	pseudolocalization_override_enabled = GLOBAL_DEF("internationalization/pseudolocalization/override", false);
+	expansion_ratio = GLOBAL_DEF("internationalization/pseudolocalization/expansion_ratio", 0.0);
+	pseudolocalization_prefix = GLOBAL_DEF("internationalization/pseudolocalization/prefix", "[");
+	pseudolocalization_suffix = GLOBAL_DEF("internationalization/pseudolocalization/suffix", "]");
+	pseudolocalization_skip_placeholders_enabled = GLOBAL_DEF("internationalization/pseudolocalization/skip_placeholders", true);
+
 #ifdef TOOLS_ENABLED
 	{
 		String options = "";
@@ -1252,10 +1329,10 @@ StringName TranslationServer::tool_translate(const StringName &p_message, const
 	if (tool_translation.is_valid()) {
 		StringName r = tool_translation->get_message(p_message, p_context);
 		if (r) {
-			return r;
+			return editor_pseudolocalization ? tool_pseudolocalize(r) : r;
 		}
 	}
-	return p_message;
+	return editor_pseudolocalization ? tool_pseudolocalize(p_message) : p_message;
 }
 
 StringName TranslationServer::tool_translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
@@ -1300,6 +1377,181 @@ StringName TranslationServer::doc_translate_plural(const StringName &p_message,
 	return p_message_plural;
 }
 
+bool TranslationServer::is_pseudolocalization_enabled() const {
+	return pseudolocalization_enabled;
+}
+
+void TranslationServer::set_pseudolocalization_enabled(bool p_enabled) {
+	pseudolocalization_enabled = p_enabled;
+
+	if (OS::get_singleton()->get_main_loop()) {
+		OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_TRANSLATION_CHANGED);
+	}
+	ResourceLoader::reload_translation_remaps();
+}
+
+void TranslationServer::set_editor_pseudolocalization(bool p_enabled) {
+	editor_pseudolocalization = p_enabled;
+}
+
+void TranslationServer::reload_pseudolocalization() {
+	pseudolocalization_accents_enabled = GLOBAL_GET("internationalization/pseudolocalization/replace_with_accents");
+	pseudolocalization_double_vowels_enabled = GLOBAL_GET("internationalization/pseudolocalization/double_vowels");
+	pseudolocalization_fake_bidi_enabled = GLOBAL_GET("internationalization/pseudolocalization/fake_bidi");
+	pseudolocalization_override_enabled = GLOBAL_GET("internationalization/pseudolocalization/override");
+	expansion_ratio = GLOBAL_GET("internationalization/pseudolocalization/expansion_ratio");
+	pseudolocalization_prefix = GLOBAL_GET("internationalization/pseudolocalization/prefix");
+	pseudolocalization_suffix = GLOBAL_GET("internationalization/pseudolocalization/suffix");
+	pseudolocalization_skip_placeholders_enabled = GLOBAL_GET("internationalization/pseudolocalization/skip_placeholders");
+
+	if (OS::get_singleton()->get_main_loop()) {
+		OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_TRANSLATION_CHANGED);
+	}
+	ResourceLoader::reload_translation_remaps();
+}
+
+StringName TranslationServer::pseudolocalize(const StringName &p_message) const {
+	String message = p_message;
+	int length = message.length();
+	if (pseudolocalization_override_enabled) {
+		message = get_override_string(message);
+	}
+
+	if (pseudolocalization_double_vowels_enabled) {
+		message = double_vowels(message);
+	}
+
+	if (pseudolocalization_accents_enabled) {
+		message = replace_with_accented_string(message);
+	}
+
+	if (pseudolocalization_fake_bidi_enabled) {
+		message = wrap_with_fakebidi_characters(message);
+	}
+
+	StringName res = add_padding(message, length);
+	return res;
+}
+
+StringName TranslationServer::tool_pseudolocalize(const StringName &p_message) const {
+	String message = p_message;
+	message = double_vowels(message);
+	message = replace_with_accented_string(message);
+	StringName res = "[!!! " + message + " !!!]";
+	return res;
+}
+
+String TranslationServer::get_override_string(String &p_message) const {
+	String res;
+	for (int i = 0; i < p_message.size(); i++) {
+		if (pseudolocalization_skip_placeholders_enabled && is_placeholder(p_message, i)) {
+			res += p_message[i];
+			res += p_message[i + 1];
+			i++;
+			continue;
+		}
+		res += '*';
+	}
+	return res;
+}
+
+String TranslationServer::double_vowels(String &p_message) const {
+	String res;
+	for (int i = 0; i < p_message.size(); i++) {
+		if (pseudolocalization_skip_placeholders_enabled && is_placeholder(p_message, i)) {
+			res += p_message[i];
+			res += p_message[i + 1];
+			i++;
+			continue;
+		}
+		res += p_message[i];
+		if (p_message[i] == 'a' || p_message[i] == 'e' || p_message[i] == 'i' || p_message[i] == 'o' || p_message[i] == 'u' ||
+				p_message[i] == 'A' || p_message[i] == 'E' || p_message[i] == 'I' || p_message[i] == 'O' || p_message[i] == 'U') {
+			res += p_message[i];
+		}
+	}
+	return res;
+};
+
+String TranslationServer::replace_with_accented_string(String &p_message) const {
+	String res;
+	for (int i = 0; i < p_message.size(); i++) {
+		if (pseudolocalization_skip_placeholders_enabled && is_placeholder(p_message, i)) {
+			res += p_message[i];
+			res += p_message[i + 1];
+			i++;
+			continue;
+		}
+		const char32_t *accented = get_accented_version(p_message[i]);
+		if (accented) {
+			res += accented;
+		} else {
+			res += p_message[i];
+		}
+	}
+	return res;
+}
+
+String TranslationServer::wrap_with_fakebidi_characters(String &p_message) const {
+	String res;
+	char32_t fakebidiprefix = U'\u202e';
+	char32_t fakebidisuffix = U'\u202c';
+	res += fakebidiprefix;
+	// The fake bidi unicode gets popped at every newline so pushing it back at every newline.
+	for (int i = 0; i < p_message.size(); i++) {
+		if (p_message[i] == '\n') {
+			res += fakebidisuffix;
+			res += p_message[i];
+			res += fakebidiprefix;
+		} else if (pseudolocalization_skip_placeholders_enabled && is_placeholder(p_message, i)) {
+			res += fakebidisuffix;
+			res += p_message[i];
+			res += p_message[i + 1];
+			res += fakebidiprefix;
+			i++;
+		} else {
+			res += p_message[i];
+		}
+	}
+	res += fakebidisuffix;
+	return res;
+}
+
+String TranslationServer::add_padding(String &p_message, int p_length) const {
+	String res;
+	String prefix = pseudolocalization_prefix;
+	String suffix;
+	for (int i = 0; i < p_length * expansion_ratio / 2; i++) {
+		prefix += "_";
+		suffix += "_";
+	}
+	suffix += pseudolocalization_suffix;
+	res += prefix;
+	res += p_message;
+	res += suffix;
+	return res;
+}
+
+const char32_t *TranslationServer::get_accented_version(char32_t p_character) const {
+	if (!((p_character >= 'a' && p_character <= 'z') || (p_character >= 'A' && p_character <= 'Z'))) {
+		return nullptr;
+	}
+
+	for (unsigned int i = 0; i < sizeof(_character_to_accented) / sizeof(_character_to_accented[0]); i++) {
+		if (_character_to_accented[i].character == p_character) {
+			return _character_to_accented[i].accented_character;
+		}
+	}
+
+	return nullptr;
+}
+
+bool TranslationServer::is_placeholder(String &p_message, int p_index) const {
+	return p_message[p_index] == '%' && p_index < p_message.size() - 1 &&
+		   (p_message[p_index + 1] == 's' || p_message[p_index + 1] == 'c' || p_message[p_index + 1] == 'd' ||
+				   p_message[p_index + 1] == 'o' || p_message[p_index + 1] == 'x' || p_message[p_index + 1] == 'X' || p_message[p_index + 1] == 'f');
+}
+
 void TranslationServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_locale", "locale"), &TranslationServer::set_locale);
 	ClassDB::bind_method(D_METHOD("get_locale"), &TranslationServer::get_locale);
@@ -1316,6 +1568,12 @@ void TranslationServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("clear"), &TranslationServer::clear);
 
 	ClassDB::bind_method(D_METHOD("get_loaded_locales"), &TranslationServer::get_loaded_locales);
+
+	ClassDB::bind_method(D_METHOD("is_pseudolocalization_enabled"), &TranslationServer::is_pseudolocalization_enabled);
+	ClassDB::bind_method(D_METHOD("set_pseudolocalization_enabled", "enabled"), &TranslationServer::set_pseudolocalization_enabled);
+	ClassDB::bind_method(D_METHOD("reload_pseudolocalization"), &TranslationServer::reload_pseudolocalization);
+	ClassDB::bind_method(D_METHOD("pseudolocalize", "message"), &TranslationServer::pseudolocalize);
+	ADD_PROPERTY(PropertyInfo(Variant::Type::BOOL, "pseudolocalization_enabled"), "set_pseudolocalization_enabled", "is_pseudolocalization_enabled");
 }
 
 void TranslationServer::load_translations() {
diff --git a/core/string/translation.h b/core/string/translation.h
index 72a828227e..4f179ac0fe 100644
--- a/core/string/translation.h
+++ b/core/string/translation.h
@@ -77,6 +77,26 @@ class TranslationServer : public Object {
 
 	bool enabled = true;
 
+	bool pseudolocalization_enabled = false;
+	bool pseudolocalization_accents_enabled = false;
+	bool pseudolocalization_double_vowels_enabled = false;
+	bool pseudolocalization_fake_bidi_enabled = false;
+	bool pseudolocalization_override_enabled = false;
+	bool pseudolocalization_skip_placeholders_enabled = false;
+	bool editor_pseudolocalization = false;
+	float expansion_ratio = 0.0;
+	String pseudolocalization_prefix;
+	String pseudolocalization_suffix;
+
+	StringName tool_pseudolocalize(const StringName &p_message) const;
+	String get_override_string(String &p_message) const;
+	String double_vowels(String &p_message) const;
+	String replace_with_accented_string(String &p_message) const;
+	String wrap_with_fakebidi_characters(String &p_message) const;
+	String add_padding(String &p_message, int p_length) const;
+	const char32_t *get_accented_version(char32_t p_character) const;
+	bool is_placeholder(String &p_message, int p_index) const;
+
 	static TranslationServer *singleton;
 	bool _load_translations(const String &p_from);
 
@@ -104,6 +124,13 @@ public:
 	StringName translate(const StringName &p_message, const StringName &p_context = "") const;
 	StringName translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context = "") const;
 
+	StringName pseudolocalize(const StringName &p_message) const;
+
+	bool is_pseudolocalization_enabled() const;
+	void set_pseudolocalization_enabled(bool p_enabled);
+	void set_editor_pseudolocalization(bool p_enabled);
+	void reload_pseudolocalization();
+
 	static Vector<String> get_all_locales();
 	static Vector<String> get_all_locale_names();
 	static bool is_locale_valid(const String &p_locale);
diff --git a/core/string/translation_po.cpp b/core/string/translation_po.cpp
index ad768f7140..1da00aa54b 100644
--- a/core/string/translation_po.cpp
+++ b/core/string/translation_po.cpp
@@ -30,7 +30,7 @@
 
 #include "translation_po.h"
 
-#include "core/os/file_access.h"
+#include "core/io/file_access.h"
 
 #ifdef DEBUG_TRANSLATION_PO
 void TranslationPO::print_translation_map() {
@@ -47,8 +47,7 @@ void TranslationPO::print_translation_map() {
 
 	List<StringName> context_l;
 	translation_map.get_key_list(&context_l);
-	for (List<StringName>::Element *E = context_l.front(); E; E = E->next()) {
-		StringName ctx = E->get();
+	for (const StringName &ctx : context_l) {
 		file->store_line(" ===== Context: " + String::utf8(String(ctx).utf8()) + " ===== ");
 		const HashMap<StringName, Vector<StringName>> &inner_map = translation_map[ctx];
 
@@ -74,8 +73,7 @@ Dictionary TranslationPO::_get_messages() const {
 
 	List<StringName> context_l;
 	translation_map.get_key_list(&context_l);
-	for (List<StringName>::Element *E = context_l.front(); E; E = E->next()) {
-		StringName ctx = E->get();
+	for (const StringName &ctx : context_l) {
 		const HashMap<StringName, Vector<StringName>> &id_str_map = translation_map[ctx];
 
 		Dictionary d2;
@@ -98,8 +96,7 @@ void TranslationPO::_set_messages(const Dictionary &p_messages) {
 
 	List<Variant> context_l;
 	p_messages.get_key_list(&context_l);
-	for (List<Variant>::Element *E = context_l.front(); E; E = E->next()) {
-		StringName ctx = E->get();
+	for (const Variant &ctx : context_l) {
 		const Dictionary &id_str_map = p_messages[ctx];
 
 		HashMap<StringName, Vector<StringName>> temp_map;
@@ -121,8 +118,8 @@ Vector<String> TranslationPO::_get_message_list() const {
 	get_message_list(&msgs);
 
 	Vector<String> v;
-	for (List<StringName>::Element *E = msgs.front(); E; E = E->next()) {
-		v.push_back(E->get());
+	for (const StringName &E : msgs) {
+		v.push_back(E);
 	}
 
 	return v;
@@ -188,7 +185,7 @@ void TranslationPO::set_plural_rule(const String &p_plural_rule) {
 	plural_rule = plural_rule.replacen("(", "");
 	plural_rule = plural_rule.replacen(")", "");
 	_cache_plural_tests(plural_rule);
-	expr.instance();
+	expr.instantiate();
 	input_name.push_back("n");
 }
 
@@ -281,13 +278,13 @@ void TranslationPO::get_message_list(List<StringName> *r_messages) const {
 	List<StringName> context_l;
 	translation_map.get_key_list(&context_l);
 
-	for (List<StringName>::Element *E = context_l.front(); E; E = E->next()) {
-		if (String(E->get()) != "") {
+	for (const StringName &E : context_l) {
+		if (String(E) != "") {
 			continue;
 		}
 
 		List<StringName> msgid_l;
-		translation_map[E->get()].get_key_list(&msgid_l);
+		translation_map[E].get_key_list(&msgid_l);
 
 		for (List<StringName>::Element *E2 = msgid_l.front(); E2; E2 = E2->next()) {
 			r_messages->push_back(E2->get());
@@ -300,8 +297,8 @@ int TranslationPO::get_message_count() const {
 	translation_map.get_key_list(&context_l);
 
 	int count = 0;
-	for (List<StringName>::Element *E = context_l.front(); E; E = E->next()) {
-		count += translation_map[E->get()].size();
+	for (const StringName &E : context_l) {
+		count += translation_map[E].size();
 	}
 	return count;
 }
diff --git a/core/string/ustring.cpp b/core/string/ustring.cpp
index 49cf171f2b..7beecdb6b5 100644
--- a/core/string/ustring.cpp
+++ b/core/string/ustring.cpp
@@ -54,7 +54,7 @@
 #define snprintf _snprintf_s
 #endif
 
-#define MAX_DIGITS 6
+#define MAX_DECIMALS 32
 #define UPPERCASE(m_c) (((m_c) >= 'a' && (m_c) <= 'z') ? ((m_c) - ('a' - 'A')) : (m_c))
 #define LOWERCASE(m_c) (((m_c) >= 'A' && (m_c) <= 'Z') ? ((m_c) + ('a' - 'A')) : (m_c))
 #define IS_DIGIT(m_d) ((m_d) >= '0' && (m_d) <= '9')
@@ -275,7 +275,7 @@ Error String::parse_url(String &r_scheme, String &r_host, int &r_port, String &r
 		base = base.substr(pos + 1, base.length() - pos - 1);
 	} else {
 		// Anything else
-		if (base.get_slice_count(":") > 1) {
+		if (base.get_slice_count(":") > 2) {
 			return ERR_INVALID_PARAMETER;
 		}
 		pos = base.rfind(":");
@@ -294,7 +294,7 @@ Error String::parse_url(String &r_scheme, String &r_host, int &r_port, String &r
 	// Port
 	if (base.begins_with(":")) {
 		base = base.substr(1, base.length() - 1);
-		if (!base.is_valid_integer()) {
+		if (!base.is_valid_int()) {
 			return ERR_INVALID_PARAMETER;
 		}
 		r_port = base.to_int();
@@ -1379,8 +1379,11 @@ String String::num(double p_num, int p_decimals) {
 	}
 #ifndef NO_USE_STDLIB
 
-	if (p_decimals > 16) {
-		p_decimals = 16;
+	if (p_decimals < 0) {
+		p_decimals = 14 - (int)floor(log10(p_num));
+	}
+	if (p_decimals > MAX_DECIMALS) {
+		p_decimals = MAX_DECIMALS;
 	}
 
 	char fmt[7];
@@ -1391,7 +1394,6 @@ String String::num(double p_num, int p_decimals) {
 		fmt[1] = 'l';
 		fmt[2] = 'f';
 		fmt[3] = 0;
-
 	} else if (p_decimals < 10) {
 		fmt[2] = '0' + p_decimals;
 		fmt[3] = 'l';
@@ -1458,8 +1460,9 @@ String String::num(double p_num, int p_decimals) {
 		double dec = p_num - (double)((int)p_num);
 
 		int digit = 0;
-		if (p_decimals > MAX_DIGITS)
-			p_decimals = MAX_DIGITS;
+		if (p_decimals > MAX_DECIMALS) {
+			p_decimals = MAX_DECIMALS;
+		}
 
 		int dec_int = 0;
 		int dec_max = 0;
@@ -1471,16 +1474,18 @@ String String::num(double p_num, int p_decimals) {
 			digit++;
 
 			if (p_decimals == -1) {
-				if (digit == MAX_DIGITS) //no point in going to infinite
+				if (digit == MAX_DECIMALS) { //no point in going to infinite
 					break;
+				}
 
 				if (dec - (double)((int)dec) < 1e-6) {
 					break;
 				}
 			}
 
-			if (digit == p_decimals)
+			if (digit == p_decimals) {
 				break;
+			}
 		}
 		dec *= 10;
 		int last = (int)dec % 10;
@@ -1589,7 +1594,7 @@ String String::num_uint64(uint64_t p_num, int base, bool capitalize_hex) {
 	return s;
 }
 
-String String::num_real(double p_num) {
+String String::num_real(double p_num, bool p_trailing) {
 	if (Math::is_nan(p_num)) {
 		return "nan";
 	}
@@ -1616,7 +1621,15 @@ String String::num_real(double p_num) {
 		double dec = p_num - (double)((int)p_num);
 
 		int digit = 0;
-		int decimals = MAX_DIGITS;
+
+#if REAL_T_IS_DOUBLE
+		int decimals = 14 - (int)floor(log10(p_num));
+#else
+		int decimals = 6 - (int)floor(log10(p_num));
+#endif
+		if (decimals > MAX_DECIMALS) {
+			decimals = MAX_DECIMALS;
+		}
 
 		int dec_int = 0;
 		int dec_max = 0;
@@ -1656,8 +1669,10 @@ String String::num_real(double p_num) {
 			dec_int /= 10;
 		}
 		sd = '.' + decimal;
-	} else {
+	} else if (p_trailing) {
 		sd = ".0";
+	} else {
+		sd = "";
 	}
 
 	if (intn == 0) {
@@ -3382,17 +3397,10 @@ String String::format(const Variant &values, String placeholder) const {
 				if (value_arr.size() == 2) {
 					Variant v_key = value_arr[0];
 					String key = v_key;
-					if (key.left(1) == "\"" && key.right(1) == "\"") {
-						key = key.substr(1, key.length() - 2);
-					}
 
 					Variant v_val = value_arr[1];
 					String val = v_val;
 
-					if (val.left(1) == "\"" && val.right(1) == "\"") {
-						val = val.substr(1, val.length() - 2);
-					}
-
 					new_string = new_string.replace(placeholder.replace("_", key), val);
 				} else {
 					ERR_PRINT(String("STRING.format Inner Array size != 2 ").ascii().get_data());
@@ -3401,10 +3409,6 @@ String String::format(const Variant &values, String placeholder) const {
 				Variant v_val = values_arr[i];
 				String val = v_val;
 
-				if (val.left(1) == "\"" && val.right(1) == "\"") {
-					val = val.substr(1, val.length() - 2);
-				}
-
 				if (placeholder.find("_") > -1) {
 					new_string = new_string.replace(placeholder.replace("_", i_as_str), val);
 				} else {
@@ -3417,19 +3421,8 @@ String String::format(const Variant &values, String placeholder) const {
 		List<Variant> keys;
 		d.get_key_list(&keys);
 
-		for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
-			String key = E->get();
-			String val = d[E->get()];
-
-			if (key.left(1) == "\"" && key.right(1) == "\"") {
-				key = key.substr(1, key.length() - 2);
-			}
-
-			if (val.left(1) == "\"" && val.right(1) == "\"") {
-				val = val.substr(1, val.length() - 2);
-			}
-
-			new_string = new_string.replace(placeholder.replace("_", key), val);
+		for (const Variant &key : keys) {
+			new_string = new_string.replace(placeholder.replace("_", key), d[key]);
 		}
 	} else {
 		ERR_PRINT(String("Invalid type: use Array or Dictionary.").ascii().get_data());
@@ -3786,7 +3779,7 @@ String String::humanize_size(uint64_t p_size) {
 	return String::num(p_size / divisor).pad_decimals(digits) + " " + prefixes[prefix_idx];
 }
 
-bool String::is_abs_path() const {
+bool String::is_absolute_path() const {
 	if (length() > 1) {
 		return (operator[](0) == '/' || operator[](0) == '\\' || find(":/") != -1 || find(":\\") != -1);
 	} else if ((length()) == 1) {
@@ -4153,7 +4146,7 @@ String String::trim_suffix(const String &p_suffix) const {
 	return s;
 }
 
-bool String::is_valid_integer() const {
+bool String::is_valid_int() const {
 	int len = length();
 
 	if (len == 0) {
@@ -4378,7 +4371,7 @@ bool String::is_valid_ip_address() const {
 		}
 		for (int i = 0; i < ip.size(); i++) {
 			String n = ip[i];
-			if (!n.is_valid_integer()) {
+			if (!n.is_valid_int()) {
 				return false;
 			}
 			int val = n.to_int();
@@ -4396,7 +4389,7 @@ bool String::is_resource_file() const {
 }
 
 bool String::is_rel_path() const {
-	return !is_abs_path();
+	return !is_absolute_path();
 }
 
 String String::get_base_dir() const {
diff --git a/core/string/ustring.h b/core/string/ustring.h
index a56845deff..ffb354d6e1 100644
--- a/core/string/ustring.h
+++ b/core/string/ustring.h
@@ -309,7 +309,7 @@ public:
 	String unquote() const;
 	static String num(double p_num, int p_decimals = -1);
 	static String num_scientific(double p_num);
-	static String num_real(double p_num);
+	static String num_real(double p_num, bool p_trailing = true);
 	static String num_int64(int64_t p_num, int base = 10, bool capitalize_hex = false);
 	static String num_uint64(uint64_t p_num, int base = 10, bool capitalize_hex = false);
 	static String chr(char32_t p_char);
@@ -397,7 +397,7 @@ public:
 	_FORCE_INLINE_ bool is_empty() const { return length() == 0; }
 
 	// path functions
-	bool is_abs_path() const;
+	bool is_absolute_path() const;
 	bool is_rel_path() const;
 	bool is_resource_file() const;
 	String path_to(const String &p_path) const;
@@ -425,7 +425,7 @@ public:
 	String validate_node_name() const;
 
 	bool is_valid_identifier() const;
-	bool is_valid_integer() const;
+	bool is_valid_int() const;
 	bool is_valid_float() const;
 	bool is_valid_hex_number(bool p_with_prefix) const;
 	bool is_valid_html_color() const;