Merge tag 'dev-2025-07'

core/os/env_windows.odin

@@ -8,7 +8,7 @@ import "base:runtime"
 // Otherwise the returned value will be empty and the boolean will be false
 // NOTE: the value will be allocated with the supplied allocator
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	if key == "" {
 		return
 	}
@@ -29,17 +29,54 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 	return
 }
 
+// This version of `lookup_env` doesn't allocate and instead requires the user to provide a buffer.
+// Note that it is limited to environment names and values of 512 utf-16 values each
+// due to the necessary utf-8 <> utf-16 conversion.
+@(require_results)
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	key_buf: [513]u16
+	wkey := win32.utf8_to_wstring(key_buf[:], key)
+	if wkey == nil {
+		return "", .Buffer_Full
+	}
+
+	n2 := win32.GetEnvironmentVariableW(wkey, nil, 0)
+	if n2 == 0 {
+		return "", .Env_Var_Not_Found
+	}
+
+	val_buf: [513]u16
+	n2 = win32.GetEnvironmentVariableW(wkey, raw_data(val_buf[:]), u32(len(val_buf[:])))
+	if n2 == 0 {
+		return "", .Env_Var_Not_Found
+	} else if int(n2) > len(buf) {
+		return "", .Buffer_Full
+	}
+
+	value = win32.utf16_to_utf8(buf, val_buf[:n2])
+
+	return value, nil
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
 
 // get_env retrieves the value of the environment variable named by the key
 // It returns the value, which will be empty if the variable is not present
 // To distinguish between an empty value and an unset value, use lookup_env
 // NOTE: the value will be allocated with the supplied allocator
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
+
 // set_env sets the value of the environment variable named by the key
 set_env :: proc(key, value: string) -> Error {
 	k := win32.utf8_to_wstring(key)

core/os/errors.odin

@@ -35,6 +35,9 @@ General_Error :: enum u32 {
 
 	File_Is_Pipe,
 	Not_Dir,
+
+	// Environment variable not found.
+	Env_Var_Not_Found,
 }
 
 
@@ -82,6 +85,7 @@ error_string :: proc "contextless" (ferr: Error) -> string {
 		case .Pattern_Has_Separator: return "pattern has separator"
 		case .File_Is_Pipe:      return "file is pipe"
 		case .Not_Dir:           return "file is not directory"
+		case .Env_Var_Not_Found: return "environment variable not found"
 		}
 	case io.Error:
 		switch e {

core/os/os.odin

@@ -4,6 +4,7 @@ import "base:intrinsics"
 import "base:runtime"
 import "core:io"
 import "core:strconv"
+import "core:strings"
 import "core:unicode/utf8"
 
 
@@ -57,7 +58,7 @@ write_encoded_rune :: proc(f: Handle, r: rune) -> (n: int, err: Error) {
 		if r < 32 {
 			if wrap(write_string(f, "\\x"), &n, &err) { return }
 			b: [2]byte
-			s := strconv.append_bits(b[:], u64(r), 16, true, 64, strconv.digits, nil)
+			s := strconv.write_bits(b[:], u64(r), 16, true, 64, strconv.digits, nil)
 			switch len(s) {
 			case 0: if wrap(write_string(f, "00"), &n, &err) { return }
 			case 1: if wrap(write_rune(f, '0'), &n, &err)    { return }
@@ -210,3 +211,55 @@ heap_free   :: runtime.heap_free
 processor_core_count :: proc() -> int {
 	return _processor_core_count()
 }
+
+// Always allocates for consistency.
+replace_environment_placeholders :: proc(path: string, allocator := context.allocator) -> (res: string) {
+	path := path
+
+	sb: strings.Builder
+	strings.builder_init_none(&sb, allocator)
+	for len(path) > 0 {
+		switch path[0] {
+		case '%': // Windows
+			when ODIN_OS == .Windows {
+				for r, i in path[1:] {
+					if r == '%' {
+						env_key := path[1:i+1]
+						env_val := get_env(env_key, context.temp_allocator)
+						strings.write_string(&sb, env_val)
+						path = path[i+1:] // % is part of key, so skip 1 character extra
+					}
+				}
+			} else {
+				strings.write_rune(&sb, rune(path[0]))
+			}
+
+		case '$': // Posix
+			when ODIN_OS != .Windows {
+				env_key := ""
+				dollar_loop: for r, i in path[1:] {
+					switch r {
+					case 'A'..='Z', 'a'..='z', '0'..='9', '_': // Part of key ident
+					case:
+						env_key = path[1:i+1]
+						break dollar_loop
+					}
+				}
+				if len(env_key) > 0 {
+					env_val := get_env(env_key, context.temp_allocator)
+					strings.write_string(&sb, env_val)
+					path = path[len(env_key):]
+				}
+
+			} else {
+				strings.write_rune(&sb, rune(path[0]))
+			}
+
+		case:
+			strings.write_rune(&sb, rune(path[0]))
+		}
+
+		path = path[1:]
+	}
+	return strings.to_string(sb)
+}

core/os/os2/env.odin

@@ -1,26 +1,49 @@
 package os2
 
 import "base:runtime"
+import "core:strings"
 
-// get_env retrieves the value of the environment variable named by the key
+// `get_env` retrieves the value of the environment variable named by the key
 // It returns the value, which will be empty if the variable is not present
 // To distinguish between an empty value and an unset value, use lookup_env
 // NOTE: the value will be allocated with the supplied allocator
 @(require_results)
-get_env :: proc(key: string, allocator: runtime.Allocator) -> string {
+get_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> string {
 	value, _ := lookup_env(key, allocator)
 	return value
 }
 
-// lookup_env gets the value of the environment variable named by the key
+// `get_env` retrieves the value of the environment variable named by the key
+// It returns the value, which will be empty if the variable is not present
+// To distinguish between an empty value and an unset value, use lookup_env
+// NOTE: this version takes a backing buffer for the string value
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> string {
+	value, _ := lookup_env(buf, key)
+	return value
+}
+
+get_env :: proc{get_env_alloc, get_env_buf}
+
+// `lookup_env` gets the value of the environment variable named by the key
 // If the variable is found in the environment the value (which can be empty) is returned and the boolean is true
 // Otherwise the returned value will be empty and the boolean will be false
 // NOTE: the value will be allocated with the supplied allocator
 @(require_results)
-lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
-	return _lookup_env(key, allocator)
+lookup_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
+	return _lookup_env_alloc(key, allocator)
 }
 
+// This version of `lookup_env` doesn't allocate and instead requires the user to provide a buffer.
+// Note that it is limited to environment names and values of 512 utf-16 values each
+// due to the necessary utf-8 <> utf-16 conversion.
+@(require_results)
+lookup_env_buf :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	return _lookup_env_buf(buf, key)
+}
+
+lookup_env :: proc{lookup_env_alloc, lookup_env_buf}
+
 // set_env sets the value of the environment variable named by the key
 // Returns Error on failure
 set_env :: proc(key, value: string) -> Error {
@@ -45,4 +68,55 @@ environ :: proc(allocator: runtime.Allocator) -> ([]string, Error) {
 	return _environ(allocator)
 }
 
+// Always allocates for consistency.
+replace_environment_placeholders :: proc(path: string, allocator: runtime.Allocator) -> (res: string) {
+	path := path
 
+	sb: strings.Builder
+	strings.builder_init_none(&sb, allocator)
+
+	for len(path) > 0 {
+		switch path[0] {
+		case '%': // Windows
+			when ODIN_OS == .Windows {
+				for r, i in path[1:] {
+					if r == '%' {
+						env_key := path[1:i+1]
+						env_val := get_env(env_key, context.temp_allocator)
+						strings.write_string(&sb, env_val)
+						path = path[i+1:] // % is part of key, so skip 1 character extra
+					}
+				}
+			} else {
+				strings.write_rune(&sb, rune(path[0]))
+			}
+
+		case '$': // Posix
+			when ODIN_OS != .Windows {
+				env_key := ""
+				dollar_loop: for r, i in path[1:] {
+					switch r {
+					case 'A'..='Z', 'a'..='z', '0'..='9', '_': // Part of key ident
+					case:
+						env_key = path[1:i+1]
+						break dollar_loop
+					}
+				}
+				if len(env_key) > 0 {
+					env_val := get_env(env_key, context.temp_allocator)
+					strings.write_string(&sb, env_val)
+					path = path[len(env_key):]
+				}
+
+			} else {
+				strings.write_rune(&sb, rune(path[0]))
+			}
+
+		case:
+			strings.write_rune(&sb, rune(path[0]))
+		}
+
+		path = path[1:]
+	}
+	return strings.to_string(sb)
+}

core/os/os2/env_linux.odin

@@ -41,7 +41,7 @@ _lookup :: proc(key: string) -> (value: string, idx: int) {
 	return "", -1
 }
 
-_lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
+_lookup_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
 	if intrinsics.atomic_load_explicit(&_org_env_begin, .Acquire) == 0 {
 		_build_env()
 	}
@@ -53,6 +53,23 @@ _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string
 	return
 }
 
+_lookup_env_buf :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if intrinsics.atomic_load_explicit(&_org_env_begin, .Acquire) == 0 {
+		_build_env()
+	}
+
+	if v, idx := _lookup(key); idx != -1 {
+		if len(buf) >= len(v) {
+			copy(buf, v)
+			return string(buf[:len(v)]), nil
+		}
+		return "", .Buffer_Full
+	}
+	return "", .Env_Var_Not_Found
+}
+
+_lookup_env :: proc{_lookup_env_alloc, _lookup_env_buf}
+
 _set_env :: proc(key, v_new: string) -> Error {
 	if intrinsics.atomic_load_explicit(&_org_env_begin, .Acquire) == 0 {
 		_build_env()

core/os/os2/env_posix.odin

@@ -7,7 +7,7 @@ import "base:runtime"
 import "core:strings"
 import "core:sys/posix"
 
-_lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
+_lookup_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
 	if key == "" {
 		return
 	}
@@ -26,6 +26,36 @@ _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string
 	return
 }
 
+_lookup_env_buf :: proc(buf: []u8, key: string) -> (value: string, error: Error) {
+	if key == "" {
+		return
+	}
+
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	cval := posix.getenv(cstring(raw_data(buf)))
+	if cval == nil {
+		return
+	}
+
+	if value = string(cval); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+
+_lookup_env :: proc{_lookup_env_alloc, _lookup_env_buf}
+
 _set_env :: proc(key, value: string) -> (err: Error) {
 	temp_allocator := TEMP_ALLOCATOR_GUARD({})
 

core/os/os2/env_wasi.odin

@@ -67,7 +67,7 @@ delete_string_if_not_original :: proc(str: string) {
 }
 
 @(require_results)
-_lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
+_lookup_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
 	if err := build_env(); err != nil {
 		return
 	}
@@ -79,6 +79,34 @@ _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string
 	return
 }
 
+_lookup_env_buf :: proc(buf: []u8, key: string) -> (value: string, error: Error) {
+	if key == "" {
+		return
+	}
+
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	sync.shared_guard(&g_env_mutex)
+
+	val, ok := g_env[key]
+
+	if !ok {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(val) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, val)
+			return string(buf[:len(val)]), nil
+		}
+	}
+}
+_lookup_env :: proc{_lookup_env_alloc, _lookup_env_buf}
+
 @(require_results)
 _set_env :: proc(key, value: string) -> (err: Error) {
 	build_env() or_return

core/os/os2/env_windows.odin

@@ -4,7 +4,7 @@ package os2
 import win32 "core:sys/windows"
 import "base:runtime"
 
-_lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
+_lookup_env_alloc :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
 	if key == "" {
 		return
 	}
@@ -36,6 +36,36 @@ _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string
 	return
 }
 
+// This version of `lookup_env` doesn't allocate and instead requires the user to provide a buffer.
+// Note that it is limited to environment names and values of 512 utf-16 values each
+// due to the necessary utf-8 <> utf-16 conversion.
+@(require_results)
+_lookup_env_buf :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	key_buf: [513]u16
+	wkey := win32.utf8_to_wstring(key_buf[:], key)
+	if wkey == nil {
+		return "", .Buffer_Full
+	}
+
+	n2 := win32.GetEnvironmentVariableW(wkey, nil, 0)
+	if n2 == 0 {
+		return "", .Env_Var_Not_Found
+	}
+
+	val_buf: [513]u16
+	n2 = win32.GetEnvironmentVariableW(wkey, raw_data(val_buf[:]), u32(len(val_buf[:])))
+	if n2 == 0 {
+		return "", .Env_Var_Not_Found
+	} else if int(n2) > len(buf) {
+		return "", .Buffer_Full
+	}
+
+	value = win32.utf16_to_utf8(buf, val_buf[:n2])
+
+	return value, nil
+}
+_lookup_env :: proc{_lookup_env_alloc, _lookup_env_buf}
+
 _set_env :: proc(key, value: string) -> Error {
 	temp_allocator := TEMP_ALLOCATOR_GUARD({})
 	k := win32_utf8_to_wstring(key,   temp_allocator) or_return

core/os/os2/errors.odin

@@ -27,6 +27,9 @@ General_Error :: enum u32 {
 
 	Pattern_Has_Separator,
 
+	No_HOME_Variable,
+	Env_Var_Not_Found,
+
 	Unsupported,
 }
 
@@ -59,20 +62,22 @@ error_string :: proc(ferr: Error) -> string {
 	case General_Error:
 		switch e {
 		case .None: return ""
-		case .Permission_Denied: return "permission denied"
-		case .Exist:             return "file already exists"
-		case .Not_Exist:         return "file does not exist"
-		case .Closed:            return "file already closed"
-		case .Timeout:           return "i/o timeout"
-		case .Broken_Pipe:       return "Broken pipe"
-		case .No_Size:           return "file has no definite size"
-		case .Invalid_File:      return "invalid file"
-		case .Invalid_Dir:       return "invalid directory"
-		case .Invalid_Path:      return "invalid path"
-		case .Invalid_Callback:  return "invalid callback"
-		case .Invalid_Command:   return "invalid command"
-		case .Unsupported:       return "unsupported"
-		case .Pattern_Has_Separator: return "pattern has separator"
+		case .Permission_Denied:      return "permission denied"
+		case .Exist:                  return "file already exists"
+		case .Not_Exist:              return "file does not exist"
+		case .Closed:                 return "file already closed"
+		case .Timeout:                return "i/o timeout"
+		case .Broken_Pipe:            return "Broken pipe"
+		case .No_Size:                return "file has no definite size"
+		case .Invalid_File:           return "invalid file"
+		case .Invalid_Dir:            return "invalid directory"
+		case .Invalid_Path:           return "invalid path"
+		case .Invalid_Callback:       return "invalid callback"
+		case .Invalid_Command:        return "invalid command"
+		case .Unsupported:            return "unsupported"
+		case .Pattern_Has_Separator:  return "pattern has separator"
+		case .No_HOME_Variable:       return "no $HOME variable"
+		case .Env_Var_Not_Found:      return "environment variable not found"
 		}
 	case io.Error:
 		switch e {

core/os/os2/file_linux.odin

@@ -269,6 +269,7 @@ _write_at :: proc(f: ^File_Impl, p: []byte, offset: i64) -> (nt: i64, err: Error
 	return
 }
 
+@(no_sanitize_memory)
 _file_size :: proc(f: ^File_Impl) -> (n: i64, err: Error) {
 	// TODO: Identify 0-sized "pseudo" files and return No_Size. This would
 	//       eliminate the need for the _read_entire_pseudo_file procs.

core/os/os2/file_util.odin

@@ -59,7 +59,7 @@ write_encoded_rune :: proc(f: ^File, r: rune) -> (n: int, err: Error) {
 		if r < 32 {
 			if wrap(write_string(f, "\\x"), &n, &err) { return }
 			b: [2]byte
-			s := strconv.append_bits(b[:], u64(r), 16, true, 64, strconv.digits, nil)
+			s := strconv.write_bits(b[:], u64(r), 16, true, 64, strconv.digits, nil)
 			switch len(s) {
 			case 0: if wrap(write_string(f, "00"), &n, &err) { return }
 			case 1: if wrap(write_rune(f, '0'), &n, &err)    { return }

core/os/os2/user.odin

@@ -2,78 +2,148 @@ package os2
 
 import "base:runtime"
 
-@(require_results)
-user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
-	temp_allocator := TEMP_ALLOCATOR_GUARD({ allocator })
-
-	#partial switch ODIN_OS {
-	case .Windows:
-		dir = get_env("LocalAppData", temp_allocator)
-		if dir != "" {
-			dir = clone_string(dir, temp_allocator) or_return
-		}
-	case .Darwin:
-		dir = get_env("HOME", temp_allocator)
-		if dir != "" {
-			dir = concatenate({dir, "/Library/Caches"}, temp_allocator) or_return
-		}
-	case: // All other UNIX systems
-		dir = get_env("XDG_CACHE_HOME", allocator)
-		if dir == "" {
-			dir = get_env("HOME", temp_allocator)
-			if dir == "" {
-				return
-			}
-			dir = concatenate({dir, "/.cache"}, temp_allocator) or_return
-		}
-	}
-	if dir == "" {
-		err = .Invalid_Path
-	}
-	return
-}
-
-@(require_results)
-user_config_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
-	temp_allocator := TEMP_ALLOCATOR_GUARD({ allocator })
-
-	#partial switch ODIN_OS {
-	case .Windows:
-		dir = get_env("AppData", temp_allocator)
-		if dir != "" {
-			dir = clone_string(dir, allocator) or_return
-		}
-	case .Darwin:
-		dir = get_env("HOME", temp_allocator)
-		if dir != "" {
-			dir = concatenate({dir, "/.config"}, allocator) or_return
-		}
-	case: // All other UNIX systems
-		dir = get_env("XDG_CONFIG_HOME", allocator)
-		if dir == "" {
-			dir = get_env("HOME", temp_allocator)
-			if dir == "" {
-				return
-			}
-			dir = concatenate({dir, "/.config"}, allocator) or_return
-		}
-	}
-	if dir == "" {
-		err = .Invalid_Path
-	}
-	return
-}
-
+// ```
+// Windows:  C:\Users\Alice
+// macOS:    /Users/Alice
+// Linux:    /home/alice
+// ```
 @(require_results)
 user_home_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
-	env := "HOME"
-	#partial switch ODIN_OS {
-	case .Windows:
-		env = "USERPROFILE"
-	}
-	if v := get_env(env, allocator); v != "" {
-		return v, nil
-	}
-	return "", .Invalid_Path
+	return _user_home_dir(allocator)
 }
 
+// Files that applications can regenerate/refetch at a loss of speed, e.g. shader caches
+//
+// Sometimes deleted for system maintenance
+//
+// ```
+// Windows:  C:\Users\Alice\AppData\Local
+// macOS:    /Users/Alice/Library/Caches
+// Linux:    /home/alice/.cache
+// ```
+@(require_results)
+user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_cache_dir(allocator)
+}
+
+// User-hidden application data
+//
+// ```
+// Windows:  C:\Users\Alice\AppData\Local ("C:\Users\Alice\AppData\Roaming" if `roaming`)
+// macOS:    /Users/Alice/Library/Application Support
+// Linux:    /home/alice/.local/share
+// ```
+//
+// NOTE: (Windows only) `roaming` is for syncing across multiple devices within a *domain network*
+@(require_results)
+user_data_dir :: proc(allocator: runtime.Allocator, roaming := false) -> (dir: string, err: Error) {
+	return _user_data_dir(allocator, roaming)
+}
+
+// Non-essential application data, e.g. history, ui layout state
+//
+// ```
+// Windows:  C:\Users\Alice\AppData\Local
+// macOS:    /Users/Alice/Library/Application Support
+// Linux:    /home/alice/.local/state
+// ```
+@(require_results)
+user_state_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_state_dir(allocator)
+}
+
+// Application log files
+//
+// ```
+// Windows:  C:\Users\Alice\AppData\Local
+// macOS:    /Users/Alice/Library/Logs
+// Linux:    /home/alice/.local/state
+// ```
+@(require_results)
+user_log_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_log_dir(allocator)
+}
+
+// Application settings/preferences
+//
+// ```
+// Windows:  C:\Users\Alice\AppData\Local ("C:\Users\Alice\AppData\Roaming" if `roaming`)
+// macOS:    /Users/Alice/Library/Application Support
+// Linux:    /home/alice/.config
+// ```
+//
+// NOTE: (Windows only) `roaming` is for syncing across multiple devices within a *domain network*
+@(require_results)
+user_config_dir :: proc(allocator: runtime.Allocator, roaming := false) -> (dir: string, err: Error) {
+	return _user_config_dir(allocator, roaming)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Music
+// macOS:    /Users/Alice/Music
+// Linux:    /home/alice/Music
+// ```
+@(require_results)
+user_music_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_music_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Desktop
+// macOS:    /Users/Alice/Desktop
+// Linux:    /home/alice/Desktop
+// ```
+@(require_results)
+user_desktop_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_desktop_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Documents
+// macOS:    /Users/Alice/Documents
+// Linux:    /home/alice/Documents
+// ```
+@(require_results)
+user_documents_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_documents_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Downloads
+// macOS:    /Users/Alice/Downloads
+// Linux:    /home/alice/Downloads
+// ```
+@(require_results)
+user_downloads_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_downloads_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Pictures
+// macOS:    /Users/Alice/Pictures
+// Linux:    /home/alice/Pictures
+// ```
+@(require_results)
+user_pictures_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_pictures_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Public
+// macOS:    /Users/Alice/Public
+// Linux:    /home/alice/Public
+// ```
+@(require_results)
+user_public_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_public_dir(allocator)
+}
+
+// ```
+// Windows:  C:\Users\Alice\Videos
+// macOS:    /Users/Alice/Movies
+// Linux:    /home/alice/Videos
+// ```
+@(require_results)
+user_videos_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	return _user_videos_dir(allocator)
+}

