9 files changed, 248 insertions, 158 deletions

diff --git a/platform/linuxbsd/detect.py b/platform/linuxbsd/detect.py
index 3f713d2db3..54351757cd 100644
--- a/platform/linuxbsd/detect.py
+++ b/platform/linuxbsd/detect.py
@@ -70,7 +70,7 @@ def configure(env: "Environment"):
             'Unsupported CPU architecture "%s" for Linux / *BSD. Supported architectures are: %s.'
             % (env["arch"], ", ".join(supported_arches))
         )
-        sys.exit()
+        sys.exit(255)
 
     ## Build type
 
@@ -208,7 +208,7 @@ def configure(env: "Environment"):
             "freetype, libpng, zlib, graphite, harfbuzz.\n"
             "Please specify `builtin_<name>=no` for all of them, or none."
         )
-        sys.exit()
+        sys.exit(255)
 
     if not env["builtin_freetype"]:
         env.ParseConfig("pkg-config freetype2 --cflags --libs")
@@ -277,11 +277,10 @@ def configure(env: "Environment"):
         env.Prepend(CPPPATH=["/usr/include/recastnavigation"])
         env.Append(LIBS=["Recast"])
 
-    if not env["builtin_embree"]:
+    if not env["builtin_embree"] and env["arch"] in ["x86_64", "arm64"]:
         # No pkgconfig file so far, hardcode expected lib name.
         env.Append(LIBS=["embree3"])
 
-    ## Flags
     if env["fontconfig"]:
         if not env["use_sowrap"]:
             if os.system("pkg-config --exists fontconfig") == 0:  # 0 means found
@@ -308,11 +307,12 @@ def configure(env: "Environment"):
         if not env["use_sowrap"]:
             if os.system("pkg-config --exists libpulse") == 0:  # 0 means found
                 env.ParseConfig("pkg-config libpulse --cflags --libs")
-                env.Append(CPPDEFINES=["PULSEAUDIO_ENABLED", "_REENTRANT"])
+                env.Append(CPPDEFINES=["PULSEAUDIO_ENABLED"])
             else:
                 print("Warning: PulseAudio development libraries not found. Disabling the PulseAudio audio driver.")
                 env["pulseaudio"] = False
-        env.Append(CPPDEFINES=["PULSEAUDIO_ENABLED", "_REENTRANT"])
+        else:
+            env.Append(CPPDEFINES=["PULSEAUDIO_ENABLED", "_REENTRANT"])
 
     if env["dbus"]:
         if not env["use_sowrap"]:
diff --git a/platform/linuxbsd/os_linuxbsd.cpp b/platform/linuxbsd/os_linuxbsd.cpp
index 54bb34ef73..88c3d2cc14 100644
--- a/platform/linuxbsd/os_linuxbsd.cpp
+++ b/platform/linuxbsd/os_linuxbsd.cpp
@@ -677,40 +677,45 @@ Vector<String> OS_LinuxBSD::get_system_font_path_for_text(const String &p_font_n
 	}
 
 	Vector<String> ret;
