Add function OS::get_real_path()

* Added a unified `OS.get_real_path(path)` API (exposed via scripting/bindings) to return normalized “real” paths across platforms.

* **Bug Fixes**
  * Windows: improved executable-path resolution with proper normalization, better handling when module path retrieval fails, and more reliable environment variable existence/value detection.
  * Unix: executable-path and platform “real” path normalization now use real-path resolution with validation and safe fallback.

* **Refactor**
  * Introduced a shared real-path resolution interface, aligning OS implementations across platforms.

Author: samuelvenable

core/core_bind.cpp

@@ -360,6 +360,10 @@ String OS::get_executable_path() const {
 	return ::OS::get_singleton()->get_executable_path();
 }
 
+String OS::get_real_path(const String &p_path) const {
+	return ::OS::get_singleton()->get_real_path(p_path);
+}
+
 Error OS::shell_open(const String &p_uri) {
 	if (p_uri.begins_with("res://")) {
 		WARN_PRINT("Attempting to open an URL with the \"res://\" protocol. Use `ProjectSettings.globalize_path()` to convert a Redot-specific path to a system path before opening it with `OS.shell_open()`.");
@@ -767,6 +771,7 @@ void OS::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_system_font_path", "font_name", "weight", "stretch", "italic"), &OS::get_system_font_path, DEFVAL(400), DEFVAL(100), DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("get_system_font_path_for_text", "font_name", "text", "locale", "script", "weight", "stretch", "italic"), &OS::get_system_font_path_for_text, DEFVAL(String()), DEFVAL(String()), DEFVAL(400), DEFVAL(100), DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("get_executable_path"), &OS::get_executable_path);
+	ClassDB::bind_method(D_METHOD("get_real_path", "path"), &OS::get_real_path);
 
 	ClassDB::bind_method(D_METHOD("read_string_from_stdin", "buffer_size"), &OS::read_string_from_stdin, DEFVAL(1024));
 	ClassDB::bind_method(D_METHOD("read_buffer_from_stdin", "buffer_size"), &OS::read_buffer_from_stdin, DEFVAL(1024));

core/core_bind.h

@@ -216,6 +216,7 @@ class OS : public Object {
 	String get_system_font_path(const String &p_font_name, int p_weight = 400, int p_stretch = 100, bool p_italic = false) const;
 	Vector<String> get_system_font_path_for_text(const String &p_font_name, const String &p_text, const String &p_locale = String(), const String &p_script = String(), int p_weight = 400, int p_stretch = 100, bool p_italic = false) const;
 	String get_executable_path() const;
+	String get_real_path(const String &p_path) const;
 
 	String read_string_from_stdin(int64_t p_buffer_size = 1024);
 	PackedByteArray read_buffer_from_stdin(int64_t p_buffer_size = 1024);

core/os/os.cpp

@@ -175,6 +175,10 @@ bool OS::is_delta_smoothing_enabled() const {
 	return _delta_smoothing_enabled;
 }
 
+String OS::get_real_path(const String &p_path) const {
+	return p_path;
+}
+
 String OS::get_executable_path() const {
 	return _execpath;
 }

core/os/os.h

@@ -195,6 +195,7 @@ class OS {
 	virtual Vector<String> get_system_fonts() const { return Vector<String>(); }
 	virtual String get_system_font_path(const String &p_font_name, int p_weight = 400, int p_stretch = 100, bool p_italic = false) const { return String(); }
 	virtual Vector<String> get_system_font_path_for_text(const String &p_font_name, const String &p_text, const String &p_locale = String(), const String &p_script = String(), int p_weight = 400, int p_stretch = 100, bool p_italic = false) const { return Vector<String>(); }
+	virtual String get_real_path(const String &p_path) const;
 	virtual String get_executable_path() const;
 	virtual Error execute(const String &p_path, const List<String> &p_arguments, String *r_pipe = nullptr, int *r_exitcode = nullptr, bool read_stderr = false, Mutex *p_pipe_mutex = nullptr, bool p_open_console = false) = 0;
 	virtual Dictionary execute_with_pipe(const String &p_path, const List<String> &p_arguments, bool p_blocking = true) { return Dictionary(); }

doc/classes/OS.xml

@@ -458,6 +458,15 @@
 				[b]Note:[/b] This method is only implemented on Windows, macOS, Linux and iOS. On Android and Web, [method get_processor_name] returns an empty string.
 			</description>
 		</method>
+		<method name="get_real_path" qualifiers="const">
+			<return type="String" />
+			<param index="0" name="path" type="String" />
+			<description>
+				Normalizes a given path, removing consecutive double-slash path separators, converts relative path logic to absolute, and resolves all symbolic links.
+				[b]Note:[/b] On Windows, if a path passed to the function contains backwards slashes for any path separators, those are replaced with forward slashes.
+				[b]Note:[/b] If the function failed for any reason, max path byte limit exceeded, the original input string with forward slash separators is returned.
+			</description>
+		</method>
 		<method name="get_restart_on_exit_arguments" qualifiers="const">
 			<return type="PackedStringArray" />
 			<description>

drivers/unix/os_unix.cpp

@@ -58,20 +58,19 @@
 #include <sys/sysctl.h>
 #endif
 
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__NetBSD__)
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #endif
 
-#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
 #include <kvm.h>
 #endif
 
 #if defined(__OpenBSD__)
 #include <sys/swap.h>
 #include <sys/types.h>
 #include <uvm/uvmexp.h>
-#include <climits>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -89,6 +88,7 @@
 #include <sys/wait.h>
 #include <unistd.h>
 #include <cerrno>
+#include <climits>
 #include <csignal>
 #include <cstdarg>
 #include <cstdio>
@@ -109,7 +109,7 @@
 // Random location for getentropy. Fitting.
 #include <sys/random.h>
 #define UNIX_GET_ENTROPY
-#elif defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__GLIBC_MINOR__) && (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 26))
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || (defined(__GLIBC_MINOR__) && (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 26))
 // In <unistd.h>.
 // One day... (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700)
 // https://publications.opengroup.org/standards/unix/c211
@@ -454,7 +454,7 @@ Dictionary OS_Unix::get_memory_info() const {
 	if (swap_used.xsu_avail + ((vmstat.free_count - vmstat.speculative_count) + vmstat.external_page_count) * (int64_t)pagesize != 0) {
 		meminfo["available"] = swap_used.xsu_avail + ((vmstat.free_count - vmstat.speculative_count) + vmstat.external_page_count) * (int64_t)pagesize;
 	}
-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
 	int pagesize = 0;
 	size_t len = sizeof(pagesize);
 	if (sysctlbyname("vm.stats.vm.v_page_size", &pagesize, &len, nullptr, 0) < 0) {
@@ -1135,21 +1135,23 @@ String OS_Unix::get_user_data_dir(const String &p_user_dir) const {
 	return get_data_path().path_join(p_user_dir);
 }
 
+String OS_Unix::get_real_path(const String &p_path) const {
+	String result = p_path;
+	char resolved_path[PATH_MAX];
+	if (realpath(p_path.utf8().get_data(), resolved_path)) {
+		result = String::utf8(resolved_path);
+	}
+	return result;
+}
+
 String OS_Unix::get_executable_path() const {
 #ifdef __linux__
-	//fix for running from a symlink
-	char buf[PATH_MAX];
-	memset(buf, 0, PATH_MAX);
-	ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf));
-	String b;
-	if (len > 0) {
-		b.append_utf8(buf, len);
-	}
-	if (b.is_empty()) {
-		WARN_PRINT("Couldn't get executable path from /proc/self/exe, using argv[0]");
+	String s = get_real_path("/proc/self/exe");
+	if (s.is_empty() || s == "/proc/self/exe" || !FileAccess::exists(s)) {
+		WARN_PRINT("Couldn't get executable path from /proc/self/exe");
 		return OS::get_executable_path();
 	}
-	return b;
+	return s;
 #elif defined(__OpenBSD__)
 	std::string path;
 	auto cpp_getexe = [](std::string exe) {
@@ -1318,13 +1320,8 @@ String OS_Unix::get_executable_path() const {
 		return OS::get_executable_path();
 	}
 
-	// NetBSD does not always return a normalized path. For example if argv[0] is "./a.out" then executable path is "/home/netbsd/./a.out". Normalize with realpath:
-	char resolved_path[MAXPATHLEN];
-
-	realpath(buf, resolved_path);
-
-	return String::utf8(resolved_path);
-#elif defined(__FreeBSD__)
+	return get_real_path(String::utf8(buf));
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
 	int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
 	char buf[MAXPATHLEN];
 	size_t len = sizeof(buf);
@@ -1333,7 +1330,7 @@ String OS_Unix::get_executable_path() const {
 		return OS::get_executable_path();
 	}
 
-	return String::utf8(buf);
+	return get_real_path(String::utf8(buf));
 #elif defined(__APPLE__)
 	char temp_path[1];
 	uint32_t buff_size = 1;
@@ -1348,7 +1345,7 @@ String OS_Unix::get_executable_path() const {
 	String path = String::utf8(resolved_path);
 	delete[] resolved_path;
 
-	return path;
+	return get_real_path(path);
 #else
 	ERR_PRINT("Warning, don't know how to obtain executable path on this OS! Please override this function properly.");
 	return OS::get_executable_path();

drivers/unix/os_unix.h

@@ -143,6 +143,7 @@ class OS_Unix : public OS {
 
 	virtual void initialize_debugging() override;
 
+	virtual String get_real_path(const String &p_path) const override;
 	virtual String get_executable_path() const override;
 	virtual String get_user_data_dir(const String &p_user_dir) const override;
 

platform/windows/os_windows.cpp

@@ -2051,24 +2051,51 @@ String OS_Windows::get_system_font_path(const String &p_font_name, int p_weight,
 	return String();
 }
 
+String OS_Windows::get_real_path(const String &p_path) const {
+	WCHAR buf[4096];
+	String res = p_path;
+	HANDLE handle = CreateFileW((const WCHAR *)res.utf16().get_data(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, nullptr);
+	if (handle != INVALID_HANDLE_VALUE) {
+		DWORD len = GetFinalPathNameByHandleW(handle, buf, 4096, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+		if (len && len < 4096) {
+			res = String::utf16((const char16_t *)buf);
+			if (res.begins_with("\\\\?\\UNC\\")) {
+				res = "\\" + res.substr(7);
+			} else if (res.begins_with("\\\\?\\")) {
+				res = res.substr(4);
+			}
+		}
+		CloseHandle(handle);
+	}
+	return res.replace_char('\\', '/');
+}
+
 String OS_Windows::get_executable_path() const {
-	WCHAR bufname[4096];
-	GetModuleFileNameW(nullptr, bufname, 4096);
-	String s = String::utf16((const char16_t *)bufname).replace_char('\\', '/');
-	return s;
+	WCHAR buf[4096];
+	if (!GetModuleFileNameW(nullptr, buf, 4096)) {
+		WARN_PRINT("Couldn't get executable path from GetModuleFileName");
+		return OS::get_executable_path().replace_char('\\', '/');
+	}
+	return get_real_path(String::utf16((const char16_t *)buf));
 }
 
 bool OS_Windows::has_environment(const String &p_var) const {
-	return GetEnvironmentVariableW((LPCWSTR)(p_var.utf16().get_data()), nullptr, 0) > 0;
+	// An environment variable can still exist in the environment block, but just have an empty value; check for ERROR_ENVVAR_NOT_FOUND:
+	return (!(GetEnvironmentVariableW((LPCWSTR)(p_var.utf16().get_data()), nullptr, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND));
 }
 
 String OS_Windows::get_environment(const String &p_var) const {
-	WCHAR wval[0x7fff]; // MSDN says 32767 char is the maximum
-	int wlen = GetEnvironmentVariableW((LPCWSTR)(p_var.utf16().get_data()), wval, 0x7fff);
-	if (wlen > 0) {
-		return String::utf16((const char16_t *)wval);
+	String res;
+	DWORD len = GetEnvironmentVariableW((LPCWSTR)(p_var.utf16().get_data()), nullptr, 0);
+	if (len) {
+		WCHAR *val = new WCHAR[len]();
+		len = GetEnvironmentVariableW((LPCWSTR)(p_var.utf16().get_data()), val, len);
+		if (len) {
+			res = String::utf16((const char16_t *)val);
+		}
+		delete[] val;
 	}
-	return "";
+	return res;
 }
 
 void OS_Windows::set_environment(const String &p_var, const String &p_value) const {

platform/windows/os_windows.h

@@ -227,6 +227,7 @@ class OS_Windows : public OS {
 	virtual String get_system_font_path(const String &p_font_name, int p_weight = 400, int p_stretch = 100, bool p_italic = false) const override;
 	virtual Vector<String> get_system_font_path_for_text(const String &p_font_name, const String &p_text, const String &p_locale = String(), const String &p_script = String(), int p_weight = 400, int p_stretch = 100, bool p_italic = false) const override;
 
+	virtual String get_real_path(const String &p_path) const override;
 	virtual String get_executable_path() const override;
 
 	virtual String get_locale() const override;