core/os/os2/user_posix.odin

@@ -0,0 +1,175 @@
+#+build !windows
+package os2
+
+import "base:runtime"
+import "core:encoding/ini"
+import "core:strings"
+
+_user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Library/Caches", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_CACHE_HOME", "/.cache", allocator)
+	}
+}
+
+_user_config_dir :: proc(allocator: runtime.Allocator, _roaming: bool) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Library/Application Support", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_CONFIG_HOME", "/.config", allocator)
+	}
+}
+
+_user_state_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Library/Application Support", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_STATE_HOME", "/.local/state", allocator)
+	}
+}
+
+_user_log_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Library/Logs", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_STATE_HOME", "/.local/state", allocator)
+	}
+}
+
+_user_data_dir :: proc(allocator: runtime.Allocator, _roaming: bool) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Library/Application Support", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_DATA_HOME", "/.local/share", allocator)
+	}
+}
+
+_user_music_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Music", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_MUSIC_DIR", "/Music", allocator)
+	}
+}
+
+_user_desktop_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Desktop", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_DESKTOP_DIR", "/Desktop", allocator)
+	}
+}
+
+_user_documents_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Documents", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_DOCUMENTS_DIR", "/Documents", allocator)
+	}
+}
+
+_user_downloads_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Downloads", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_DOWNLOAD_DIR", "/Downloads", allocator)
+	}
+}
+
+_user_pictures_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Pictures", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_PICTURES_DIR", "/Pictures", allocator)
+	}
+}
+
+_user_public_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Public", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_PUBLICSHARE_DIR", "/Public", allocator)
+	}
+}
+
+_user_videos_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	#partial switch ODIN_OS {
+	case .Darwin:
+		return _xdg_lookup("", "/Movies", allocator)
+	case: // Unix
+		return _xdg_lookup("XDG_VIDEOS_DIR", "/Videos", allocator)
+	}
+}
+
+_user_home_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	if v := get_env("HOME", allocator); v != "" {
+		return v, nil
+	}
+	err = .No_HOME_Variable
+	return
+}
+
+_xdg_lookup :: proc(xdg_key: string, fallback_suffix: string, allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	temp_allocator  := TEMP_ALLOCATOR_GUARD({ allocator })
+
+	if xdg_key == "" { // Darwin doesn't have XDG paths.
+		dir = get_env("HOME", temp_allocator)
+		if dir == "" {
+			err = .No_HOME_Variable
+			return
+		}
+		return concatenate({dir, fallback_suffix}, allocator)
+	} else {
+		if strings.ends_with(xdg_key, "_DIR") {
+			dir = _xdg_user_dirs_lookup(xdg_key, allocator) or_return
+		} else {
+			dir = get_env(xdg_key, allocator)
+		}
+
+		if dir == "" {
+			dir = get_env("HOME", temp_allocator)
+			if dir == "" {
+				err = .No_HOME_Variable
+				return
+			}
+			dir = concatenate({dir, fallback_suffix}, allocator) or_return
+		}
+		return
+	}
+}
+
+// If `<config-dir>/user-dirs.dirs` doesn't exist, or `xdg_key` can't be found there: returns `""`
+_xdg_user_dirs_lookup :: proc(xdg_key: string, allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	temp_allocator  := TEMP_ALLOCATOR_GUARD({ allocator })
+	config_dir      := user_config_dir(temp_allocator) or_return
+	user_dirs_path  := concatenate({config_dir, "/user-dirs.dirs"}, temp_allocator) or_return
+	content         := read_entire_file(user_dirs_path, temp_allocator) or_return
+
+	it := ini.Iterator{
+		section = "",
+		_src    = string(content),
+		options = ini.Options{
+			comment        = "#",
+			key_lower_case = false,
+		},
+	}
+
+	for k, v in ini.iterate(&it) {
+		if k == xdg_key {
+			return replace_environment_placeholders(v, allocator), nil
+		}
+	}
+	return
+}