-	FcPattern *pattern = FcPatternCreate();
-	if (pattern) {
-		FcPatternAddString(pattern, FC_FAMILY, reinterpret_cast<const FcChar8 *>(p_font_name.utf8().get_data()));
-		FcPatternAddInteger(pattern, FC_WEIGHT, _weight_to_fc(p_weight));
-		FcPatternAddInteger(pattern, FC_WIDTH, _stretch_to_fc(p_stretch));
-		FcPatternAddInteger(pattern, FC_SLANT, p_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
-
-		FcCharSet *char_set = FcCharSetCreate();
-		for (int i = 0; i < p_text.size(); i++) {
-			FcCharSetAddChar(char_set, p_text[i]);
-		}
-		FcPatternAddCharSet(pattern, FC_CHARSET, char_set);
-
-		FcLangSet *lang_set = FcLangSetCreate();
-		FcLangSetAdd(lang_set, reinterpret_cast<const FcChar8 *>(p_locale.utf8().get_data()));
-		FcPatternAddLangSet(pattern, FC_LANG, lang_set);
-
-		FcConfigSubstitute(0, pattern, FcMatchPattern);
-		FcDefaultSubstitute(pattern);
-
-		FcResult result;
-		FcPattern *match = FcFontMatch(0, pattern, &result);
-		if (match) {
-			char *file_name = nullptr;
-			if (FcPatternGetString(match, FC_FILE, 0, reinterpret_cast<FcChar8 **>(&file_name)) == FcResultMatch) {
-				if (file_name) {
-					ret.push_back(String::utf8(file_name));
+	static const char *allowed_formats[] = { "TrueType", "CFF" };
+	for (size_t i = 0; i < sizeof(allowed_formats) / sizeof(const char *); i++) {
+		FcPattern *pattern = FcPatternCreate();
+		if (pattern) {
+			FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
+			FcPatternAddString(pattern, FC_FONTFORMAT, reinterpret_cast<const FcChar8 *>(allowed_formats[i]));
+			FcPatternAddString(pattern, FC_FAMILY, reinterpret_cast<const FcChar8 *>(p_font_name.utf8().get_data()));
+			FcPatternAddInteger(pattern, FC_WEIGHT, _weight_to_fc(p_weight));
+			FcPatternAddInteger(pattern, FC_WIDTH, _stretch_to_fc(p_stretch));
+			FcPatternAddInteger(pattern, FC_SLANT, p_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
+
+			FcCharSet *char_set = FcCharSetCreate();
+			for (int j = 0; j < p_text.size(); j++) {
+				FcCharSetAddChar(char_set, p_text[j]);
+			}
+			FcPatternAddCharSet(pattern, FC_CHARSET, char_set);
+
+			FcLangSet *lang_set = FcLangSetCreate();
+			FcLangSetAdd(lang_set, reinterpret_cast<const FcChar8 *>(p_locale.utf8().get_data()));
+			FcPatternAddLangSet(pattern, FC_LANG, lang_set);
+
+			FcConfigSubstitute(0, pattern, FcMatchPattern);
+			FcDefaultSubstitute(pattern);
+
+			FcResult result;
+			FcPattern *match = FcFontMatch(0, pattern, &result);
+			if (match) {
+				char *file_name = nullptr;
+				if (FcPatternGetString(match, FC_FILE, 0, reinterpret_cast<FcChar8 **>(&file_name)) == FcResultMatch) {
+					if (file_name) {
+						ret.push_back(String::utf8(file_name));
+					}
 				}
+				FcPatternDestroy(match);
 			}
-			FcPatternDestroy(match);
+			FcPatternDestroy(pattern);
+			FcCharSetDestroy(char_set);
+			FcLangSetDestroy(lang_set);
 		}
-		FcPatternDestroy(pattern);
-		FcCharSetDestroy(char_set);
-		FcLangSetDestroy(lang_set);
 	}
 
 	return ret;
@@ -725,47 +730,51 @@ String OS_LinuxBSD::get_system_font_path(const String &p_font_name, int p_weight
 		ERR_FAIL_V_MSG(String(), "Unable to load fontconfig, system font support is disabled.");
 	}
 
-	String ret;
-	FcPattern *pattern = FcPatternCreate();
-	if (pattern) {
-		bool allow_substitutes = (p_font_name.to_lower() == "sans-serif") || (p_font_name.to_lower() == "serif") || (p_font_name.to_lower() == "monospace") || (p_font_name.to_lower() == "cursive") || (p_font_name.to_lower() == "fantasy");
-
-		FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
-		FcPatternAddString(pattern, FC_FAMILY, reinterpret_cast<const FcChar8 *>(p_font_name.utf8().get_data()));
-		FcPatternAddInteger(pattern, FC_WEIGHT, _weight_to_fc(p_weight));
-		FcPatternAddInteger(pattern, FC_WIDTH, _stretch_to_fc(p_stretch));
-		FcPatternAddInteger(pattern, FC_SLANT, p_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
-
-		FcConfigSubstitute(0, pattern, FcMatchPattern);
-		FcDefaultSubstitute(pattern);
-
-		FcResult result;
-		FcPattern *match = FcFontMatch(0, pattern, &result);
-		if (match) {
-			if (!allow_substitutes) {
-				char *family_name = nullptr;
-				if (FcPatternGetString(match, FC_FAMILY, 0, reinterpret_cast<FcChar8 **>(&family_name)) == FcResultMatch) {
-					if (family_name && String::utf8(family_name).to_lower() != p_font_name.to_lower()) {
+	static const char *allowed_formats[] = { "TrueType", "CFF" };
+	for (size_t i = 0; i < sizeof(allowed_formats) / sizeof(const char *); i++) {
+		FcPattern *pattern = FcPatternCreate();
+		if (pattern) {
+			bool allow_substitutes = (p_font_name.to_lower() == "sans-serif") || (p_font_name.to_lower() == "serif") || (p_font_name.to_lower() == "monospace") || (p_font_name.to_lower() == "cursive") || (p_font_name.to_lower() == "fantasy");
+
+			FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
+			FcPatternAddString(pattern, FC_FONTFORMAT, reinterpret_cast<const FcChar8 *>(allowed_formats[i]));
+			FcPatternAddString(pattern, FC_FAMILY, reinterpret_cast<const FcChar8 *>(p_font_name.utf8().get_data()));
+			FcPatternAddInteger(pattern, FC_WEIGHT, _weight_to_fc(p_weight));
+			FcPatternAddInteger(pattern, FC_WIDTH, _stretch_to_fc(p_stretch));
+			FcPatternAddInteger(pattern, FC_SLANT, p_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN);
+
+			FcConfigSubstitute(0, pattern, FcMatchPattern);
+			FcDefaultSubstitute(pattern);
+
+			FcResult result;
+			FcPattern *match = FcFontMatch(0, pattern, &result);
+			if (match) {
+				if (!allow_substitutes) {
+					char *family_name = nullptr;
+					if (FcPatternGetString(match, FC_FAMILY, 0, reinterpret_cast<FcChar8 **>(&family_name)) == FcResultMatch) {
+						if (family_name && String::utf8(family_name).to_lower() != p_font_name.to_lower()) {
+							FcPatternDestroy(match);
+							FcPatternDestroy(pattern);
+							continue;
+						}
+					}
+				}
+				char *file_name = nullptr;
+				if (FcPatternGetString(match, FC_FILE, 0, reinterpret_cast<FcChar8 **>(&file_name)) == FcResultMatch) {
+					if (file_name) {
+						String ret = String::utf8(file_name);
 						FcPatternDestroy(match);
 						FcPatternDestroy(pattern);
-
-						return String();
+						return ret;
 					}
 				}
+				FcPatternDestroy(match);
 			}
-			char *file_name = nullptr;
-			if (FcPatternGetString(match, FC_FILE, 0, reinterpret_cast<FcChar8 **>(&file_name)) == FcResultMatch) {
-				if (file_name) {
-					ret = String::utf8(file_name);
-				}
-			}
-
-			FcPatternDestroy(match);
+			FcPatternDestroy(pattern);
 		}
-		FcPatternDestroy(pattern);
 	}
 
-	return ret;
+	return String();
 #else
 	ERR_FAIL_V_MSG(String(), "Godot was compiled without fontconfig, system font support is disabled.");
 #endif
diff --git a/platform/linuxbsd/tts_linux.cpp b/platform/linuxbsd/tts_linux.cpp
index 04d7c5444f..ce0199e87f 100644
--- a/platform/linuxbsd/tts_linux.cpp
+++ b/platform/linuxbsd/tts_linux.cpp
@@ -76,76 +76,84 @@ void TTS_Linux::speech_init_thread_func(void *p_userdata) {
 
 void TTS_Linux::speech_event_index_mark(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type, char *p_index_mark) {
 	TTS_Linux *tts = TTS_Linux::get_singleton();
-	if (tts && tts->ids.has(p_msg_id)) {
-		MutexLock thread_safe_method(tts->_thread_safe_);
-		// Get word offset from the index mark injected to the text stream.
-		String mark = String::utf8(p_index_mark);
-		DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, tts->ids[p_msg_id], mark.to_int());
+	if (tts) {
+		callable_mp(tts, &TTS_Linux::_speech_index_mark).call_deferred(p_msg_id, p_client_id, (int)p_type, String::utf8(p_index_mark));
+	}
+}
+
+void TTS_Linux::_speech_index_mark(size_t p_msg_id, size_t p_client_id, int p_type, const String &p_index_mark) {
+	_THREAD_SAFE_METHOD_
+
+	if (ids.has(p_msg_id)) {
+		DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, ids[p_msg_id], p_index_mark.to_int());
 	}
 }
 
 void TTS_Linux::speech_event_callback(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type) {
 	TTS_Linux *tts = TTS_Linux::get_singleton();
 	if (tts) {
-		MutexLock thread_safe_method(tts->_thread_safe_);
-		List<DisplayServer::TTSUtterance> &queue = tts->queue;
-		if (!tts->paused && tts->ids.has(p_msg_id)) {
-			if (p_type == SPD_EVENT_END) {
-				DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, tts->ids[p_msg_id]);
-				tts->ids.erase(p_msg_id);
-				tts->last_msg_id = -1;
-				tts->speaking = false;
-			} else if (p_type == SPD_EVENT_CANCEL) {
-				DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, tts->ids[p_msg_id]);
-				tts->ids.erase(p_msg_id);
-				tts->last_msg_id = -1;
-				tts->speaking = false;
-			}
+		callable_mp(tts, &TTS_Linux::_speech_event).call_deferred(p_msg_id, p_client_id, (int)p_type);
+	}
+}
+
+void TTS_Linux::_speech_event(size_t p_msg_id, size_t p_client_id, int p_type) {
+	_THREAD_SAFE_METHOD_
+
+	if (!paused && ids.has(p_msg_id)) {
+		if ((SPDNotificationType)p_type == SPD_EVENT_END) {
+			DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, ids[p_msg_id]);
+			ids.erase(p_msg_id);
+			last_msg_id = -1;
+			speaking = false;
+		} else if ((SPDNotificationType)p_type == SPD_EVENT_CANCEL) {
+			DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, ids[p_msg_id]);
+			ids.erase(p_msg_id);
+			last_msg_id = -1;
+			speaking = false;
 		}
-		if (!tts->speaking && queue.size() > 0) {
-			DisplayServer::TTSUtterance &message = queue.front()->get();
-
-			// Inject index mark after each word.
-			String text;
-			String language;
-			SPDVoice **voices = spd_list_synthesis_voices(tts->synth);
-			if (voices != nullptr) {
-				SPDVoice **voices_ptr = voices;
-				while (*voices_ptr != nullptr) {
-					if (String::utf8((*voices_ptr)->name) == message.voice) {
-						language = String::utf8((*voices_ptr)->language);
-						break;
-					}
-					voices_ptr++;
-				}
-				free_spd_voices(voices);
-			}
-			PackedInt32Array breaks = TS->string_get_word_breaks(message.text, language);
-			for (int i = 0; i < breaks.size(); i += 2) {
-				const int start = breaks[i];
-				const int end = breaks[i + 1];
-				text += message.text.substr(start, end - start + 1);
-				text += "<mark name=\"" + String::num_int64(end, 10) + "\"/>";
-			}
+	}
+	if (!speaking && queue.size() > 0) {
+		DisplayServer::TTSUtterance &message = queue.front()->get();
 
-			spd_set_synthesis_voice(tts->synth, message.voice.utf8().get_data());
-			spd_set_volume(tts->synth, message.volume * 2 - 100);
-			spd_set_voice_pitch(tts->synth, (message.pitch - 1) * 100);
-			float rate = 0;
-			if (message.rate > 1.f) {
-				rate = log10(MIN(message.rate, 2.5f)) / log10(2.5f) * 100;
-			} else if (message.rate < 1.f) {
-				rate = log10(MAX(message.rate, 0.5f)) / log10(0.5f) * -100;
+		// Inject index mark after each word.
+		String text;
+		String language;
+		SPDVoice **voices = spd_list_synthesis_voices(synth);
+		if (voices != nullptr) {
+			SPDVoice **voices_ptr = voices;
+			while (*voices_ptr != nullptr) {
+				if (String::utf8((*voices_ptr)->name) == message.voice) {
+					language = String::utf8((*voices_ptr)->language);
+					break;
+				}
+				voices_ptr++;
 			}
-			spd_set_voice_rate(tts->synth, rate);
-			spd_set_data_mode(tts->synth, SPD_DATA_SSML);
-			tts->last_msg_id = spd_say(tts->synth, SPD_TEXT, text.utf8().get_data());
-			tts->ids[tts->last_msg_id] = message.id;
-			DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_STARTED, message.id);
-
-			queue.pop_front();
-			tts->speaking = true;
+			free_spd_voices(voices);
+		}
+		PackedInt32Array breaks = TS->string_get_word_breaks(message.text, language);
+		for (int i = 0; i < breaks.size(); i += 2) {
+			const int start = breaks[i];
+			const int end = breaks[i + 1];
+			text += message.text.substr(start, end - start + 1);
+			text += "<mark name=\"" + String::num_int64(end, 10) + "\"/>";
 		}
+		spd_set_synthesis_voice(synth, message.voice.utf8().get_data());
+		spd_set_volume(synth, message.volume * 2 - 100);
+		spd_set_voice_pitch(synth, (message.pitch - 1) * 100);
+		float rate = 0;
+		if (message.rate > 1.f) {
+			rate = log10(MIN(message.rate, 2.5f)) / log10(2.5f) * 100;
+		} else if (message.rate < 1.f) {
+			rate = log10(MAX(message.rate, 0.5f)) / log10(0.5f) * -100;
+		}
+		spd_set_voice_rate(synth, rate);
+		spd_set_data_mode(synth, SPD_DATA_SSML);
+		last_msg_id = spd_say(synth, SPD_TEXT, text.utf8().get_data());
+		ids[last_msg_id] = message.id;
+		DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_STARTED, message.id);
+
+		queue.pop_front();
+		speaking = true;
 	}
 }
 
@@ -204,7 +212,7 @@ void TTS_Linux::speak(const String &p_text, const String &p_voice, int p_volume,
 	if (is_paused()) {
 		resume();
 	} else {
-		speech_event_callback(0, 0, SPD_EVENT_BEGIN);
+		_speech_event(0, 0, (int)SPD_EVENT_BEGIN);
 	}
 }
 
diff --git a/platform/linuxbsd/tts_linux.h b/platform/linuxbsd/tts_linux.h
index 3fe7b659d0..4134f8fa2f 100644
--- a/platform/linuxbsd/tts_linux.h
+++ b/platform/linuxbsd/tts_linux.h
@@ -45,7 +45,7 @@
 #include <libspeechd.h>
 #endif
 
-class TTS_Linux {
+class TTS_Linux : public Object {
 	_THREAD_SAFE_CLASS_
 
 	List<DisplayServer::TTSUtterance> queue;
@@ -63,6 +63,10 @@ class TTS_Linux {
 
 	static TTS_Linux *singleton;
 
+protected:
+	void _speech_event(size_t p_msg_id, size_t p_client_id, int p_type);
+	void _speech_index_mark(size_t p_msg_id, size_t p_client_id, int p_type, const String &p_index_mark);
+
 public:
 	static TTS_Linux *get_singleton();
 
diff --git a/platform/linuxbsd/x11/display_server_x11.cpp b/platform/linuxbsd/x11/display_server_x11.cpp
index dff2f536a8..4c5d9552e6 100644
--- a/platform/linuxbsd/x11/display_server_x11.cpp
+++ b/platform/linuxbsd/x11/display_server_x11.cpp
@@ -128,6 +128,7 @@ bool DisplayServerX11::has_feature(Feature p_feature) const {
 #endif
 		case FEATURE_CLIPBOARD_PRIMARY:
 		case FEATURE_TEXT_TO_SPEECH:
+		case FEATURE_SCREEN_CAPTURE:
 			return true;
 		default: {
 		}
@@ -604,7 +605,7 @@ String DisplayServerX11::_clipboard_get_impl(Atom p_source, Window x11_window, A
 							success = true;
 						}
 					} else {
-						printf("Failed to get selection data chunk.\n");
+						print_verbose("Failed to get selection data chunk.");
 						done = true;
 					}
 
@@ -631,7 +632,7 @@ String DisplayServerX11::_clipboard_get_impl(Atom p_source, Window x11_window, A
 			if (result == Success) {
 				ret.parse_utf8((const char *)data);
 			} else {
-				printf("Failed to get selection data.\n");
+				print_verbose("Failed to get selection data.");
 			}
 
 			if (data) {
@@ -1169,6 +1170,29 @@ int DisplayServerX11::screen_get_dpi(int p_screen) const {
 	return 96;
 }
 
+Color DisplayServerX11::screen_get_pixel(const Point2i &p_position) const {
+	Point2i pos = p_position;
+
+	int number_of_screens = XScreenCount(x11_display);
+	for (int i = 0; i < number_of_screens; i++) {
+		Window root = XRootWindow(x11_display, i);
+		XWindowAttributes root_attrs;
+		XGetWindowAttributes(x11_display, root, &root_attrs);
+		if ((pos.x >= root_attrs.x) && (pos.x <= root_attrs.x + root_attrs.width) && (pos.y >= root_attrs.y) && (pos.y <= root_attrs.y + root_attrs.height)) {
+			XImage *image = XGetImage(x11_display, root, pos.x, pos.y, 1, 1, AllPlanes, XYPixmap);
+			if (image) {
+				XColor c;
+				c.pixel = XGetPixel(image, 0, 0);
+				XFree(image);
+				XQueryColor(x11_display, XDefaultColormap(x11_display, i), &c);
+				return Color(float(c.red) / 65535.0, float(c.green) / 65535.0, float(c.blue) / 65535.0, 1.0);
+			}
+		}
+	}
+
+	return Color();
+}
+
 float DisplayServerX11::screen_get_refresh_rate(int p_screen) const {
 	_THREAD_SAFE_METHOD_
 
@@ -2824,7 +2848,7 @@ Key DisplayServerX11::keyboard_get_keycode_from_physical(Key p_keycode) const {
 	Key modifiers = p_keycode & KeyModifierMask::MODIFIER_MASK;
 	Key keycode_no_mod = p_keycode & KeyModifierMask::CODE_MASK;
 	unsigned int xkeycode = KeyMappingX11::get_xlibcode(keycode_no_mod);
-	KeySym xkeysym = XkbKeycodeToKeysym(x11_display, xkeycode, 0, 0);
+	KeySym xkeysym = XkbKeycodeToKeysym(x11_display, xkeycode, keyboard_get_current_layout(), 0);
 	if (is_ascii_lower_case(xkeysym)) {
 		xkeysym -= ('a' - 'A');
 	}
@@ -2917,7 +2941,7 @@ BitField<MouseButtonMask> DisplayServerX11::_get_mouse_button_state(MouseButton
 }
 
 void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event, LocalVector<XEvent> &p_events, uint32_t &p_event_index, bool p_echo) {
-	WindowData wd = windows[p_window];
+	WindowData &wd = windows[p_window];
 	// X11 functions don't know what const is
 	XKeyEvent *xkeyevent = p_event;
 
@@ -3319,7 +3343,7 @@ Atom DisplayServerX11::_process_selection_request_target(Atom p_target, Window p
 		return p_property;
 	} else {
 		char *target_name = XGetAtomName(x11_display, p_target);
-		printf("Target '%s' not supported.\n", target_name);
+		print_verbose(vformat("Target '%s' not supported.", target_name));
 		if (target_name) {
 			XFree(target_name);
 		}
@@ -4850,7 +4874,7 @@ DisplayServer *DisplayServerX11::create_func(const String &p_rendering_driver, W
 					vformat("Your video card drivers seem not to support the required Vulkan version.\n\n"
 							"If possible, consider updating your video card drivers or using the OpenGL 3 driver.\n\n"
 							"You can enable the OpenGL 3 driver by starting the engine from the\n"
-							"command line with the command:\n'%s --rendering-driver opengl3'\n\n"
+							"command line with the command:\n\n    \"%s\" --rendering-driver opengl3\n\n"
 							"If you recently updated your video card drivers, try rebooting.",
 							executable_name),
 					"Unable to initialize Vulkan video driver");
@@ -4873,7 +4897,9 @@ DisplayServerX11::WindowID DisplayServerX11::_create_window(WindowMode p_mode, V
 
 #ifdef GLES3_ENABLED
 	if (gl_manager) {
-		visualInfo = gl_manager->get_vi(x11_display);
+		Error err;
+		visualInfo = gl_manager->get_vi(x11_display, err);
+		ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, "Can't acquire visual info from display.");
 		vi_selected = true;
 	}
 #endif
@@ -5258,6 +5284,9 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode
 	}
 #ifdef XKB_ENABLED
 	xkb_loaded = (initialize_xkbcommon(dylibloader_verbose) == 0);
+	if (!xkb_context_new || !xkb_compose_table_new_from_locale || !xkb_compose_table_unref || !xkb_context_unref || !xkb_compose_state_feed || !xkb_compose_state_unref || !xkb_compose_state_new || !xkb_compose_state_get_status || !xkb_compose_state_get_utf8 || !xkb_keysym_to_utf32 || !xkb_keysym_to_upper) {
+		xkb_loaded = false;
+	}
 #endif
 	if (initialize_xext(dylibloader_verbose) != 0) {
 		r_error = ERR_UNAVAILABLE;
diff --git a/platform/linuxbsd/x11/display_server_x11.h b/platform/linuxbsd/x11/display_server_x11.h
index dbe8a0ce2b..c98409253e 100644
--- a/platform/linuxbsd/x11/display_server_x11.h
+++ b/platform/linuxbsd/x11/display_server_x11.h
@@ -409,6 +409,7 @@ public:
 	virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
 	virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
 	virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
+	virtual Color screen_get_pixel(const Point2i &p_position) const override;
 
 #if defined(DBUS_ENABLED)
 	virtual void screen_set_keep_on(bool p_enable) override;
diff --git a/platform/linuxbsd/x11/gl_manager_x11.cpp b/platform/linuxbsd/x11/gl_manager_x11.cpp
index 03ba95f475..ee767dfa80 100644
--- a/platform/linuxbsd/x11/gl_manager_x11.cpp
+++ b/platform/linuxbsd/x11/gl_manager_x11.cpp
@@ -83,8 +83,13 @@ int GLManager_X11::_find_or_create_display(Display *p_x11_display) {
 	d.context = memnew(GLManager_X11_Private);
 	d.context->glx_context = nullptr;
 
-	//Error err = _create_context(d);
-	_create_context(d);
+	Error err = _create_context(d);
+
+	if (err != OK) {
+		_displays.remove_at(new_display_id);
+		return -1;
+	}
+
 	return new_display_id;
 }
 
@@ -191,8 +196,14 @@ Error GLManager_X11::_create_context(GLDisplay &gl_display) {
 	return OK;
 }
 
-XVisualInfo GLManager_X11::get_vi(Display *p_display) {
-	return _displays[_find_or_create_display(p_display)].x_vi;
+XVisualInfo GLManager_X11::get_vi(Display *p_display, Error &r_error) {
+	int display_id = _find_or_create_display(p_display);
+	if (display_id < 0) {
+		r_error = FAILED;
+		return XVisualInfo();
+	}
+	r_error = OK;
+	return _displays[display_id].x_vi;
 }
 
 Error GLManager_X11::window_create(DisplayServer::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height) {
@@ -211,6 +222,10 @@ Error GLManager_X11::window_create(DisplayServer::WindowID p_window_id, ::Window
 	win.x11_window = p_window;
 	win.gldisplay_id = _find_or_create_display(p_display);
 
+	if (win.gldisplay_id == -1) {
+		return FAILED;
+	}
+
 	// the display could be invalid .. check NYI
 	GLDisplay &gl_display = _displays[win.gldisplay_id];
 	::Display *x11_display = gl_display.x11_display;
diff --git a/platform/linuxbsd/x11/gl_manager_x11.h b/platform/linuxbsd/x11/gl_manager_x11.h
index 0eb8ab64f4..0203dff679 100644
--- a/platform/linuxbsd/x11/gl_manager_x11.h
+++ b/platform/linuxbsd/x11/gl_manager_x11.h
@@ -114,7 +114,7 @@ private:
 	Error _create_context(GLDisplay &gl_display);
 
 public:
-	XVisualInfo get_vi(Display *p_display);
+	XVisualInfo get_vi(Display *p_display, Error &r_error);
 	Error window_create(DisplayServer::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height);
 	void window_destroy(DisplayServer::WindowID p_window_id);
 	void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);
diff --git a/platform/linuxbsd/x11/key_mapping_x11.cpp b/platform/linuxbsd/x11/key_mapping_x11.cpp
index e5eba6ccad..0f709872cb 100644
--- a/platform/linuxbsd/x11/key_mapping_x11.cpp
+++ b/platform/linuxbsd/x11/key_mapping_x11.cpp
@@ -85,8 +85,8 @@ void KeyMappingX11::initialize() {
 	xkeysym_map[XK_Begin] = Key::CLEAR;
 	xkeysym_map[XK_Insert] = Key::INSERT;
 	xkeysym_map[XK_Delete] = Key::KEY_DELETE;
-	//xkeysym_map[XK_KP_Equal]
-	//xkeysym_map[XK_KP_Separator]
+	xkeysym_map[XK_KP_Equal] = Key::EQUAL;
+	xkeysym_map[XK_KP_Separator] = Key::COMMA;
 	xkeysym_map[XK_KP_Decimal] = Key::KP_PERIOD;
 	xkeysym_map[XK_KP_Delete] = Key::KP_PERIOD;
 	xkeysym_map[XK_KP_Multiply] = Key::KP_MULTIPLY;
@@ -217,10 +217,10 @@ void KeyMappingX11::initialize() {
 	scancode_map[0x1F] = Key::I;
 	scancode_map[0x20] = Key::O;
 	scancode_map[0x21] = Key::P;
-	scancode_map[0x22] = Key::BRACELEFT;
-	scancode_map[0x23] = Key::BRACERIGHT;
+	scancode_map[0x22] = Key::BRACKETLEFT;
+	scancode_map[0x23] = Key::BRACKETRIGHT;
 	scancode_map[0x24] = Key::ENTER;
-	scancode_map[0x25] = Key::CTRL;
+	scancode_map[0x25] = Key::CTRL; // Left
 	scancode_map[0x26] = Key::A;
 	scancode_map[0x27] = Key::S;
 	scancode_map[0x28] = Key::D;
@@ -232,8 +232,8 @@ void KeyMappingX11::initialize() {
 	scancode_map[0x2E] = Key::L;
 	scancode_map[0x2F] = Key::SEMICOLON;
 	scancode_map[0x30] = Key::APOSTROPHE;
-	scancode_map[0x31] = Key::SECTION;
-	scancode_map[0x32] = Key::SHIFT;
+	scancode_map[0x31] = Key::QUOTELEFT;
+	scancode_map[0x32] = Key::SHIFT; // Left
 	scancode_map[0x33] = Key::BACKSLASH;
 	scancode_map[0x34] = Key::Z;
 	scancode_map[0x35] = Key::X;
@@ -245,9 +245,9 @@ void KeyMappingX11::initialize() {
 	scancode_map[0x3B] = Key::COMMA;
 	scancode_map[0x3C] = Key::PERIOD;
 	scancode_map[0x3D] = Key::SLASH;
-	scancode_map[0x3E] = Key::SHIFT;
+	scancode_map[0x3E] = Key::SHIFT; // Right
 	scancode_map[0x3F] = Key::KP_MULTIPLY;
-	scancode_map[0x40] = Key::ALT;
+	scancode_map[0x40] = Key::ALT; // Left
 	scancode_map[0x41] = Key::SPACE;
 	scancode_map[0x42] = Key::CAPSLOCK;
 	scancode_map[0x43] = Key::F1;
@@ -275,14 +275,23 @@ void KeyMappingX11::initialize() {
 	scancode_map[0x59] = Key::KP_3;
 	scancode_map[0x5A] = Key::KP_0;
 	scancode_map[0x5B] = Key::KP_PERIOD;
-	scancode_map[0x5E] = Key::QUOTELEFT;
+	//scancode_map[0x5C]
+	//scancode_map[0x5D] // Zenkaku Hankaku
+	scancode_map[0x5E] = Key::SECTION;
 	scancode_map[0x5F] = Key::F11;
 	scancode_map[0x60] = Key::F12;
+	//scancode_map[0x61] // Romaji
+	//scancode_map[0x62] // Katakana
+	//scancode_map[0x63] // Hiragana
+	//scancode_map[0x64] // Henkan
+	//scancode_map[0x65] // Hiragana Katakana
+	//scancode_map[0x66] // Muhenkan
+	scancode_map[0x67] = Key::COMMA; // KP_Separator
 	scancode_map[0x68] = Key::KP_ENTER;
-	scancode_map[0x69] = Key::CTRL;
+	scancode_map[0x69] = Key::CTRL; // Right
 	scancode_map[0x6A] = Key::KP_DIVIDE;
 	scancode_map[0x6B] = Key::PRINT;
-	scancode_map[0x6C] = Key::ALT;
+	scancode_map[0x6C] = Key::ALT; // Right
 	scancode_map[0x6D] = Key::ENTER;
 	scancode_map[0x6E] = Key::HOME;
 	scancode_map[0x6F] = Key::UP;
@@ -294,13 +303,28 @@ void KeyMappingX11::initialize() {
 	scancode_map[0x75] = Key::PAGEDOWN;
 	scancode_map[0x76] = Key::INSERT;
 	scancode_map[0x77] = Key::KEY_DELETE;
+	//scancode_map[0x78] // Macro
 	scancode_map[0x79] = Key::VOLUMEMUTE;
 	scancode_map[0x7A] = Key::VOLUMEDOWN;
 	scancode_map[0x7B] = Key::VOLUMEUP;
+	//scancode_map[0x7C] // Power
+	scancode_map[0x7D] = Key::EQUAL; // KP_Equal
+	//scancode_map[0x7E] // KP_PlusMinus
 	scancode_map[0x7F] = Key::PAUSE;
-	scancode_map[0x85] = Key::META;
-	scancode_map[0x86] = Key::META;
+	scancode_map[0x80] = Key::LAUNCH0;
+	scancode_map[0x81] = Key::COMMA; // KP_Comma
+	//scancode_map[0x82] // Hangul
+	//scancode_map[0x83] // Hangul_Hanja
+	scancode_map[0x84] = Key::YEN;
+	scancode_map[0x85] = Key::META; // Left
+	scancode_map[0x86] = Key::META; // Right
 	scancode_map[0x87] = Key::MENU;
+
+	scancode_map[0xA6] = Key::BACK; // On Chromebooks
+	scancode_map[0xA7] = Key::FORWARD; // On Chromebooks
+
+	scancode_map[0xB5] = Key::REFRESH; // On Chromebooks
+
 	scancode_map[0xBF] = Key::F13;
 	scancode_map[0xC0] = Key::F14;
 	scancode_map[0xC1] = Key::F15;