15 files changed, 643 insertions, 322 deletions

diff --git a/platform/android/export/export.cpp b/platform/android/export/export.cpp
index 2f6f483edf..474458b00f 100644
--- a/platform/android/export/export.cpp
+++ b/platform/android/export/export.cpp
@@ -1334,7 +1334,7 @@ class EditorExportPlatformAndroid : public EditorExportPlatform {
 					str = get_project_name(package_name);
 
 				} else {
-					String lang = str.substr(str.find_last("-") + 1, str.length()).replace("-", "_");
+					String lang = str.substr(str.rfind("-") + 1, str.length()).replace("-", "_");
 					String prop = "application/config/name_" + lang;
 					if (ProjectSettings::get_singleton()->has_setting(prop)) {
 						str = ProjectSettings::get_singleton()->get(prop);
diff --git a/platform/iphone/export/export.cpp b/platform/iphone/export/export.cpp
index 194e71c9de..4393a4ae9f 100644
--- a/platform/iphone/export/export.cpp
+++ b/platform/iphone/export/export.cpp
@@ -793,17 +793,33 @@ void EditorExportPlatformIOS::_add_assets_to_project(const Ref<EditorExportPrese
 	String pbx_frameworks_refs;
 	String pbx_resources_build;
 	String pbx_resources_refs;
+	String pbx_embeded_frameworks;
 
 	const String file_info_format = String("$build_id = {isa = PBXBuildFile; fileRef = $ref_id; };\n") +
 									"$ref_id = {isa = PBXFileReference; lastKnownFileType = $file_type; name = \"$name\"; path = \"$file_path\"; sourceTree = \"<group>\"; };\n";
+
 	for (int i = 0; i < p_additional_assets.size(); ++i) {
+		String additional_asset_info_format = file_info_format;
+
 		String build_id = (++current_id).str();
 		String ref_id = (++current_id).str();
+		String framework_id = "";
+
 		const IOSExportAsset &asset = p_additional_assets[i];
 
 		String type;
 		if (asset.exported_path.ends_with(".framework")) {
+			additional_asset_info_format += "$framework_id = {isa = PBXBuildFile; fileRef = $ref_id; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; };\n";
+			framework_id = (++current_id).str();
+			pbx_embeded_frameworks += framework_id + ",\n";
+
 			type = "wrapper.framework";
+		} else if (asset.exported_path.ends_with(".xcframework")) {
+			additional_asset_info_format += "$framework_id = {isa = PBXBuildFile; fileRef = $ref_id; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; };\n";
+			framework_id = (++current_id).str();
+			pbx_embeded_frameworks += framework_id + ",\n";
+
+			type = "wrapper.xcframework";
 		} else if (asset.exported_path.ends_with(".dylib")) {
 			type = "compiled.mach-o.dylib";
 		} else if (asset.exported_path.ends_with(".a")) {
@@ -828,7 +844,10 @@ void EditorExportPlatformIOS::_add_assets_to_project(const Ref<EditorExportPrese
 		format_dict["name"] = asset.exported_path.get_file();
 		format_dict["file_path"] = asset.exported_path;
 		format_dict["file_type"] = type;
-		pbx_files += file_info_format.format(format_dict, "$_");
+		if (framework_id.length() > 0) {
+			format_dict["framework_id"] = framework_id;
+		}
+		pbx_files += additional_asset_info_format.format(format_dict, "$_");
 	}
 
 	// Note, frameworks like gamekit are always included in our project.pbxprof file
@@ -862,6 +881,7 @@ void EditorExportPlatformIOS::_add_assets_to_project(const Ref<EditorExportPrese
 	str = str.replace("$additional_pbx_frameworks_refs", pbx_frameworks_refs);
 	str = str.replace("$additional_pbx_resources_build", pbx_resources_build);
 	str = str.replace("$additional_pbx_resources_refs", pbx_resources_refs);
+	str = str.replace("$pbx_embeded_frameworks", pbx_embeded_frameworks);
 
 	CharString cs = str.utf8();
 	p_project_data.resize(cs.size() - 1);
@@ -892,8 +912,39 @@ Error EditorExportPlatformIOS::_export_additional_assets(const String &p_out_dir
 				memdelete(filesystem_da);
 				return ERR_FILE_NOT_FOUND;
 			}
-			String additional_dir = p_is_framework && asset.ends_with(".dylib") ? "/dylibs/" : "/";
-			String destination_dir = p_out_dir + additional_dir + asset.get_base_dir().replace("res://", "");
+
+			String base_dir = asset.get_base_dir().replace("res://", "");
+			String destination_dir;
+			String destination;
+			String asset_path;
+			bool create_framework = false;
+
+			if (p_is_framework && asset.ends_with(".dylib")) {
+				// For iOS we need to turn .dylib into .framework
+				// to be able to send application to AppStore
+				destination_dir = p_out_dir.plus_file("dylibs").plus_file(base_dir);
+
+				String file_name = asset.get_basename().get_file();
+				String framework_name = file_name + ".framework";
+
+				destination_dir = destination_dir.plus_file(framework_name);
+				destination = destination_dir.plus_file(file_name);
+				asset_path = destination_dir;
+				create_framework = true;
+			} else if (p_is_framework && (asset.ends_with(".framework") || asset.ends_with(".xcframework"))) {
+				destination_dir = p_out_dir.plus_file("dylibs").plus_file(base_dir);
+
+				String file_name = asset.get_file();
+				destination = destination_dir.plus_file(file_name);
+				asset_path = destination;
+			} else {
+				destination_dir = p_out_dir.plus_file(base_dir);
+
+				String file_name = asset.get_file();
+				destination = destination_dir.plus_file(file_name);
+				asset_path = destination;
+			}
+
 			if (!filesystem_da->dir_exists(destination_dir)) {
 				Error make_dir_err = filesystem_da->make_dir_recursive(destination_dir);
 				if (make_dir_err) {
@@ -903,15 +954,66 @@ Error EditorExportPlatformIOS::_export_additional_assets(const String &p_out_dir
 				}
 			}
 
-			String destination = destination_dir.plus_file(asset.get_file());
 			Error err = dir_exists ? da->copy_dir(asset, destination) : da->copy(asset, destination);
 			memdelete(da);
 			if (err) {
 				memdelete(filesystem_da);
 				return err;
 			}
-			IOSExportAsset exported_asset = { destination, p_is_framework };
+			IOSExportAsset exported_asset = { asset_path, p_is_framework };
 			r_exported_assets.push_back(exported_asset);
+
+			if (create_framework) {
+				String file_name = asset.get_basename().get_file();
+				String framework_name = file_name + ".framework";
+
+				// Performing `install_name_tool -id @rpath/{name}.framework/{name} ./{name}` on dylib
+				{
+					List<String> install_name_args;
+					install_name_args.push_back("-id");
+					install_name_args.push_back(String("@rpath").plus_file(framework_name).plus_file(file_name));
+					install_name_args.push_back(destination);
+
+					OS::get_singleton()->execute("install_name_tool", install_name_args, true);
+				}
+
+				// Creating Info.plist
+				{
+					String info_plist_format = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+											   "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+											   "<plist version=\"1.0\">\n"
+											   "<dict>\n"
+											   "<key>CFBundleShortVersionString</key>\n"
+											   "<string>1.0</string>\n"
+											   "<key>CFBundleIdentifier</key>\n"
+											   "<string>com.gdnative.framework.$name</string>\n"
+											   "<key>CFBundleName</key>\n"
+											   "<string>$name</string>\n"
+											   "<key>CFBundleExecutable</key>\n"
+											   "<string>$name</string>\n"
+											   "<key>DTPlatformName</key>\n"
+											   "<string>iphoneos</string>\n"
+											   "<key>CFBundleInfoDictionaryVersion</key>\n"
+											   "<string>6.0</string>\n"
+											   "<key>CFBundleVersion</key>\n"
+											   "<string>1</string>\n"
+											   "<key>CFBundlePackageType</key>\n"
+											   "<string>FMWK</string>\n"
+											   "<key>MinimumOSVersion</key>\n"
+											   "<string>10.0</string>\n"
+											   "</dict>\n"
+											   "</plist>";
+
+					String info_plist = info_plist_format.replace("$name", file_name);
+
+					FileAccess *f = FileAccess::open(asset_path.plus_file("Info.plist"), FileAccess::WRITE);
+					if (f) {
+						f->store_string(info_plist);
+						f->close();
+						memdelete(f);
+					}
+				}
+			}
 		}
 	}
 	memdelete(filesystem_da);
diff --git a/platform/javascript/audio_driver_javascript.cpp b/platform/javascript/audio_driver_javascript.cpp
index b8914414e6..9604914b2c 100644
--- a/platform/javascript/audio_driver_javascript.cpp
+++ b/platform/javascript/audio_driver_javascript.cpp
@@ -36,6 +36,15 @@
 
 AudioDriverJavaScript *AudioDriverJavaScript::singleton = nullptr;
 
+bool AudioDriverJavaScript::is_available() {
+	return EM_ASM_INT({
+		if (!(window.AudioContext || window.webkitAudioContext)) {
+			return 0;
+		}
+		return 1;
+	}) != 0;
+}
+
 const char *AudioDriverJavaScript::get_name() const {
 	return "JavaScript";
 }
@@ -207,12 +216,14 @@ void AudioDriverJavaScript::finish_async() {
 
 	/* clang-format off */
 	EM_ASM({
-		var ref = Module.IDHandler.get($0);
+		const id = $0;
+		var ref = Module.IDHandler.get(id);
 		Module.async_finish.push(new Promise(function(accept, reject) {
 			if (!ref) {
-				console.log("Ref not found!", $0, Module.IDHandler);
+				console.log("Ref not found!", id, Module.IDHandler);
 				setTimeout(accept, 0);
 			} else {
+				Module.IDHandler.remove(id);
 				const context = ref['context'];
 				// Disconnect script and input.
 				ref['script'].disconnect();
@@ -226,7 +237,6 @@ void AudioDriverJavaScript::finish_async() {
 				});
 			}
 		}));
-		Module.IDHandler.remove($0);
 	}, id);
 	/* clang-format on */
 }
@@ -293,9 +303,5 @@ Error AudioDriverJavaScript::capture_stop() {
 }
 
 AudioDriverJavaScript::AudioDriverJavaScript() {
-	_driver_id = 0;
-	internal_buffer = nullptr;
-	buffer_length = 0;
-
 	singleton = this;
 }
diff --git a/platform/javascript/audio_driver_javascript.h b/platform/javascript/audio_driver_javascript.h
index 9b26be001e..f029a91db0 100644
--- a/platform/javascript/audio_driver_javascript.h
+++ b/platform/javascript/audio_driver_javascript.h
@@ -34,12 +34,13 @@
 #include "servers/audio_server.h"
 
 class AudioDriverJavaScript : public AudioDriver {
-	float *internal_buffer;
+	float *internal_buffer = nullptr;
 
-	int _driver_id;
-	int buffer_length;
+	int _driver_id = 0;
+	int buffer_length = 0;
 
 public:
+	static bool is_available();
 	void mix_to_js();
 	void process_capture(float sample);
 
diff --git a/platform/javascript/display_server_javascript.cpp b/platform/javascript/display_server_javascript.cpp
index 0312efb377..2f0a2faa83 100644
--- a/platform/javascript/display_server_javascript.cpp
+++ b/platform/javascript/display_server_javascript.cpp
@@ -44,18 +44,15 @@
 #define DOM_BUTTON_XBUTTON1 3
 #define DOM_BUTTON_XBUTTON2 4
 
+char DisplayServerJavaScript::canvas_id[256] = { 0 };
+static bool cursor_inside_canvas = true;
+
 DisplayServerJavaScript *DisplayServerJavaScript::get_singleton() {
 	return static_cast<DisplayServerJavaScript *>(DisplayServer::get_singleton());
 }
 
 // Window (canvas)
-extern "C" EMSCRIPTEN_KEEPALIVE void _set_canvas_id(uint8_t *p_data, int p_data_size) {
-	DisplayServerJavaScript *display = DisplayServerJavaScript::get_singleton();
-	display->canvas_id.parse_utf8((const char *)p_data, p_data_size);
-	display->canvas_id = "#" + display->canvas_id;
-}
-
-static void focus_canvas() {
+void DisplayServerJavaScript::focus_canvas() {
 	/* clang-format off */
 	EM_ASM(
 		Module['canvas'].focus();
@@ -63,7 +60,7 @@ static void focus_canvas() {
 	/* clang-format on */
 }
 
-static bool is_canvas_focused() {
+bool DisplayServerJavaScript::is_canvas_focused() {
 	/* clang-format off */
 	return EM_ASM_INT_V(
 		return document.activeElement == Module['canvas'];
@@ -71,8 +68,21 @@ static bool is_canvas_focused() {
 	/* clang-format on */
 }
 
-static Point2 compute_position_in_canvas(int x, int y) {
-	DisplayServerJavaScript *display = DisplayServerJavaScript::get_singleton();
+bool DisplayServerJavaScript::check_size_force_redraw() {
+	int canvas_width;
+	int canvas_height;
+	emscripten_get_canvas_element_size(DisplayServerJavaScript::canvas_id, &canvas_width, &canvas_height);
+	if (last_width != canvas_width || last_height != canvas_height) {
+		last_width = canvas_width;
+		last_height = canvas_height;
+		// Update the framebuffer size and for redraw.
+		emscripten_set_canvas_element_size(DisplayServerJavaScript::canvas_id, canvas_width, canvas_height);
+		return true;
+	}
+	return false;
+}
+
+Point2 DisplayServerJavaScript::compute_position_in_canvas(int p_x, int p_y) {
 	int canvas_x = EM_ASM_INT({
 		return Module['canvas'].getBoundingClientRect().x;
 	});
@@ -81,23 +91,22 @@ static Point2 compute_position_in_canvas(int x, int y) {
 	});
 	int canvas_width;
 	int canvas_height;
-	emscripten_get_canvas_element_size(display->canvas_id.utf8().get_data(), &canvas_width, &canvas_height);
+	emscripten_get_canvas_element_size(canvas_id, &canvas_width, &canvas_height);
 
 	double element_width;
 	double element_height;
-	emscripten_get_element_css_size(display->canvas_id.utf8().get_data(), &element_width, &element_height);
+	emscripten_get_element_css_size(canvas_id, &element_width, &element_height);
 
-	return Point2((int)(canvas_width / element_width * (x - canvas_x)),
-			(int)(canvas_height / element_height * (y - canvas_y)));
+	return Point2((int)(canvas_width / element_width * (p_x - canvas_x)),
+			(int)(canvas_height / element_height * (p_y - canvas_y)));
 }
 
-static bool cursor_inside_canvas = true;
-
 EM_BOOL DisplayServerJavaScript::fullscreen_change_callback(int p_event_type, const EmscriptenFullscreenChangeEvent *p_event, void *p_user_data) {
 	DisplayServerJavaScript *display = get_singleton();
 	// Empty ID is canvas.
 	String target_id = String::utf8(p_event->id);
-	if (target_id.empty() || "#" + target_id == display->canvas_id) {
+	String canvas_str_id = String::utf8(canvas_id);
+	if (target_id.empty() || target_id == canvas_str_id) {
 		// This event property is the only reliable data on
 		// browser fullscreen state.
 		if (p_event->isFullscreen) {
@@ -131,14 +140,14 @@ extern "C" EMSCRIPTEN_KEEPALIVE void _drop_files_callback(char *p_filev[], int p
 // Keys
 
 template <typename T>
-static void dom2godot_mod(T *emscripten_event_ptr, Ref<InputEventWithModifiers> godot_event) {
+void DisplayServerJavaScript::dom2godot_mod(T *emscripten_event_ptr, Ref<InputEventWithModifiers> godot_event) {
 	godot_event->set_shift(emscripten_event_ptr->shiftKey);
 	godot_event->set_alt(emscripten_event_ptr->altKey);
 	godot_event->set_control(emscripten_event_ptr->ctrlKey);
 	godot_event->set_metakey(emscripten_event_ptr->metaKey);
 }
 
-static Ref<InputEventKey> setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) {
+Ref<InputEventKey> DisplayServerJavaScript::setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) {
 	Ref<InputEventKey> ev;
 	ev.instance();
 	ev->set_echo(emscripten_event->repeat);
@@ -289,7 +298,7 @@ EM_BOOL DisplayServerJavaScript::mousemove_callback(int p_event_type, const Emsc
 }
 
 // Cursor
-static const char *godot2dom_cursor(DisplayServer::CursorShape p_shape) {
+const char *DisplayServerJavaScript::godot2dom_cursor(DisplayServer::CursorShape p_shape) {
 	switch (p_shape) {
 		case DisplayServer::CURSOR_ARROW:
 			return "auto";
@@ -330,7 +339,7 @@ static const char *godot2dom_cursor(DisplayServer::CursorShape p_shape) {
 	}
 }
 
-static void set_css_cursor(const char *p_cursor) {
+void DisplayServerJavaScript::set_css_cursor(const char *p_cursor) {
 	/* clang-format off */
 	EM_ASM_({
 		Module['canvas'].style.cursor = UTF8ToString($0);
@@ -338,7 +347,7 @@ static void set_css_cursor(const char *p_cursor) {
 	/* clang-format on */
 }
 
-static bool is_css_cursor_hidden() {
+bool DisplayServerJavaScript::is_css_cursor_hidden() const {
 	/* clang-format off */
 	return EM_ASM_INT({
 		return Module['canvas'].style.cursor === 'none';
@@ -820,23 +829,6 @@ DisplayServer *DisplayServerJavaScript::create_func(const String &p_rendering_dr
 }
 
 DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
-	/* clang-format off */
-	EM_ASM({
-		const canvas = Module['canvas'];
-		var enc = new TextEncoder("utf-8");
-		var buffer = new Uint8Array(enc.encode(canvas.id));
-		var len = buffer.byteLength;
-		var out = _malloc(len);
-		HEAPU8.set(buffer, out);
-		ccall("_set_canvas_id",
-			"void",
-			["number", "number"],
-			[out, len]
-		);
-		_free(out);
-	});
-	/* clang-format on */
-
 	RasterizerDummy::make_current(); // TODO GLES2 in Godot 4.0... or webgpu?
 #if 0
 	EmscriptenWebGLContextAttributes attributes;
@@ -859,7 +851,7 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 		gl_initialization_error = true;
 	}
 
-	EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(canvas_id.utf8().get_data(), &attributes);
+	EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = emscripten_webgl_create_context(canvas_id, &attributes);
 	if (emscripten_webgl_make_context_current(ctx) != EMSCRIPTEN_RESULT_SUCCESS) {
 		gl_initialization_error = true;
 	}
@@ -881,7 +873,6 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 	}
 
 	EMSCRIPTEN_RESULT result;
-	CharString id = canvas_id.utf8();
 #define EM_CHECK(ev)                         \
 	if (result != EMSCRIPTEN_RESULT_SUCCESS) \
 		ERR_PRINT("Error while setting " #ev " callback: Code " + itos(result));
@@ -895,16 +886,16 @@ DisplayServerJavaScript::DisplayServerJavaScript(const String &p_rendering_drive
 	// JavaScript APIs. For APIs that are not (sufficiently) exposed, EM_ASM
 	// is used below.
 	SET_EM_CALLBACK(EMSCRIPTEN_EVENT_TARGET_WINDOW, mousemove, mousemove_callback)
-	SET_EM_CALLBACK(id.get_data(), mousedown, mouse_button_callback)
+	SET_EM_CALLBACK(canvas_id, mousedown, mouse_button_callback)
 	SET_EM_CALLBACK(EMSCRIPTEN_EVENT_TARGET_WINDOW, mouseup, mouse_button_callback)
-	SET_EM_CALLBACK(id.get_data(), wheel, wheel_callback)
-	SET_EM_CALLBACK(id.get_data(), touchstart, touch_press_callback)
-	SET_EM_CALLBACK(id.get_data(), touchmove, touchmove_callback)
-	SET_EM_CALLBACK(id.get_data(), touchend, touch_press_callback)
-	SET_EM_CALLBACK(id.get_data(), touchcancel, touch_press_callback)
-	SET_EM_CALLBACK(id.get_data(), keydown, keydown_callback)
-	SET_EM_CALLBACK(id.get_data(), keypress, keypress_callback)
-	SET_EM_CALLBACK(id.get_data(), keyup, keyup_callback)
+	SET_EM_CALLBACK(canvas_id, wheel, wheel_callback)
+	SET_EM_CALLBACK(canvas_id, touchstart, touch_press_callback)
+	SET_EM_CALLBACK(canvas_id, touchmove, touchmove_callback)
+	SET_EM_CALLBACK(canvas_id, touchend, touch_press_callback)
+	SET_EM_CALLBACK(canvas_id, touchcancel, touch_press_callback)
+	SET_EM_CALLBACK(canvas_id, keydown, keydown_callback)
+	SET_EM_CALLBACK(canvas_id, keypress, keypress_callback)
+	SET_EM_CALLBACK(canvas_id, keyup, keyup_callback)
 	SET_EM_CALLBACK(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, fullscreenchange, fullscreen_change_callback)
 	SET_EM_CALLBACK_NOTARGET(gamepadconnected, gamepad_change_callback)
 	SET_EM_CALLBACK_NOTARGET(gamepaddisconnected, gamepad_change_callback)
@@ -1012,7 +1003,7 @@ Size2i DisplayServerJavaScript::screen_get_size(int p_screen) const {
 
 Rect2i DisplayServerJavaScript::screen_get_usable_rect(int p_screen) const {
 	int canvas[2];
-	emscripten_get_canvas_element_size(canvas_id.utf8().get_data(), canvas, canvas + 1);
+	emscripten_get_canvas_element_size(canvas_id, canvas, canvas + 1);
 	return Rect2i(0, 0, canvas[0], canvas[1]);
 }
 
@@ -1103,12 +1094,14 @@ Size2i DisplayServerJavaScript::window_get_min_size(WindowID p_window) const {
 }
 
 void DisplayServerJavaScript::window_set_size(const Size2i p_size, WindowID p_window) {
-	emscripten_set_canvas_element_size(canvas_id.utf8().get_data(), p_size.x, p_size.y);
+	last_width = p_size.x;
+	last_height = p_size.y;
+	emscripten_set_canvas_element_size(canvas_id, p_size.x, p_size.y);
 }
 
 Size2i DisplayServerJavaScript::window_get_size(WindowID p_window) const {
 	int canvas[2];
-	emscripten_get_canvas_element_size(canvas_id.utf8().get_data(), canvas, canvas + 1);
+	emscripten_get_canvas_element_size(canvas_id, canvas, canvas + 1);
 	return Size2(canvas[0], canvas[1]);
 }
 
@@ -1134,7 +1127,7 @@ void DisplayServerJavaScript::window_set_mode(WindowMode p_mode, WindowID p_wind
 			strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
 			strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
 			strategy.canvasResizedCallback = nullptr;
-			EMSCRIPTEN_RESULT result = emscripten_request_fullscreen_strategy(canvas_id.utf8().get_data(), false, &strategy);
+			EMSCRIPTEN_RESULT result = emscripten_request_fullscreen_strategy(canvas_id, false, &strategy);
 			ERR_FAIL_COND_MSG(result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED, "Enabling fullscreen is only possible from an input callback for the HTML5 platform.");
 			ERR_FAIL_COND_MSG(result != EMSCRIPTEN_RESULT_SUCCESS, "Enabling fullscreen is only possible from an input callback for the HTML5 platform.");
 		} break;
diff --git a/platform/javascript/display_server_javascript.h b/platform/javascript/display_server_javascript.h
index 9860ecdf98..b149665d67 100644
--- a/platform/javascript/display_server_javascript.h
+++ b/platform/javascript/display_server_javascript.h
@@ -53,6 +53,21 @@ class DisplayServerJavaScript : public DisplayServer {
 	double last_click_ms = 0;
 	int last_click_button_index = -1;
 
+	int last_width = 0;
+	int last_height = 0;
+
+	// utilities
+	static Point2 compute_position_in_canvas(int p_x, int p_y);
+	static void focus_canvas();
+	static bool is_canvas_focused();
+	template <typename T>
+	static void dom2godot_mod(T *emscripten_event_ptr, Ref<InputEventWithModifiers> godot_event);
+	static Ref<InputEventKey> setup_key_event(const EmscriptenKeyboardEvent *emscripten_event);
+	static const char *godot2dom_cursor(DisplayServer::CursorShape p_shape);
+	static void set_css_cursor(const char *p_cursor);
+	bool is_css_cursor_hidden() const;
+
+	// events
 	static EM_BOOL fullscreen_change_callback(int p_event_type, const EmscriptenFullscreenChangeEvent *p_event, void *p_user_data);
 
 	static EM_BOOL keydown_callback(int p_event_type, const EmscriptenKeyboardEvent *p_event, void *p_user_data);
@@ -81,17 +96,20 @@ protected:
 public:
 	// Override return type to make writing static callbacks less tedious.
 	static DisplayServerJavaScript *get_singleton();
+	static char canvas_id[256];
 
 	WindowMode window_mode = WINDOW_MODE_WINDOWED;
 
 	String clipboard;
-	String canvas_id;
 
 	Callable window_event_callback;
 	Callable input_event_callback;
 	Callable input_text_callback;
 	Callable drop_files_callback;
 
+	// utilities
+	bool check_size_force_redraw();
+
 	// from DisplayServer
 	virtual void alert(const String &p_alert, const String &p_title = "ALERT!");
 	virtual bool has_feature(Feature p_feature) const;
diff --git a/platform/javascript/javascript_main.cpp b/platform/javascript/javascript_main.cpp
index fd61c46e63..99672745e7 100644
--- a/platform/javascript/javascript_main.cpp
+++ b/platform/javascript/javascript_main.cpp
@@ -30,11 +30,13 @@
 
 #include "core/io/resource_loader.h"
 #include "main/main.h"
-#include "os_javascript.h"
+#include "platform/javascript/display_server_javascript.h"
+#include "platform/javascript/os_javascript.h"
 
 #include <emscripten/emscripten.h>
 
 static OS_JavaScript *os = nullptr;
+static uint64_t target_ticks = 0;
 
 void exit_callback() {
 	emscripten_cancel_main_loop(); // After this, we can exit!
@@ -46,12 +48,32 @@ void exit_callback() {
 }
 
 void main_loop_callback() {
+	uint64_t current_ticks = os->get_ticks_usec();
+
+	bool force_draw = DisplayServerJavaScript::get_singleton()->check_size_force_redraw();
+	if (force_draw) {
+		Main::force_redraw();
+	} else if (current_ticks < target_ticks) {
+		return; // Skip frame.
+	}
+
+	int target_fps = Engine::get_singleton()->get_target_fps();
+	if (target_fps > 0) {
+		target_ticks += (uint64_t)(1000000 / target_fps);
+	}
 	if (os->main_loop_iterate()) {
 		emscripten_cancel_main_loop(); // Cancel current loop and wait for finalize_async.
+		/* clang-format off */
 		EM_ASM({
 			// This will contain the list of operations that need to complete before cleanup.
-			Module.async_finish = [];
+			Module.async_finish = [
+				// Always contains at least one async promise, to avoid firing immediately if nothing is added.
+				new Promise(function(accept, reject) {
+					setTimeout(accept, 0);
+				})
+			];
 		});
+		/* clang-format on */
 		os->get_main_loop()->finish();
 		os->finalize_async(); // Will add all the async finish functions.
 		EM_ASM({
@@ -79,13 +101,35 @@ extern "C" EMSCRIPTEN_KEEPALIVE void main_after_fs_sync(char *p_idbfs_err) {
 	ResourceLoader::set_abort_on_missing_resources(false);
 	Main::start();
 	os->get_main_loop()->init();
-	emscripten_resume_main_loop();
 	// Immediately run the first iteration.
 	// We are inside an animation frame, we want to immediately draw on the newly setup canvas.
 	main_loop_callback();
+	emscripten_resume_main_loop();
 }
 
 int main(int argc, char *argv[]) {
+	// Create and mount userfs immediately.
+	EM_ASM({
+		FS.mkdir('/userfs');
+		FS.mount(IDBFS, {}, '/userfs');
+	});
+
+	// Configure locale.
+	char locale_ptr[16];
+	/* clang-format off */
+	EM_ASM({
+		stringToUTF8(Module['locale'], $0, 16);
+	}, locale_ptr);
+	/* clang-format on */
+	setenv("LANG", locale_ptr, true);
+
+	// Ensure the canvas ID.
+	/* clang-format off */
+	EM_ASM({
+		stringToUTF8("#" + Module['canvas'].id, $0, 255);
+	}, DisplayServerJavaScript::canvas_id);
+	/* clang-format on */
+
 	os = new OS_JavaScript();
 	Main::setup(argv[0], argc - 1, &argv[1], false);
 	emscripten_set_main_loop(main_loop_callback, -1, false);
@@ -95,8 +139,6 @@ int main(int argc, char *argv[]) {
 	// run the 'main_after_fs_sync' function.
 	/* clang-format off */
 	EM_ASM({
-		FS.mkdir('/userfs');
-		FS.mount(IDBFS, {}, '/userfs');
 		FS.syncfs(true, function(err) {
 			requestAnimationFrame(function() {
 				ccall('main_after_fs_sync', null, ['string'], [err ? err.message : ""]);
diff --git a/platform/javascript/os_javascript.cpp b/platform/javascript/os_javascript.cpp
index ad4b5a5afa..1ff4304bcf 100644
--- a/platform/javascript/os_javascript.cpp
+++ b/platform/javascript/os_javascript.cpp
@@ -74,18 +74,12 @@ void OS_JavaScript::initialize() {
 	EngineDebugger::register_uri_handler("ws://", RemoteDebuggerPeerWebSocket::create);
 	EngineDebugger::register_uri_handler("wss://", RemoteDebuggerPeerWebSocket::create);
 #endif
-
-	char locale_ptr[16];
-	/* clang-format off */
-	EM_ASM({
-		stringToUTF8(Module['locale'], $0, 16);
-	}, locale_ptr);
-	/* clang-format on */
-	setenv("LANG", locale_ptr, true);
 }
 
 void OS_JavaScript::resume_audio() {
-	audio_driver_javascript.resume();
+	if (audio_driver_javascript) {
+		audio_driver_javascript->resume();
+	}
 }
 
 void OS_JavaScript::set_main_loop(MainLoop *p_main_loop) {
@@ -133,11 +127,17 @@ void OS_JavaScript::delete_main_loop() {
 
 void OS_JavaScript::finalize_async() {
 	finalizing = true;
-	audio_driver_javascript.finish_async();
+	if (audio_driver_javascript) {
+		audio_driver_javascript->finish_async();
+	}
 }
 
 void OS_JavaScript::finalize() {
 	delete_main_loop();
+	if (audio_driver_javascript) {
+		memdelete(audio_driver_javascript);
+		audio_driver_javascript = nullptr;
+	}
 }
 
 // Miscellaneous
@@ -246,7 +246,10 @@ void OS_JavaScript::initialize_joypads() {
 }
 
 OS_JavaScript::OS_JavaScript() {
-	AudioDriverManager::add_driver(&audio_driver_javascript);
+	if (AudioDriverJavaScript::is_available()) {
+		audio_driver_javascript = memnew(AudioDriverJavaScript);
+		AudioDriverManager::add_driver(audio_driver_javascript);
+	}
 
 	Vector<Logger *> loggers;
 	loggers.push_back(memnew(StdLogger));
diff --git a/platform/javascript/os_javascript.h b/platform/javascript/os_javascript.h
index f0f18b44f8..22234f9355 100644
--- a/platform/javascript/os_javascript.h
+++ b/platform/javascript/os_javascript.h
@@ -40,7 +40,7 @@
 
 class OS_JavaScript : public OS_Unix {
 	MainLoop *main_loop = nullptr;
-	AudioDriverJavaScript audio_driver_javascript;
+	AudioDriverJavaScript *audio_driver_javascript = nullptr;
 
 	bool finalizing = false;
 	bool idb_available = false;
@@ -83,6 +83,9 @@ public:
 	String get_executable_path() const;
 	virtual Error shell_open(String p_uri);
 	virtual String get_name() const;
+	// Override default OS implementation which would block the main thread with delay_usec.
+	// Implemented in javascript_main.cpp loop callback instead.
+	virtual void add_frame_delay(bool p_can_draw) {}
 	virtual bool can_draw() const;
 
 	virtual String get_cache_path() const;
diff --git a/platform/linuxbsd/display_server_x11.cpp b/platform/linuxbsd/display_server_x11.cpp
index cb4b0d745b..c9b951f4d9 100644
--- a/platform/linuxbsd/display_server_x11.cpp
+++ b/platform/linuxbsd/display_server_x11.cpp
@@ -410,7 +410,18 @@ void DisplayServerX11::mouse_warp_to_position(const Point2i &p_to) {
 }
 
 Point2i DisplayServerX11::mouse_get_position() const {
-	return last_mouse_pos;
+	int root_x, root_y;
+	int win_x, win_y;
+	unsigned int mask_return;
+	Window window_returned;
+
+	Bool result = XQueryPointer(x11_display, RootWindow(x11_display, DefaultScreen(x11_display)), &window_returned,
+			&window_returned, &root_x, &root_y, &win_x, &win_y,
+			&mask_return);
+	if (result == True) {
+		return Point2i(root_x, root_y);
+	}
+	return Point2i();
 }
 
 Point2i DisplayServerX11::mouse_get_absolute_position() const {
@@ -718,6 +729,14 @@ ObjectID DisplayServerX11::window_get_attached_instance_id(WindowID p_window) co
 }
 
 DisplayServerX11::WindowID DisplayServerX11::get_window_at_screen_position(const Point2i &p_position) const {
+#warning This is an incorrect implementation, if windows overlap, it should return the topmost visible one or none if occluded by a foreign window
+
+	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
+		Rect2i win_rect = Rect2i(window_get_position(E->key()), window_get_size(E->key()));
+		if (win_rect.has_point(p_position)) {
+			return E->key();
+		}
+	}
 	return INVALID_WINDOW_ID;
 }
 
@@ -2345,15 +2364,22 @@ void DisplayServerX11::process_events() {
 		for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
 			if (E->get().focused) {
 				focus_found = true;
+				break;
 			}
 		}
 
 		if (!focus_found) {
-			if (OS::get_singleton()->get_main_loop()) {
-				OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT);
-			}
+			uint64_t delta = OS::get_singleton()->get_ticks_msec() - time_since_no_focus;
 
-			app_focused = false;
+			if (delta > 250) {
+				//X11 can go between windows and have no focus for a while, when creating them or something else. Use this as safety to avoid unnecesary focus in/outs.
+				if (OS::get_singleton()->get_main_loop()) {
+					OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT);
+				}
+				app_focused = false;
+			}
+		} else {
+			time_since_no_focus = OS::get_singleton()->get_ticks_msec();
 		}
 	}
 
diff --git a/platform/linuxbsd/display_server_x11.h b/platform/linuxbsd/display_server_x11.h
index 3d0b2c7e8a..b5d2ea1c63 100644
--- a/platform/linuxbsd/display_server_x11.h
+++ b/platform/linuxbsd/display_server_x11.h
@@ -167,6 +167,7 @@ class DisplayServerX11 : public DisplayServer {
 	int last_click_button_index;
 	uint32_t last_button_state;
 	bool app_focused = false;
+	uint64_t time_since_no_focus = 0;
 
 	struct {
 		int opcode;
diff --git a/platform/osx/display_server_osx.h b/platform/osx/display_server_osx.h
index ac419a821c..3e6b59f58c 100644
--- a/platform/osx/display_server_osx.h
+++ b/platform/osx/display_server_osx.h
@@ -86,6 +86,14 @@ public:
 		uint32_t unicode;
 	};
 
+	struct WarpEvent {
+		NSTimeInterval timestamp;
+		NSPoint delta;
+	};
+
+	List<WarpEvent> warp_events;
+	NSTimeInterval last_warp = 0;
+
 	Vector<KeyEvent> key_event_buffer;
 	int key_event_pos;
 
@@ -124,6 +132,7 @@ public:
 		bool on_top = false;
 		bool borderless = false;
 		bool resize_disabled = false;
+		bool no_focus = false;
 	};
 
 	Point2i im_selection;
@@ -142,7 +151,6 @@ public:
 
 	void _set_window_per_pixel_transparency_enabled(bool p_enabled, WindowID p_window);
 
-	float _display_scale(id screen) const;
 	Point2i _get_screens_origin() const;
 	Point2i _get_native_screen_position(int p_screen) const;
 
@@ -216,6 +224,7 @@ public:
 	virtual Size2i screen_get_size(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
 	virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
 	virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
+	virtual float screen_get_max_scale() const;
 	virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
 
 	virtual Vector<int> get_window_list() const;
diff --git a/platform/osx/display_server_osx.mm b/platform/osx/display_server_osx.mm
index 220ba9ac7e..b7b750a975 100644
--- a/platform/osx/display_server_osx.mm
+++ b/platform/osx/display_server_osx.mm
@@ -47,6 +47,8 @@
 #if defined(OPENGL_ENABLED)
 #include "drivers/gles2/rasterizer_gles2.h"
 //TODO - reimplement OpenGLES
+
+#import <AppKit/NSOpenGLView.h>
 #endif
 
 #if defined(VULKAN_ENABLED)
@@ -68,11 +70,11 @@ static void _get_key_modifier_state(unsigned int p_osx_state, Ref<InputEventWith
 	r_state->set_metakey((p_osx_state & NSEventModifierFlagCommand));
 }
 
-static Vector2i _get_mouse_pos(DisplayServerOSX::WindowData &p_wd, NSPoint p_locationInWindow, CGFloat p_backingScaleFactor) {
+static Vector2i _get_mouse_pos(DisplayServerOSX::WindowData &p_wd, NSPoint p_locationInWindow) {
 	const NSRect contentRect = [p_wd.window_view frame];
-	const NSPoint p = p_locationInWindow;
-	p_wd.mouse_pos.x = p.x * p_backingScaleFactor;
-	p_wd.mouse_pos.y = (contentRect.size.height - p.y) * p_backingScaleFactor;
+	const float scale = DS_OSX->screen_get_max_scale();
+	p_wd.mouse_pos.x = p_locationInWindow.x * scale;
+	p_wd.mouse_pos.y = (contentRect.size.height - p_locationInWindow.y) * scale;
 	DS_OSX->last_mouse_pos = p_wd.mouse_pos;
 	Input::get_singleton()->set_mouse_position(p_wd.mouse_pos);
 	return p_wd.mouse_pos;
@@ -131,10 +133,11 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 	// From http://cocoadev.com/index.pl?GameKeyboardHandlingAlmost
 	// This works around an AppKit bug, where key up events while holding
 	// down the command key don't get sent to the key window.
-	if ([event type] == NSEventTypeKeyUp && ([event modifierFlags] & NSEventModifierFlagCommand))
+	if ([event type] == NSEventTypeKeyUp && ([event modifierFlags] & NSEventModifierFlagCommand)) {
 		[[self keyWindow] sendEvent:event];
-	else
+	} else {
 		[super sendEvent:event];
+	}
 }
 
 @end
@@ -210,8 +213,9 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 }
 
 - (void)globalMenuCallback:(id)sender {
-	if (![sender representedObject])
+	if (![sender representedObject]) {
 		return;
+	}
 
 	GlobalMenuItem *value = [sender representedObject];
 
@@ -264,8 +268,9 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 }
 
 - (void)showAbout:(id)sender {
-	if (OS_OSX::get_singleton()->get_main_loop())
+	if (OS_OSX::get_singleton()->get_main_loop()) {
 		OS_OSX::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_WM_ABOUT);
+	}
 }
 
 @end
@@ -318,6 +323,11 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 		[pwd.window_object makeKeyAndOrderFront:nil]; // Move focus back to main window if there is no parent or other windows left.
 	}
 
+#if defined(OPENGL_ENABLED)
+	if (DS_OSX->rendering_driver == "opengl_es") {
+		//TODO - reimplement OpenGLES
+	}
+#endif
 #ifdef VULKAN_ENABLED
 	if (DS_OSX->rendering_driver == "vulkan") {
 		DS_OSX->context_vulkan->window_destroy(window_id);
@@ -345,22 +355,25 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 
 	wd.fullscreen = false;
 
+	const float scale = DS_OSX->screen_get_max_scale();
 	if (wd.min_size != Size2i()) {
-		Size2i size = wd.min_size / DS_OSX->_display_scale([wd.window_object screen]);
+		Size2i size = wd.min_size / scale;
 		[wd.window_object setContentMinSize:NSMakeSize(size.x, size.y)];
 	}
 	if (wd.max_size != Size2i()) {
-		Size2i size = wd.max_size / DS_OSX->_display_scale([wd.window_object screen]);
+		Size2i size = wd.max_size / scale;
 		[wd.window_object setContentMaxSize:NSMakeSize(size.x, size.y)];
 	}
 
-	if (wd.resize_disabled)
+	if (wd.resize_disabled) {
 		[wd.window_object setStyleMask:[wd.window_object styleMask] & ~NSWindowStyleMaskResizable];
+	}
 }
 
 - (void)windowDidChangeBackingProperties:(NSNotification *)notification {
-	if (!DisplayServerOSX::get_singleton())
+	if (!DisplayServerOSX::get_singleton()) {
 		return;
+	}
 
 	ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
@@ -368,34 +381,21 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 	CGFloat newBackingScaleFactor = [wd.window_object backingScaleFactor];
 	CGFloat oldBackingScaleFactor = [[[notification userInfo] objectForKey:@"NSBackingPropertyOldScaleFactorKey"] doubleValue];
 
-#if defined(OPENGL_ENABLED)
-	if (DS_OSX->rendering_driver == "opengl_es") {
-		//TODO - reimplement OpenGLES
-		if (OS_OSX::get_singleton()->is_hidpi_allowed()) {
-			[wd.window_view setWantsBestResolutionOpenGLSurface:YES];
-		} else {
-			[wd.window_view setWantsBestResolutionOpenGLSurface:NO];
-		}
-	}
-#endif
-
 	if (newBackingScaleFactor != oldBackingScaleFactor) {
 		//Set new display scale and window size
-		float newDisplayScale = OS_OSX::get_singleton()->is_hidpi_allowed() ? newBackingScaleFactor : 1.0;
-
+		const float scale = DS_OSX->screen_get_max_scale();
 		const NSRect contentRect = [wd.window_view frame];
 
-		wd.size.width = contentRect.size.width * newDisplayScale;
-		wd.size.height = contentRect.size.height * newDisplayScale;
+		wd.size.width = contentRect.size.width * scale;
+		wd.size.height = contentRect.size.height * scale;
 
 		DS_OSX->_send_window_event(wd, DisplayServerOSX::WINDOW_EVENT_DPI_CHANGE);
 
-#if defined(VULKAN_ENABLED)
-		if (DS_OSX->rendering_driver == "vulkan") {
-			CALayer *layer = [wd.window_view layer];
-			layer.contentsScale = DS_OSX->_display_scale([wd.window_object screen]);
+		CALayer *layer = [wd.window_view layer];
+		if (layer) {
+			layer.contentsScale = scale;
 		}
-#endif
+
 		//Force window resize event
 		[self windowDidResize:notification];
 	}
@@ -407,22 +407,24 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 	}
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
+	const NSRect contentRect = [wd.window_view frame];
+
+	const float scale = DS_OSX->screen_get_max_scale();
+	wd.size.width = contentRect.size.width * scale;
+	wd.size.height = contentRect.size.height * scale;
+
+	CALayer *layer = [wd.window_view layer];
+	if (layer) {
+		layer.contentsScale = scale;
+	}
+
 #if defined(OPENGL_ENABLED)
 	if (DS_OSX->rendering_driver == "opengl_es") {
 		//TODO - reimplement OpenGLES
-		wd.context_gles2->update();
 	}
 #endif
-	const NSRect contentRect = [wd.window_view frame];
-
-	float displayScale = DS_OSX->_display_scale([wd.window_object screen]);
-	wd.size.width = contentRect.size.width * displayScale;
-	wd.size.height = contentRect.size.height * displayScale;
-
 #if defined(VULKAN_ENABLED)
 	if (DS_OSX->rendering_driver == "vulkan") {
-		CALayer *layer = [wd.window_view layer];
-		layer.contentsScale = displayScale;
 		DS_OSX->context_vulkan->window_resize(window_id, wd.size.width, wd.size.height);
 	}
 #endif
@@ -467,8 +469,7 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 	}
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
-	const CGFloat backingScaleFactor = (OS::get_singleton()->is_hidpi_allowed()) ? [wd.window_view backingScaleFactor] : 1.0;
-	_get_mouse_pos(wd, [wd.window_object mouseLocationOutsideOfEventStream], backingScaleFactor);
+	_get_mouse_pos(wd, [wd.window_object mouseLocationOutsideOfEventStream]);
 	Input::get_singleton()->set_mouse_position(wd.mouse_pos);
 
 	DS_OSX->window_focused = true;
@@ -543,6 +544,12 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 }
 
 - (CALayer *)makeBackingLayer {
+#if defined(OPENGL_ENABLED)
+	if (DS_OSX->rendering_driver == "opengl_es") {
+		CALayer *layer = [[NSOpenGLLayer class] layer];
+		return layer;
+	}
+#endif
 #if defined(VULKAN_ENABLED)
 	if (DS_OSX->rendering_driver == "vulkan") {
 		CALayer *layer = [[CAMetalLayer class] layer];
@@ -553,20 +560,17 @@ static NSCursor *_cursorFromSelector(SEL selector, SEL fallback = nil) {
 }
 
 - (void)updateLayer {
-#if defined(VULKAN_ENABLED)
-	if (DS_OSX->rendering_driver == "vulkan") {
-		[super updateLayer];
-	}
-#endif
 #if defined(OPENGL_ENABLED)
 	if (DS_OSX->rendering_driver == "opengl_es") {
-		ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
-		DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
-
-		wd.context_gles2->update();
+		[super updateLayer];
 		//TODO - reimplement OpenGLES
 	}
 #endif
+#if defined(VULKAN_ENABLED)
+	if (DS_OSX->rendering_driver == "vulkan") {
+		[super updateLayer];
+	}
+#endif
 }
 
 - (BOOL)wantsUpdateLayer {
@@ -631,8 +635,9 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 }
 
 - (void)doCommandBySelector:(SEL)aSelector {
-	if ([self respondsToSelector:aSelector])
+	if ([self respondsToSelector:aSelector]) {
 		[self performSelector:aSelector];
+	}
 }
 
 - (void)unmarkText {
@@ -667,8 +672,8 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
 	const NSRect contentRect = [wd.window_view frame];
-	float displayScale = DS_OSX->_display_scale([wd.window_object screen]);
-	NSRect pointInWindowRect = NSMakeRect(wd.im_position.x / displayScale, contentRect.size.height - (wd.im_position.y / displayScale) - 1, 0, 0);
+	const float scale = DS_OSX->screen_get_max_scale();
+	NSRect pointInWindowRect = NSMakeRect(wd.im_position.x / scale, contentRect.size.height - (wd.im_position.y / scale) - 1, 0, 0);
 	NSPoint pointOnScreen = [wd.window_object convertRectToScreen:pointInWindowRect].origin;
 
 	return NSMakeRect(pointOnScreen.x, pointOnScreen.y, 0, 0);
@@ -707,8 +712,9 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 	for (i = 0; i < length; i++) {
 		const unichar codepoint = [characters characterAtIndex:i];
-		if ((codepoint & 0xFF00) == 0xF700)
+		if ((codepoint & 0xFF00) == 0xF700) {
 			continue;
+		}
 
 		DisplayServerOSX::KeyEvent ke;
 
@@ -775,6 +781,12 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 }
 
 - (BOOL)canBecomeKeyView {
+	if (DS_OSX->windows.has(window_id)) {
+		DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
+		if (wd.no_focus) {
+			return NO;
+		}
+	}
 	return YES;
 }
 
@@ -801,8 +813,7 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 	Ref<InputEventMouseButton> mb;
 	mb.instance();
 	mb->set_window_id(window_id);
-	const CGFloat backingScaleFactor = (OS::get_singleton()->is_hidpi_allowed()) ? [[event window] backingScaleFactor] : 1.0;
-	const Vector2 pos = _get_mouse_pos(wd, [event locationInWindow], backingScaleFactor);
+	const Vector2 pos = _get_mouse_pos(wd, [event locationInWindow]);
 	_get_key_modifier_state([event modifierFlags], mb);
 	mb->set_button_index(index);
 	mb->set_pressed(pressed);
@@ -848,13 +859,58 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 	ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
+	NSPoint delta = NSMakePoint([event deltaX], [event deltaY]);
+	NSPoint mpos = [event locationInWindow];
+
+	if (DS_OSX->mouse_mode == DisplayServer::MOUSE_MODE_CONFINED) {
+		// Discard late events
+		if (([event timestamp]) < DS_OSX->last_warp) {
+			return;
+		}
+
+		// Warp affects next event delta, subtract previous warp deltas
+		List<DisplayServerOSX::WarpEvent>::Element *F = DS_OSX->warp_events.front();
+		while (F) {
+			if (F->get().timestamp < [event timestamp]) {
+				List<DisplayServerOSX::WarpEvent>::Element *E = F;
+				delta.x -= E->get().delta.x;
+				delta.y -= E->get().delta.y;
+				F = F->next();
+				DS_OSX->warp_events.erase(E);
+			} else {
+				F = F->next();
+			}
+		}
+
+		// Confine mouse position to the window, and update delta
+		NSRect frame = [wd.window_object frame];
+		NSPoint conf_pos = mpos;
+		conf_pos.x = CLAMP(conf_pos.x + delta.x, 0.f, frame.size.width);
+		conf_pos.y = CLAMP(conf_pos.y - delta.y, 0.f, frame.size.height);
+		delta.x = conf_pos.x - mpos.x;
+		delta.y = mpos.y - conf_pos.y;
+		mpos = conf_pos;
+
+		// Move mouse cursor
+		NSRect pointInWindowRect = NSMakeRect(conf_pos.x, conf_pos.y, 0, 0);
+		conf_pos = [[wd.window_view window] convertRectToScreen:pointInWindowRect].origin;
+		conf_pos.y = CGDisplayBounds(CGMainDisplayID()).size.height - conf_pos.y;
+		CGWarpMouseCursorPosition(conf_pos);
+
+		// Save warp data
+		DS_OSX->last_warp = [[NSProcessInfo processInfo] systemUptime];
+		DisplayServerOSX::WarpEvent ev;
+		ev.timestamp = DS_OSX->last_warp;
+		ev.delta = delta;
+		DS_OSX->warp_events.push_back(ev);
+	}
+
 	Ref<InputEventMouseMotion> mm;
 	mm.instance();
 
 	mm->set_window_id(window_id);
 	mm->set_button_mask(DS_OSX->last_button_state);
-	const CGFloat backingScaleFactor = (OS::get_singleton()->is_hidpi_allowed()) ? [[event window] backingScaleFactor] : 1.0;
-	const Vector2i pos = _get_mouse_pos(wd, [event locationInWindow], backingScaleFactor);
+	const Vector2i pos = _get_mouse_pos(wd, mpos);
 	mm->set_position(pos);
 	mm->set_pressure([event pressure]);
 	if ([event subtype] == NSEventSubtypeTabletPoint) {
@@ -863,9 +919,7 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 	}
 	mm->set_global_position(pos);
 	mm->set_speed(Input::get_singleton()->get_last_mouse_speed());
-	Vector2i relativeMotion = Vector2i();
-	relativeMotion.x = [event deltaX] * backingScaleFactor;
-	relativeMotion.y = [event deltaY] * backingScaleFactor;
+	const Vector2i relativeMotion = Vector2i(delta.x, delta.y) * DS_OSX->screen_get_max_scale();
 	mm->set_relative(relativeMotion);
 	_get_key_modifier_state([event modifierFlags], mm);
 
@@ -917,16 +971,18 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 	ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
-	if (DS_OSX->mouse_mode != DisplayServer::MOUSE_MODE_CAPTURED)
+	if (DS_OSX->mouse_mode != DisplayServer::MOUSE_MODE_CAPTURED) {
 		DS_OSX->_send_window_event(wd, DisplayServerOSX::WINDOW_EVENT_MOUSE_EXIT);
+	}
 }
 
 - (void)mouseEntered:(NSEvent *)event {
 	ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
 	DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
 
-	if (DS_OSX->mouse_mode != DisplayServer::MOUSE_MODE_CAPTURED)
+	if (DS_OSX->mouse_mode != DisplayServer::MOUSE_MODE_CAPTURED) {
 		DS_OSX->_send_window_event(wd, DisplayServerOSX::WINDOW_EVENT_MOUSE_ENTER);
+	}
 
 	DisplayServer::CursorShape p_shape = DS_OSX->cursor_shape;
 	DS_OSX->cursor_shape = DisplayServer::CURSOR_MAX;
@@ -941,8 +997,7 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 	ev.instance();
 	ev->set_window_id(window_id);
 	_get_key_modifier_state([event modifierFlags], ev);
-	const CGFloat backingScaleFactor = (OS::get_singleton()->is_hidpi_allowed()) ? [[event window] backingScaleFactor] : 1.0;
-	ev->set_position(_get_mouse_pos(wd, [event locationInWindow], backingScaleFactor));
+	ev->set_position(_get_mouse_pos(wd, [event locationInWindow]));
 	ev->set_factor([event magnification] + 1.0);
 
 	Input::get_singleton()->accumulate_input_event(ev);
@@ -958,17 +1013,8 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, i
 		[trackingArea release];
 	}
 
-	NSTrackingAreaOptions options =
-			NSTrackingMouseEnteredAndExited |
-			NSTrackingActiveInKeyWindow |
-			NSTrackingCursorUpdate |
-			NSTrackingInVisibleRect;
-
-	trackingArea = [[NSTrackingArea alloc]
-			initWithRect:[self bounds]
-				 options:options
-				   owner:self
-				userInfo:nil];
+	NSTrackingAreaOptions options = NSTrackingMouseEnteredAndExited | NSTrackingActiveInKeyWindow | NSTrackingCursorUpdate | NSTrackingInVisibleRect;
+	trackingArea = [[NSTrackingArea alloc] initWithRect:[self bounds] options:options owner:self userInfo:nil];
 
 	[self addTrackingArea:trackingArea];
 	[super updateTrackingAreas];
@@ -998,8 +1044,9 @@ static bool isNumpadKey(unsigned int key) {
 		0x00
 	};
 	for (int i = 0; table[i] != 0; i++) {
-		if (key == table[i])
+		if (key == table[i]) {
 			return true;
+		}
 	}
 	return false;
 }
@@ -1139,8 +1186,9 @@ static int translateKey(unsigned int key) {
 		/* 7f */ KEY_UNKNOWN,
 	};
 
-	if (key >= 128)
+	if (key >= 128) {
 		return KEY_UNKNOWN;
+	}
 
 	return table[key];
 }
@@ -1209,16 +1257,19 @@ static const _KeyCodeMap _keycodes[55] = {
 };
 
 static int remapKey(unsigned int key, unsigned int state) {
-	if (isNumpadKey(key))
+	if (isNumpadKey(key)) {
 		return translateKey(key);
+	}
 
 	TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
-	if (!currentKeyboard)
+	if (!currentKeyboard) {
 		return translateKey(key);
+	}
 
 	CFDataRef layoutData = (CFDataRef)TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
-	if (!layoutData)
+	if (!layoutData) {
 		return translateKey(key);
+	}
 
 	const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout *)CFDataGetBytePtr(layoutData);
 
@@ -1291,8 +1342,9 @@ static int remapKey(unsigned int key, unsigned int state) {
 	}
 
 	// Pass events to IME handler
-	if (wd.im_active)
+	if (wd.im_active) {
 		[self interpretKeyEvents:[NSArray arrayWithObject:event]];
+	}
 }
 
 - (void)flagsChanged:(NSEvent *)event {
@@ -1445,8 +1497,7 @@ inline void sendPanEvent(DisplayServer::WindowID window_id, double dx, double dy
 
 	double deltaX, deltaY;
 
-	const CGFloat backingScaleFactor = (OS::get_singleton()->is_hidpi_allowed()) ? [[event window] backingScaleFactor] : 1.0;
-	_get_mouse_pos(wd, [event locationInWindow], backingScaleFactor);
+	_get_mouse_pos(wd, [event locationInWindow]);
 
 	deltaX = [event scrollingDeltaX];
 	deltaY = [event scrollingDeltaY];
@@ -1483,6 +1534,25 @@ inline void sendPanEvent(DisplayServer::WindowID window_id, double dx, double dy
 
 - (BOOL)canBecomeKeyWindow {
 	// Required for NSBorderlessWindowMask windows
+	for (Map<DisplayServer::WindowID, DisplayServerOSX::WindowData>::Element *E = DS_OSX->windows.front(); E; E = E->next()) {
+		if (E->get().window_object == self) {
+			if (E->get().no_focus) {
+				return NO;
+			}
+		}
+	}
+	return YES;
+}
+
+- (BOOL)canBecomeMainWindow {
+	// Required for NSBorderlessWindowMask windows
+	for (Map<DisplayServer::WindowID, DisplayServerOSX::WindowData>::Element *E = DS_OSX->windows.front(); E; E = E->next()) {
+		if (E->get().window_object == self) {
+			if (E->get().no_focus) {
+				return NO;
+			}
+		}
+	}
 	return YES;
 }
 
@@ -1509,6 +1579,7 @@ bool DisplayServerOSX::has_feature(Feature p_feature) const {
 		case FEATURE_HIDPI:
 		case FEATURE_ICON:
 		case FEATURE_NATIVE_ICON:
+		//case FEATURE_KEEP_SCREEN_ON:
 		case FEATURE_SWAP_BUFFERS:
 			return true;
 		default: {
@@ -1954,8 +2025,9 @@ Error DisplayServerOSX::dialog_input_text(String p_title, String p_description,
 void DisplayServerOSX::mouse_set_mode(MouseMode p_mode) {
 	_THREAD_SAFE_METHOD_
 
-	if (p_mode == mouse_mode)
+	if (p_mode == mouse_mode) {
 		return;
+	}
 
 	if (p_mode == MOUSE_MODE_CAPTURED) {
 		// Apple Docs state that the display parameter is not used.
@@ -1970,11 +2042,15 @@ void DisplayServerOSX::mouse_set_mode(MouseMode p_mode) {
 			CGDisplayHideCursor(kCGDirectMainDisplay);
 		}
 		CGAssociateMouseAndMouseCursorPosition(true);
+	} else if (p_mode == MOUSE_MODE_CONFINED) {
+		CGDisplayShowCursor(kCGDirectMainDisplay);
+		CGAssociateMouseAndMouseCursorPosition(false);
 	} else {
 		CGDisplayShowCursor(kCGDirectMainDisplay);
 		CGAssociateMouseAndMouseCursorPosition(true);
 	}
 
+	warp_events.clear();
 	mouse_mode = p_mode;
 }
 
@@ -1992,8 +2068,8 @@ void DisplayServerOSX::mouse_warp_to_position(const Point2i &p_to) {
 
 		//local point in window coords
 		const NSRect contentRect = [wd.window_view frame];
-		float displayScale = _display_scale([wd.window_object screen]);
-		NSRect pointInWindowRect = NSMakeRect(p_to.x / displayScale, contentRect.size.height - (p_to.y / displayScale) - 1, 0, 0);
+		const float scale = screen_get_max_scale();
+		NSRect pointInWindowRect = NSMakeRect(p_to.x / scale, contentRect.size.height - (p_to.y / scale - 1), 0, 0);
 		NSPoint pointOnScreen = [[wd.window_view window] convertRectToScreen:pointInWindowRect].origin;
 
 		//point in scren coords
@@ -2004,7 +2080,9 @@ void DisplayServerOSX::mouse_warp_to_position(const Point2i &p_to) {
 		CGEventSourceSetLocalEventsSuppressionInterval(lEventRef, 0.0);
 		CGAssociateMouseAndMouseCursorPosition(false);
 		CGWarpMouseCursorPosition(lMouseWarpPos);
-		CGAssociateMouseAndMouseCursorPosition(true);
+		if (mouse_mode != MOUSE_MODE_CONFINED) {
+			CGAssociateMouseAndMouseCursorPosition(true);
+		}
 	}
 }
 
@@ -2016,11 +2094,12 @@ Point2i DisplayServerOSX::mouse_get_absolute_position() const {
 	_THREAD_SAFE_METHOD_
 
 	const NSPoint mouse_pos = [NSEvent mouseLocation];
+	const float scale = screen_get_max_scale();
 
 	for (NSScreen *screen in [NSScreen screens]) {
 		NSRect frame = [screen frame];
 		if (NSMouseInRect(mouse_pos, frame, NO)) {
-			return Vector2i((int)mouse_pos.x, (int)-mouse_pos.y) + _get_screens_origin();
+			return Vector2i((int)mouse_pos.x, (int)-mouse_pos.y) * scale + _get_screens_origin();
 		}
 	}
 	return Vector2i();
@@ -2078,17 +2157,10 @@ int DisplayServerOSX::get_screen_count() const {
 // to convert between OS X native screen coordinates and the ones expected by Godot
 
 static bool displays_arrangement_dirty = true;
+static bool displays_scale_dirty = true;
 static void displays_arrangement_changed(CGDirectDisplayID display_id, CGDisplayChangeSummaryFlags flags, void *user_info) {
 	displays_arrangement_dirty = true;
-}
-
-float DisplayServerOSX::_display_scale(id screen) const {
-	if (OS_OSX::get_singleton()->is_hidpi_allowed()) {
-		if ([screen respondsToSelector:@selector(backingScaleFactor)]) {
-			return fmax(1.0, [screen backingScaleFactor]);
-		}
-	}
-	return 1.0;
+	displays_scale_dirty = true;
 }
 
 Point2i DisplayServerOSX::_get_screens_origin() const {
@@ -2115,10 +2187,9 @@ Point2i DisplayServerOSX::_get_screens_origin() const {
 Point2i DisplayServerOSX::_get_native_screen_position(int p_screen) const {
 	NSArray *screenArray = [NSScreen screens];
 	if ((NSUInteger)p_screen < [screenArray count]) {
-		float display_scale = _display_scale([screenArray objectAtIndex:p_screen]);
 		NSRect nsrect = [[screenArray objectAtIndex:p_screen] frame];
 		// Return the top-left corner of the screen, for OS X the y starts at the bottom
-		return Point2i(nsrect.origin.x, nsrect.origin.y + nsrect.size.height) * display_scale;
+		return Point2i(nsrect.origin.x, nsrect.origin.y + nsrect.size.height) * screen_get_max_scale();
 	}
 
 	return Point2i();
@@ -2147,10 +2218,9 @@ Size2i DisplayServerOSX::screen_get_size(int p_screen) const {
 
 	NSArray *screenArray = [NSScreen screens];
 	if ((NSUInteger)p_screen < [screenArray count]) {
-		float displayScale = _display_scale([screenArray objectAtIndex:p_screen]);
 		// Note: Use frame to get the whole screen size
 		NSRect nsrect = [[screenArray objectAtIndex:p_screen] frame];
-		return Size2i(nsrect.size.width, nsrect.size.height) * displayScale;
+		return Size2i(nsrect.size.width, nsrect.size.height) * screen_get_max_scale();
 	}
 
 	return Size2i();
@@ -2165,13 +2235,9 @@ int DisplayServerOSX::screen_get_dpi(int p_screen) const {
 
 	NSArray *screenArray = [NSScreen screens];
 	if ((NSUInteger)p_screen < [screenArray count]) {
-		float displayScale = _display_scale([screenArray objectAtIndex:p_screen]);
 		NSDictionary *description = [[screenArray objectAtIndex:p_screen] deviceDescription];
-		NSSize displayPixelSize = [[description objectForKey:NSDeviceSize] sizeValue];
-		CGSize displayPhysicalSize = CGDisplayScreenSize(
-				[[description objectForKey:@"NSScreenNumber"] unsignedIntValue]);
-
-		return (displayPixelSize.width * 25.4f / displayPhysicalSize.width) * displayScale;
+		NSSize displayDPI = [[description objectForKey:NSDeviceResolution] sizeValue];
+		return (displayDPI.width + displayDPI.height) / 2;
 	}
 
 	return 96;
@@ -2183,14 +2249,32 @@ float DisplayServerOSX::screen_get_scale(int p_screen) const {
 	if (p_screen == SCREEN_OF_MAIN_WINDOW) {
 		p_screen = window_get_current_screen();
 	}
-	NSArray *screenArray = [NSScreen screens];
-	if ((NSUInteger)p_screen < [screenArray count]) {
-		return _display_scale([screenArray objectAtIndex:p_screen]);
+	if (OS::get_singleton()->is_hidpi_allowed()) {
+		NSArray *screenArray = [NSScreen screens];
+		if ((NSUInteger)p_screen < [screenArray count]) {
+			if ([[screenArray objectAtIndex:p_screen] respondsToSelector:@selector(backingScaleFactor)]) {
+				return fmax(1.0, [[screenArray objectAtIndex:p_screen] backingScaleFactor]);
+			}
+		}
 	}
 
 	return 1.f;
 }
 
+float DisplayServerOSX::screen_get_max_scale() const {
+	_THREAD_SAFE_METHOD_
+
+	static float scale = 1.f;
+	if (displays_scale_dirty) {
+		int screen_count = get_screen_count();
+		for (int i = 0; i < screen_count; i++) {
+			scale = fmax(scale, screen_get_scale(i));
+		}
+		displays_scale_dirty = false;
+	}
+	return scale;
+}
+
 Rect2i DisplayServerOSX::screen_get_usable_rect(int p_screen) const {
 	_THREAD_SAFE_METHOD_
 
@@ -2200,12 +2284,12 @@ Rect2i DisplayServerOSX::screen_get_usable_rect(int p_screen) const {
 
 	NSArray *screenArray = [NSScreen screens];
 	if ((NSUInteger)p_screen < [screenArray count]) {
-		float displayScale = _display_scale([screenArray objectAtIndex:p_screen]);
+		const float scale = screen_get_max_scale();
 		NSRect nsrect = [[screenArray objectAtIndex:p_screen] visibleFrame];
 
-		Point2i position = Point2i(nsrect.origin.x, nsrect.origin.y + nsrect.size.height) * displayScale - _get_screens_origin();
+		Point2i position = Point2i(nsrect.origin.x, nsrect.origin.y + nsrect.size.height) * scale - _get_screens_origin();
 		position.y *= -1;
-		Size2i size = Size2i(nsrect.size.width, nsrect.size.height) * displayScale;
+		Size2i size = Size2i(nsrect.size.width, nsrect.size.height) * scale;
 
 		return Rect2i(position, size);
 	}
@@ -2233,7 +2317,11 @@ DisplayServer::WindowID DisplayServerOSX::create_sub_window(WindowMode p_mode, u
 			window_set_flag(WindowFlags(i), true, id);
 		}
 	}
-	[wd.window_object makeKeyAndOrderFront:nil];
+	if (wd.no_focus) {
+		[wd.window_object orderFront:nil];
+	} else {
+		[wd.window_object makeKeyAndOrderFront:nil];
+	}
 	return id;
 }
 
@@ -2251,8 +2339,9 @@ void DisplayServerOSX::_send_window_event(const WindowData &wd, WindowEvent p_ev
 
 DisplayServerOSX::WindowID DisplayServerOSX::_find_window_id(id p_window) {
 	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		if (E->get().window_object == p_window)
+		if (E->get().window_object == p_window) {
 			return E->key();
+		}
 	}
 	return INVALID_WINDOW_ID;
 }
@@ -2397,11 +2486,12 @@ Point2i DisplayServerOSX::window_get_position(WindowID p_window) const {
 
 	NSRect nsrect = [wd.window_object frame];
 	Point2i pos;
-	float display_scale = _display_scale([wd.window_object screen]);
 
 	// Return the position of the top-left corner, for OS X the y starts at the bottom
-	pos.x = nsrect.origin.x * display_scale;
-	pos.y = (nsrect.origin.y + nsrect.size.height) * display_scale;
+	const float scale = screen_get_max_scale();
+	pos.x = nsrect.origin.x;
+	pos.y = (nsrect.origin.y + nsrect.size.height);
+	pos *= scale;
 	pos -= _get_screens_origin();
 	// OS X native y-coordinate relative to _get_screens_origin() is negative,
 	// Godot expects a positive value
@@ -2420,17 +2510,12 @@ void DisplayServerOSX::window_set_position(const Point2i &p_position, WindowID p
 	// Godot passes a positive value
 	position.y *= -1;
 	position += _get_screens_origin();
+	position /= screen_get_max_scale();
 
-	NSPoint pos;
-	float displayScale = _display_scale([wd.window_object screen]);
-
-	pos.x = position.x / displayScale;
-	pos.y = position.y / displayScale;
-
-	[wd.window_object setFrameTopLeftPoint:pos];
+	[wd.window_object setFrameTopLeftPoint:NSMakePoint(position.x, position.y)];
 
 	_update_window(wd);
-	_get_mouse_pos(wd, [wd.window_object mouseLocationOutsideOfEventStream], displayScale);
+	_get_mouse_pos(wd, [wd.window_object mouseLocationOutsideOfEventStream]);
 }
 
 void DisplayServerOSX::window_set_max_size(const Size2i p_size, WindowID p_window) {
@@ -2446,7 +2531,7 @@ void DisplayServerOSX::window_set_max_size(const Size2i p_size, WindowID p_windo
 	wd.max_size = p_size;
 
 	if ((wd.max_size != Size2i()) && !wd.fullscreen) {
-		Size2i size = wd.max_size / _display_scale([wd.window_object screen]);
+		Size2i size = wd.max_size / screen_get_max_scale();
 		[wd.window_object setContentMaxSize:NSMakeSize(size.x, size.y)];
 	} else {
 		[wd.window_object setContentMaxSize:NSMakeSize(FLT_MAX, FLT_MAX)];
@@ -2474,7 +2559,7 @@ void DisplayServerOSX::window_set_min_size(const Size2i p_size, WindowID p_windo
 	wd.min_size = p_size;
 
 	if ((wd.min_size != Size2i()) && !wd.fullscreen) {
-		Size2i size = wd.min_size / _display_scale([wd.window_object screen]);
+		Size2i size = wd.min_size / screen_get_max_scale();
 		[wd.window_object setContentMinSize:NSMakeSize(size.x, size.y)];
 	} else {
 		[wd.window_object setContentMinSize:NSMakeSize(0, 0)];
@@ -2496,7 +2581,7 @@ void DisplayServerOSX::window_set_size(const Size2i p_size, WindowID p_window) {
 	ERR_FAIL_COND(!windows.has(p_window));
 	WindowData &wd = windows[p_window];
 
-	Size2i size = p_size / _display_scale([wd.window_object screen]);
+	Size2i size = p_size / screen_get_max_scale();
 
 	if (!wd.borderless) {
 		// NSRect used by setFrame includes the title bar, so add it to our size.y
@@ -2526,7 +2611,7 @@ Size2i DisplayServerOSX::window_get_real_size(WindowID p_window) const {
 	ERR_FAIL_COND_V(!windows.has(p_window), Size2i());
 	const WindowData &wd = windows[p_window];
 	NSRect frame = [wd.window_object frame];
-	return Size2i(frame.size.width, frame.size.height) * _display_scale([wd.window_object screen]);
+	return Size2i(frame.size.width, frame.size.height) * screen_get_max_scale();
 }
 
 bool DisplayServerOSX::window_is_maximize_allowed(WindowID p_window) const {
@@ -2537,24 +2622,26 @@ void DisplayServerOSX::_set_window_per_pixel_transparency_enabled(bool p_enabled
 	ERR_FAIL_COND(!windows.has(p_window));
 	WindowData &wd = windows[p_window];
 
-	if (!OS_OSX::get_singleton()->is_layered_allowed())
+	if (!OS_OSX::get_singleton()->is_layered_allowed()) {
 		return;
+	}
 	if (wd.layered_window != p_enabled) {
 		if (p_enabled) {
 			[wd.window_object setBackgroundColor:[NSColor clearColor]];
 			[wd.window_object setOpaque:NO];
 			[wd.window_object setHasShadow:NO];
+			CALayer *layer = [wd.window_view layer];
+			if (layer) {
+				[layer setOpaque:NO];
+			}
 #if defined(VULKAN_ENABLED)
 			if (rendering_driver == "vulkan") {
-				CALayer *layer = [wd.window_view layer];
-				[layer setOpaque:NO];
 				//TODO - implement transparency for Vulkan
 			}
 #endif
 #if defined(OPENGL_ENABLED)
 			if (rendering_driver == "opengl_es") {
 				//TODO - reimplement OpenGLES
-				wd.context_gles2->set_opacity(0);
 			}
 #endif
 			wd.layered_window = true;
@@ -2562,17 +2649,18 @@ void DisplayServerOSX::_set_window_per_pixel_transparency_enabled(bool p_enabled
 			[wd.window_object setBackgroundColor:[NSColor colorWithCalibratedWhite:1 alpha:1]];
 			[wd.window_object setOpaque:YES];
 			[wd.window_object setHasShadow:YES];
+			CALayer *layer = [wd.window_view layer];
+			if (layer) {
+				[layer setOpaque:YES];
+			}
 #if defined(VULKAN_ENABLED)
 			if (rendering_driver == "vulkan") {
-				CALayer *layer = [wd.window_view layer];
-				[layer setOpaque:YES];
 				//TODO - implement transparency for Vulkan
 			}
 #endif
 #if defined(OPENGL_ENABLED)
 			if (rendering_driver == "opengl_es") {
 				//TODO - reimplement OpenGLES
-				wd.context_gles2->set_opacity(1);
 			}
 #endif
 			wd.layered_window = false;
@@ -2580,7 +2668,11 @@ void DisplayServerOSX::_set_window_per_pixel_transparency_enabled(bool p_enabled
 #if defined(OPENGL_ENABLED)
 		if (rendering_driver == "opengl_es") {
 			//TODO - reimplement OpenGLES
-			wd.context_gles2->update();
+		}
+#endif
+#if defined(VULKAN_ENABLED)
+		if (rendering_driver == "vulkan") {
+			//TODO - implement transparency for Vulkan
 		}
 #endif
 		NSRect frameRect = [wd.window_object frame];
@@ -2608,16 +2700,18 @@ void DisplayServerOSX::window_set_mode(WindowMode p_mode, WindowID p_window) {
 			[wd.window_object deminiaturize:nil];
 		} break;
 		case WINDOW_MODE_FULLSCREEN: {
-			if (wd.layered_window)
+			if (wd.layered_window) {
 				_set_window_per_pixel_transparency_enabled(true, p_window);
-			if (wd.resize_disabled) //restore resize disabled
+			}
+			if (wd.resize_disabled) { //restore resize disabled
 				[wd.window_object setStyleMask:[wd.window_object styleMask] & ~NSWindowStyleMaskResizable];
+			}
 			if (wd.min_size != Size2i()) {
-				Size2i size = wd.min_size / _display_scale([wd.window_object screen]);
+				Size2i size = wd.min_size / screen_get_max_scale();
 				[wd.window_object setContentMinSize:NSMakeSize(size.x, size.y)];
 			}
 			if (wd.max_size != Size2i()) {
-				Size2i size = wd.max_size / _display_scale([wd.window_object screen]);
+				Size2i size = wd.max_size / screen_get_max_scale();
 				[wd.window_object setContentMaxSize:NSMakeSize(size.x, size.y)];
 			}
 			[wd.window_object toggleFullScreen:nil];
@@ -2686,8 +2780,9 @@ void DisplayServerOSX::window_set_flag(WindowFlags p_flag, bool p_enabled, Windo
 	switch (p_flag) {
 		case WINDOW_FLAG_RESIZE_DISABLED: {
 			wd.resize_disabled = p_enabled;
-			if (wd.fullscreen) //fullscreen window should be resizable, style will be applyed on exiting fs
+			if (wd.fullscreen) { //fullscreen window should be resizable, style will be applyed on exiting fs
 				return;
+			}
 			if (p_enabled) {
 				[wd.window_object setStyleMask:[wd.window_object styleMask] & ~NSWindowStyleMaskResizable];
 			} else {
@@ -2728,7 +2823,9 @@ void DisplayServerOSX::window_set_flag(WindowFlags p_flag, bool p_enabled, Windo
 				[wd.window_object setStyleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable | (wd.resize_disabled ? 0 : NSWindowStyleMaskResizable)];
 			}
 			_set_window_per_pixel_transparency_enabled(p_enabled, p_window);
-
+		} break;
+		case WINDOW_FLAG_NO_FOCUS: {
+			wd.no_focus = p_enabled;
 		} break;
 		default: {
 		}
@@ -2754,6 +2851,9 @@ bool DisplayServerOSX::window_get_flag(WindowFlags p_flag, WindowID p_window) co
 		case WINDOW_FLAG_TRANSPARENT: {
 			return wd.layered_window;
 		} break;
+		case WINDOW_FLAG_NO_FOCUS: {
+			return wd.no_focus;
+		} break;
 		default: {
 		}
 	}
@@ -2799,8 +2899,9 @@ void DisplayServerOSX::window_set_ime_active(const bool p_active, WindowID p_win
 
 	wd.im_active = p_active;
 
-	if (!p_active)
+	if (!p_active) {
 		[wd.window_view cancelComposition];
+	}
 }
 
 void DisplayServerOSX::window_set_ime_position(const Point2i &p_pos, WindowID p_window) {
@@ -2821,8 +2922,9 @@ void DisplayServerOSX::cursor_set_shape(CursorShape p_shape) {
 
 	ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
 
-	if (cursor_shape == p_shape)
+	if (cursor_shape == p_shape) {
 		return;
+	}
 
 	if (mouse_mode != MOUSE_MODE_VISIBLE && mouse_mode != MOUSE_MODE_CONFINED) {
 		cursor_shape = p_shape;
@@ -3216,8 +3318,9 @@ void DisplayServerOSX::process_events() {
 							   inMode:NSDefaultRunLoopMode
 							  dequeue:YES];
 
-		if (event == nil)
+		if (event == nil) {
 			break;
+		}
 
 		[NSApp sendEvent:event];
 	}
@@ -3305,11 +3408,11 @@ void DisplayServerOSX::set_icon(const Ref<Image> &p_icon) {
 Vector<String> DisplayServerOSX::get_rendering_drivers_func() {
 	Vector<String> drivers;
 
-#ifdef VULKAN_ENABLED
+#if defined(VULKAN_ENABLED)
 	drivers.push_back("vulkan");
 #endif
-#ifdef OPENGL_ENABLED
-	drivers.push_back("opengl");
+#if defined(OPENGL_ENABLED)
+	drivers.push_back("opengl_es");
 #endif
 
 	return drivers;
@@ -3324,9 +3427,14 @@ String DisplayServerOSX::ime_get_text() const {
 }
 
 DisplayServer::WindowID DisplayServerOSX::get_window_at_screen_position(const Point2i &p_position) const {
+	Point2i position = p_position;
+	position.y *= -1;
+	position += _get_screens_origin();
+	position /= screen_get_max_scale();
+
+	NSInteger wnum = [NSWindow windowNumberAtPoint:NSMakePoint(position.x, position.y) belowWindowWithWindowNumber:0 /*topmost*/];
 	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
-		Rect2i win_rect = Rect2i(window_get_position(E->key()), window_get_size(E->key()));
-		if (win_rect.has_point(p_position)) {
+		if ([E->get().window_object windowNumber] == wnum) {
 			return E->key();
 		}
 	}
@@ -3353,18 +3461,10 @@ DisplayServer *DisplayServerOSX::create_func(const String &p_rendering_driver, W
 
 DisplayServerOSX::WindowID DisplayServerOSX::_create_window(WindowMode p_mode, const Rect2i &p_rect) {
 	WindowID id;
+	const float scale = screen_get_max_scale();
 	{
 		WindowData wd;
 
-		float displayScale = 1.0;
-		if (OS_OSX::get_singleton()->is_hidpi_allowed()) {
-			// note that mainScreen is not screen #0 but the one with the keyboard focus.
-			NSScreen *screen = [NSScreen mainScreen];
-			if ([screen respondsToSelector:@selector(backingScaleFactor)]) {
-				displayScale = fmax(displayScale, [screen backingScaleFactor]);
-			}
-		}
-
 		wd.window_delegate = [[GodotWindowDelegate alloc] init];
 		ERR_FAIL_COND_V_MSG(wd.window_delegate == nil, INVALID_WINDOW_ID, "Can't create a window delegate");
 		[wd.window_delegate setWindowID:window_id_counter];
@@ -3377,7 +3477,7 @@ DisplayServerOSX::WindowID DisplayServerOSX::_create_window(WindowMode p_mode, c
 
 		// initWithContentRect uses bottom-left corner of the window’s frame as origin.
 		wd.window_object = [[GodotWindow alloc]
-				initWithContentRect:NSMakeRect(position.x / displayScale, (position.y - p_rect.size.height) / displayScale, p_rect.size.width / displayScale, p_rect.size.height / displayScale)
+				initWithContentRect:NSMakeRect(position.x / scale, (position.y - p_rect.size.height) / scale, p_rect.size.width / scale, p_rect.size.height / scale)
 						  styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable | NSWindowStyleMaskResizable
 							backing:NSBackingStoreBuffered
 							  defer:NO];
@@ -3390,54 +3490,32 @@ DisplayServerOSX::WindowID DisplayServerOSX::_create_window(WindowMode p_mode, c
 			[wd.window_view setWantsLayer:TRUE];
 		}
 
-		if (displayScale > 1.0) {
-#if defined(OPENGL_ENABLED)
-			if (rendering_driver == "opengl_es") {
-				[wd.window_view setWantsBestResolutionOpenGLSurface:YES];
-			}
-#endif
-			[wd.window_object setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
-		} else {
-#if defined(OPENGL_ENABLED)
-			if (rendering_driver == "opengl_es") {
-				[wd.window_view setWantsBestResolutionOpenGLSurface:NO];
-			}
-#endif
-		}
-
 		[wd.window_object setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
 		[wd.window_object setContentView:wd.window_view];
 		[wd.window_object setDelegate:wd.window_delegate];
 		[wd.window_object setAcceptsMouseMovedEvents:YES];
 		[wd.window_object setRestorable:NO];
 
-		if ([wd.window_object respondsToSelector:@selector(setTabbingMode:)])
+		if ([wd.window_object respondsToSelector:@selector(setTabbingMode:)]) {
 			[wd.window_object setTabbingMode:NSWindowTabbingModeDisallowed];
+		}
+
+		CALayer *layer = [wd.window_view layer];
+		if (layer) {
+			layer.contentsScale = scale;
+		}
 
 #if defined(VULKAN_ENABLED)
 		if (rendering_driver == "vulkan") {
 			if (context_vulkan) {
-				CALayer *layer = [wd.window_view layer];
-				layer.contentsScale = displayScale;
 				Error err = context_vulkan->window_create(window_id_counter, wd.window_view, p_rect.size.width, p_rect.size.height);
 				ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, "Can't create a Vulkan context");
 			}
 		}
 #endif
-#ifdef OPENGL_ENABLED
+#if defined(OPENGL_ENABLED)
 		if (rendering_driver == "opengl_es") {
 			//TODO - reimplement OpenGLES
-			wd.context_gles2 = memnew(ContextGL_OSX(wd.window_view, false));
-
-			if (wd.context_gles2->initialize() != OK) {
-				memdelete(wd.context_gles2);
-				ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, "Can't create a OpenGL context");
-			}
-
-			//if (RasterizerGLES2::is_viable() == OK) {
-			//	RasterizerGLES2::register_config();
-			//	RasterizerGLES2::make_current();
-			//}
 		}
 #endif
 		id = window_id_counter++;
@@ -3447,25 +3525,22 @@ DisplayServerOSX::WindowID DisplayServerOSX::_create_window(WindowMode p_mode, c
 	WindowData &wd = windows[id];
 	window_set_mode(p_mode, id);
 
-	float displayScale = _display_scale([wd.window_object screen]);
 	const NSRect contentRect = [wd.window_view frame];
-	wd.size.width = contentRect.size.width * displayScale;
-	wd.size.height = contentRect.size.height * displayScale;
+	wd.size.width = contentRect.size.width * scale;
+	wd.size.height = contentRect.size.height * scale;
+
+	CALayer *layer = [wd.window_view layer];
+	if (layer) {
+		layer.contentsScale = scale;
+	}
 
 #if defined(OPENGL_ENABLED)
 	if (rendering_driver == "opengl_es") {
-		if (OS_OSX::singleton->is_hidpi_allowed()) {
-			[wd.window_view setWantsBestResolutionOpenGLSurface:YES];
-		} else {
-			[wd.window_view setWantsBestResolutionOpenGLSurface:NO];
-		}
-		wd.context_gles2->update();
+		//TODO - reimplement OpenGLES
 	}
 #endif
 #if defined(VULKAN_ENABLED)
 	if (rendering_driver == "vulkan") {
-		CALayer *layer = [wd.window_view layer];
-		layer.contentsScale = displayScale;
 		context_vulkan->window_resize(id, wd.size.width, wd.size.height);
 	}
 #endif
@@ -3560,6 +3635,7 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 
 	keyboard_layout_dirty = true;
 	displays_arrangement_dirty = true;
+	displays_scale_dirty = true;
 
 	// Register to be notified on keyboard layout changes
 	CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(),
@@ -3577,8 +3653,9 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 	NSString *title;
 
 	NSString *nsappname = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleName"];
-	if (nsappname == nil)
+	if (nsappname == nil) {
 		nsappname = [[NSProcessInfo processInfo] processName];
+	}
 
 	// Setup Dock menu
 	dock_menu = [[NSMenu alloc] initWithTitle:@"_dock"];
@@ -3631,8 +3708,9 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 							   inMode:NSDefaultRunLoopMode
 							  dequeue:YES];
 
-		if (event == nil)
+		if (event == nil) {
 			break;
+		}
 
 		[NSApp sendEvent:event];
 	}
@@ -3664,8 +3742,8 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 #endif
 
 	Point2i window_position(
-			(screen_get_size(0).width - p_resolution.width) / 2,
-			(screen_get_size(0).height - p_resolution.height) / 2);
+			screen_get_position(0).x + (screen_get_size(0).width - p_resolution.width) / 2,
+			screen_get_position(0).y + (screen_get_size(0).height - p_resolution.height) / 2);
 	WindowID main_window = _create_window(p_mode, Rect2i(window_position, p_resolution));
 	for (int i = 0; i < WINDOW_FLAG_MAX; i++) {
 		if (p_flags & (1 << i)) {
@@ -3674,6 +3752,11 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 	}
 	[windows[main_window].window_object makeKeyAndOrderFront:nil];
 
+#if defined(OPENGL_ENABLED)
+	if (rendering_driver == "opengl_es") {
+		//TODO - reimplement OpenGLES
+	}
+#endif
 #if defined(VULKAN_ENABLED)
 	if (rendering_driver == "vulkan") {
 		rendering_device_vulkan = memnew(RenderingDeviceVulkan);
@@ -3684,14 +3767,6 @@ DisplayServerOSX::DisplayServerOSX(const String &p_rendering_driver, WindowMode
 #endif
 
 	[NSApp activateIgnoringOtherApps:YES];
-
-	/*
-	visual_server = memnew(VisualServerRaster);
-	if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
-		visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
-	}
-	visual_server->init();
-	*/
 }
 
 DisplayServerOSX::~DisplayServerOSX() {
@@ -3710,6 +3785,11 @@ DisplayServerOSX::~DisplayServerOSX() {
 	}
 
 	//destroy drivers
+#if defined(OPENGL_ENABLED)
+	if (rendering_driver == "opengl_es") {
+		//TODO - reimplement OpenGLES
+	}
+#endif
 #if defined(VULKAN_ENABLED)
 	if (rendering_driver == "vulkan") {
 		if (rendering_device_vulkan) {
@@ -3717,8 +3797,9 @@ DisplayServerOSX::~DisplayServerOSX() {
 			memdelete(rendering_device_vulkan);
 		}
 
-		if (context_vulkan)
+		if (context_vulkan) {
 			memdelete(context_vulkan);
+		}
 	}
 #endif
 
@@ -3726,9 +3807,6 @@ DisplayServerOSX::~DisplayServerOSX() {
 	CGDisplayRemoveReconfigurationCallback(displays_arrangement_changed, NULL);
 
 	cursors_cache.clear();
-
-	//visual_server->finish();
-	//memdelete(visual_server);
 }
 
 void DisplayServerOSX::register_osx_driver() {
diff --git a/platform/osx/os_osx.mm b/platform/osx/os_osx.mm
index dba96ccfcd..4ca89ff4b2 100644
--- a/platform/osx/os_osx.mm
+++ b/platform/osx/os_osx.mm
@@ -272,7 +272,13 @@ String OS_OSX::get_system_dir(SystemDir p_dir) const {
 }
 
 Error OS_OSX::shell_open(String p_uri) {
-	[[NSWorkspace sharedWorkspace] openURL:[[NSURL alloc] initWithString:[[NSString stringWithUTF8String:p_uri.utf8().get_data()] stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLFragmentAllowedCharacterSet]]]];
+	NSString *string = [NSString stringWithUTF8String:p_uri.utf8().get_data()];
+	NSURL *uri = [[NSURL alloc] initWithString:string];
+	// Escape special characters in filenames
+	if (!uri || !uri.scheme || [uri.scheme isEqual:@"file"]) {
+		uri = [[NSURL alloc] initWithString:[string stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLFragmentAllowedCharacterSet]]];
+	}
+	[[NSWorkspace sharedWorkspace] openURL:uri];
 	return OK;
 }
 
diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp
index 61dc156fbc..103e858d97 100644
--- a/platform/windows/display_server_windows.cpp
+++ b/platform/windows/display_server_windows.cpp
@@ -476,6 +476,7 @@ DisplayServer::WindowID DisplayServerWindows::create_sub_window(WindowMode p_mod
 	_THREAD_SAFE_METHOD_
 
 	WindowID window_id = _create_window(p_mode, p_flags, p_rect);
+	ERR_FAIL_COND_V_MSG(window_id == INVALID_WINDOW_ID, INVALID_WINDOW_ID, "Failed to create sub window.");
 
 	WindowData &wd = windows[window_id];
 
@@ -1773,14 +1774,22 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
 	};
 
 	WindowID window_id = INVALID_WINDOW_ID;
+	bool window_created = false;
 
 	for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
 		if (E->get().hWnd == hWnd) {
 			window_id = E->key();
+			window_created = true;
 			break;
 		}
 	}
 
+	if (!window_created) {
+		// Window creation in progress.
+		window_id = window_id_counter;
+		ERR_FAIL_COND_V(!windows.has(window_id), 0);
+	}
+
 	switch (uMsg) // Check For Windows Messages
 	{
 		case WM_SETFOCUS: {
@@ -2512,7 +2521,7 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
 					windows[window_id].height = window_h;
 
 #if defined(VULKAN_ENABLED)
-					if (rendering_driver == "vulkan") {
+					if ((rendering_driver == "vulkan") && window_created) {
 						context_vulkan->window_resize(window_id, windows[window_id].width, windows[window_id].height);
 					}
 #endif
@@ -2864,11 +2873,32 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode,
 	WindowRect.top = p_rect.position.y;
 	WindowRect.bottom = p_rect.position.y + p_rect.size.y;
 
+	if (p_mode == WINDOW_MODE_FULLSCREEN) {
+		int nearest_area = 0;
+		Rect2i screen_rect;
+		for (int i = 0; i < get_screen_count(); i++) {
+			Rect2i r;
+			r.position = screen_get_position(i);
+			r.size = screen_get_size(i);
+			Rect2 inters = r.clip(p_rect);
+			int area = inters.size.width * inters.size.height;
+			if (area >= nearest_area) {
+				screen_rect = r;
+				nearest_area = area;
+			}
+		}
+
+		WindowRect.left = screen_rect.position.x;
+		WindowRect.right = screen_rect.position.x + screen_rect.size.x;
+		WindowRect.top = screen_rect.position.y;
+		WindowRect.bottom = screen_rect.position.y + screen_rect.size.y;
+	}
+
 	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);
 
 	WindowID id = window_id_counter;
 	{
-		WindowData wd;
+		WindowData &wd = windows[id];
 
 		wd.hWnd = CreateWindowExW(
 				dwExStyle,
@@ -2883,6 +2913,7 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode,
 				nullptr, nullptr, hInstance, nullptr);
 		if (!wd.hWnd) {
 			MessageBoxW(nullptr, L"Window Creation Error.", L"ERROR", MB_OK | MB_ICONEXCLAMATION);
+			windows.erase(id);
 			return INVALID_WINDOW_ID;
 		}
 #ifdef VULKAN_ENABLED
@@ -2891,7 +2922,8 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode,
 			if (context_vulkan->window_create(id, wd.hWnd, hInstance, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top) == -1) {
 				memdelete(context_vulkan);
 				context_vulkan = nullptr;
-				ERR_FAIL_V(INVALID_WINDOW_ID);
+				windows.erase(id);
+				ERR_FAIL_V_MSG(INVALID_WINDOW_ID, "Failed to create Vulkan Window.");
 			}
 		}
 #endif
@@ -2949,8 +2981,6 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode,
 		wd.width = p_rect.size.width;
 		wd.height = p_rect.size.height;
 
-		windows[id] = wd;
-
 		window_id_counter++;
 	}
 
@@ -3081,7 +3111,10 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win
 	Point2i window_position(
 			(screen_get_size(0).width - p_resolution.width) / 2,
 			(screen_get_size(0).height - p_resolution.height) / 2);
+
 	WindowID main_window = _create_window(p_mode, 0, Rect2i(window_position, p_resolution));
+	ERR_FAIL_COND_MSG(main_window == INVALID_WINDOW_ID, "Failed to create main window.");
+
 	for (int i = 0; i < WINDOW_FLAG_MAX; i++) {
 		if (p_flags & (1 << i)) {
 			window_set_flag(WindowFlags(i), true, main_window);