core/os/os2/user_windows.odin

@@ -0,0 +1,79 @@
+package os2
+
+import "base:runtime"
+@(require) import win32 "core:sys/windows"
+
+_local_appdata :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_LocalAppData
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_local_appdata_or_roaming :: proc(allocator: runtime.Allocator, roaming: bool) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_LocalAppData
+	if roaming {
+		guid = win32.FOLDERID_RoamingAppData
+	}
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_config_dir :: _local_appdata_or_roaming
+_user_data_dir :: _local_appdata_or_roaming
+
+_user_state_dir :: _local_appdata
+_user_log_dir :: _local_appdata
+_user_cache_dir :: _local_appdata
+
+_user_home_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Profile
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_music_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Music
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_desktop_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Desktop
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_documents_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Documents
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_downloads_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Downloads
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_pictures_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Pictures
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_public_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Public
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_user_videos_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	guid := win32.FOLDERID_Videos
+	return _get_known_folder_path(&guid, allocator)
+}
+
+_get_known_folder_path :: proc(rfid: win32.REFKNOWNFOLDERID, allocator: runtime.Allocator) -> (dir: string, err: Error) {
+	// https://learn.microsoft.com/en-us/windows/win32/api/shlobj_core/nf-shlobj_core-shgetknownfolderpath
+	// See also `known_folders.odin` in `core:sys/windows` for the GUIDs.
+	path_w: win32.LPWSTR
+	res  := win32.SHGetKnownFolderPath(rfid, 0, nil, &path_w)
+	defer win32.CoTaskMemFree(path_w)
+
+	if res != 0 {
+		return "", .Invalid_Path
+	}
+
+	dir, _ = win32.wstring_to_utf8(path_w, -1, allocator)
+	return
+}

core/os/os_darwin.odin

@@ -1055,9 +1055,10 @@ flush :: proc(fd: Handle) -> Error {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
+	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
 	cstr := _unix_getenv(path_str)
 	if cstr == nil {
 		return "", false
@@ -1066,11 +1067,39 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
 set_env :: proc(key, value: string) -> Error {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	key_cstring := strings.clone_to_cstring(key, context.temp_allocator)
@@ -1196,7 +1225,7 @@ _processor_core_count :: proc() -> int {
 	return 1
 }
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for _, i in res {
@@ -1205,6 +1234,11 @@ _alloc_command_line_arguments :: proc() -> []string {
 	return res
 }
 
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}
+
 socket :: proc(domain: int, type: int, protocol: int) -> (Socket, Error) {
 	result := _unix_socket(c.int(domain), c.int(type), c.int(protocol))
 	if result < 0 {

core/os/os_freebsd.odin

@@ -662,7 +662,7 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Error) {
 	return File_Time(modified), nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _stat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -674,7 +674,7 @@ _stat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -688,7 +688,7 @@ _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _fstat :: proc(fd: Handle) -> (OS_Stat, Error) {
 	s: OS_Stat = ---
 	result := _unix_fstat(fd, &s)
@@ -827,10 +827,10 @@ access :: proc(path: string, mask: int) -> (bool, Error) {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
-
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
+	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
 	cstr := _unix_getenv(path_str)
 	if cstr == nil {
 		return "", false
@@ -839,11 +839,39 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
 @(require_results)
 get_current_directory :: proc(allocator := context.allocator) -> string {
 	context.allocator = allocator
@@ -936,7 +964,7 @@ _processor_core_count :: proc() -> int {
 }
 
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for arg, i in runtime.args__ {
@@ -944,3 +972,8 @@ _alloc_command_line_arguments :: proc() -> []string {
 	}
 	return res
 }
+
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}

core/os/os_haiku.odin

@@ -316,7 +316,7 @@ file_size :: proc(fd: Handle) -> (i64, Error) {
 // "Argv" arguments converted to Odin strings
 args := _alloc_command_line_arguments()
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for arg, i in runtime.args__ {
@@ -325,7 +325,12 @@ _alloc_command_line_arguments :: proc() -> []string {
 	return res
 }
 
-@(private, require_results)
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}
+
+@(private, require_results, no_sanitize_memory)
 _stat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -339,7 +344,7 @@ _stat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -353,7 +358,7 @@ _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _fstat :: proc(fd: Handle) -> (OS_Stat, Error) {
 	// deliberately uninitialized
 	s: OS_Stat = ---
@@ -463,9 +468,10 @@ access :: proc(path: string, mask: int) -> (bool, Error) {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
+	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
 	cstr := _unix_getenv(path_str)
 	if cstr == nil {
 		return "", false
@@ -474,11 +480,40 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
+
 @(private, require_results)
 _processor_core_count :: proc() -> int {
 	info: haiku.system_info

core/os/os_js.odin

@@ -249,3 +249,27 @@ exit :: proc "contextless" (code: int) -> ! {
 current_thread_id :: proc "contextless" () -> int {
 	return 0
 }
+
+@(require_results)
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+	return "", false
+}
+
+@(require_results)
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	return "", .Env_Var_Not_Found
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
+	value, _ = lookup_env(key, allocator)
+	return
+}
+
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}

core/os/os_linux.odin

@@ -674,7 +674,7 @@ seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Error) {
 	return i64(res), nil
 }
 
-@(require_results)
+@(require_results, no_sanitize_memory)
 file_size :: proc(fd: Handle) -> (i64, Error) {
 	// deliberately uninitialized; the syscall fills this buffer for us
 	s: OS_Stat = ---
@@ -794,7 +794,7 @@ last_write_time_by_name :: proc(name: string) -> (time: File_Time, err: Error) {
 	return File_Time(modified), nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _stat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -808,7 +808,7 @@ _stat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -822,7 +822,7 @@ _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _fstat :: proc(fd: Handle) -> (OS_Stat, Error) {
 	// deliberately uninitialized; the syscall fills this buffer for us
 	s: OS_Stat = ---
@@ -946,7 +946,7 @@ access :: proc(path: string, mask: int) -> (bool, Error) {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
 	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
@@ -958,11 +958,39 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
 set_env :: proc(key, value: string) -> Error {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	key_cstring := strings.clone_to_cstring(key, context.temp_allocator)
@@ -1069,7 +1097,7 @@ _processor_core_count :: proc() -> int {
 	return int(_unix_get_nprocs())
 }
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for arg, i in runtime.args__ {
@@ -1078,6 +1106,11 @@ _alloc_command_line_arguments :: proc() -> []string {
 	return res
 }
 
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}
+
 @(require_results)
 socket :: proc(domain: int, type: int, protocol: int) -> (Socket, Error) {
 	result := unix.sys_socket(domain, type, protocol)

core/os/os_netbsd.odin

@@ -724,7 +724,7 @@ last_write_time_by_name :: proc(name: string) -> (time: File_Time, err: Error) {
 	return File_Time(modified), nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _stat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -736,7 +736,7 @@ _stat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -750,7 +750,7 @@ _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _fstat :: proc(fd: Handle) -> (OS_Stat, Error) {
 	s: OS_Stat = ---
 	result := _unix_fstat(fd, &s)
@@ -874,10 +874,10 @@ access :: proc(path: string, mask: int) -> (bool, Error) {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
-
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
+	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
 	cstr := _unix_getenv(path_str)
 	if cstr == nil {
 		return "", false
@@ -886,11 +886,39 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
 @(require_results)
 get_current_directory :: proc(allocator := context.allocator) -> string {
 	context.allocator = allocator
@@ -986,7 +1014,7 @@ _processor_core_count :: proc() -> int {
 	return 1
 }
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for arg, i in runtime.args__ {
@@ -994,3 +1022,8 @@ _alloc_command_line_arguments :: proc() -> []string {
 	}
 	return res
 }
+
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}

core/os/os_openbsd.odin

@@ -639,7 +639,7 @@ last_write_time_by_name :: proc(name: string) -> (time: File_Time, err: Error) {
 	return File_Time(modified), nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _stat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -653,7 +653,7 @@ _stat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
 	cstr := strings.clone_to_cstring(path, context.temp_allocator)
@@ -667,7 +667,7 @@ _lstat :: proc(path: string) -> (OS_Stat, Error) {
 	return s, nil
 }
 
-@(private, require_results)
+@(private, require_results, no_sanitize_memory)
 _fstat :: proc(fd: Handle) -> (OS_Stat, Error) {
 	// deliberately uninitialized
 	s: OS_Stat = ---
@@ -787,9 +787,10 @@ access :: proc(path: string, mask: int) -> (bool, Error) {
 }
 
 @(require_results)
-lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)
+	// NOTE(tetra): Lifetime of 'cstr' is unclear, but _unix_free(cstr) segfaults.
 	cstr := _unix_getenv(path_str)
 	if cstr == nil {
 		return "", false
@@ -798,11 +799,39 @@ lookup_env :: proc(key: string, allocator := context.allocator) -> (value: strin
 }
 
 @(require_results)
-get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	if len(key) + 1 > len(buf) {
+		return "", .Buffer_Full
+	} else {
+		copy(buf, key)
+	}
+
+	if value = string(_unix_getenv(cstring(raw_data(buf)))); value == "" {
+		return "", .Env_Var_Not_Found
+	} else {
+		if len(value) > len(buf) {
+			return "", .Buffer_Full
+		} else {
+			copy(buf, value)
+			return string(buf[:len(value)]), nil
+		}
+	}
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
 	value, _ = lookup_env(key, allocator)
 	return
 }
 
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}
+
 @(require_results)
 get_current_directory :: proc(allocator := context.allocator) -> string {
 	context.allocator = allocator
@@ -885,7 +914,7 @@ _processor_core_count :: proc() -> int {
 	return int(_sysconf(_SC_NPROCESSORS_ONLN))
 }
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	res := make([]string, len(runtime.args__))
 	for arg, i in runtime.args__ {
@@ -893,3 +922,8 @@ _alloc_command_line_arguments :: proc() -> []string {
 	}
 	return res
 }
+
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}

core/os/os_wasi.odin

@@ -27,7 +27,7 @@ stderr: Handle = 2
 
 args := _alloc_command_line_arguments()
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> (args: []string) {
 	args = make([]string, len(runtime.args__))
 	for &arg, i in args {
@@ -36,6 +36,11 @@ _alloc_command_line_arguments :: proc() -> (args: []string) {
 	return
 }
 
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	delete(args)
+}
+
 // WASI works with "preopened" directories, the environment retrieves directories
 // (for example with `wasmtime --dir=. module.wasm`) and those given directories
 // are the only ones accessible by the application.
@@ -239,3 +244,27 @@ exit :: proc "contextless" (code: int) -> ! {
 	runtime._cleanup_runtime_contextless()
 	wasi.proc_exit(wasi.exitcode_t(code))
 }
+
+@(require_results)
+lookup_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
+	return "", false
+}
+
+@(require_results)
+lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {
+	return "", .Env_Var_Not_Found
+}
+lookup_env :: proc{lookup_env_alloc, lookup_env_buffer}
+
+@(require_results)
+get_env_alloc :: proc(key: string, allocator := context.allocator) -> (value: string) {
+	value, _ = lookup_env(key, allocator)
+	return
+}
+
+@(require_results)
+get_env_buf :: proc(buf: []u8, key: string) -> (value: string) {
+	value, _ = lookup_env(buf, key)
+	return
+}
+get_env :: proc{get_env_alloc, get_env_buf}

core/os/os_windows.odin

@@ -193,7 +193,7 @@ current_thread_id :: proc "contextless" () -> int {
 
 
 
-@(require_results)
+@(private, require_results)
 _alloc_command_line_arguments :: proc() -> []string {
 	arg_count: i32
 	arg_list_ptr := win32.CommandLineToArgvW(win32.GetCommandLineW(), &arg_count)
@@ -215,6 +215,14 @@ _alloc_command_line_arguments :: proc() -> []string {
 	return arg_list
 }
 
+@(private, fini)
+_delete_command_line_arguments :: proc() {
+	for s in args {
+		delete(s)
+	}
+	delete(args)
+}
+
 /*
 	Windows 11 (preview) has the same major and minor version numbers
 	as Windows 10: 10 and 0 respectively.