Crate ergonomic_windows 

Ergonomic Windows

Ergonomic wrappers around Windows APIs for Rust.

This crate provides safe, idiomatic Rust interfaces to common Windows functionality:

• Error Handling: Rich error types with Windows error code support
• Handle Management: RAII wrappers for Windows handles
• String Utilities: Easy conversion between Rust and Windows strings
• Process Management: Create, manage, and query Windows processes
• File System: Windows-specific file operations
• Registry: Read and write Windows Registry keys
• Windows: Create windows and handle messages
• Threading: Threads, mutexes, events, semaphores
• Memory: Virtual memory, heaps, memory info
• Console: Console I/O, colors, cursor control
• Environment: Environment variables
• Pipes: Anonymous and named pipes for IPC
• Time: High-resolution timers, system time
• Modules: Dynamic library (DLL) loading
• System Info: OS version, hardware info
• Security: Tokens, privileges, elevation
• Controls: Win32 common controls (buttons, edit, listbox, etc.)
• Direct2D: Hardware-accelerated 2D graphics and text
• WebView2: Chromium-based web browser control (requires feature)
• XAML: WinRT XAML UI types and XAML Islands support

Quick Start

use ergonomic_windows::process::Command;
use ergonomic_windows::registry::{Key, RootKey, Access};

// Spawn a process
let process = Command::new("notepad.exe")
    .arg("file.txt")
    .spawn()?;

// Read from the registry
let key = Key::open(
    RootKey::CURRENT_USER,
    r"Software\Microsoft\Windows\CurrentVersion",
    Access::READ,
)?;
let value = key.get_value("ProgramFilesDir")?;

Feature Highlights

RAII Handle Management

Windows handles are automatically closed when dropped:

use ergonomic_windows::handle::OwnedHandle;

{
    let handle = OwnedHandle::new(some_raw_handle)?;
    // Use the handle...
} // Handle is automatically closed here

Easy String Conversion

Convert between Rust and Windows strings effortlessly:

use ergonomic_windows::string::{to_wide, from_wide, WideString};

// To wide string
let wide = to_wide("Hello, Windows!");

// From wide string
let back = from_wide(&wide).unwrap();

// For Windows APIs
let ws = WideString::new("Hello");
// use ws.as_pcwstr() with Windows APIs

Process Management

Create and manage processes with a fluent API:

use ergonomic_windows::process::Command;

// Run a command and wait for completion
let exit_code = Command::new("cmd.exe")
    .args(["/c", "echo", "Hello"])
    .no_window()
    .run()?;

Registry Access

Read and write registry values with type safety:

use ergonomic_windows::registry::{Key, RootKey, Access, Value};

// Write a value
let key = Key::create(RootKey::CURRENT_USER, r"Software\MyApp", Access::ALL)?;
key.set_value("Setting", &Value::dword(42))?;

// Read it back
let value = key.get_value("Setting")?;
assert_eq!(value.as_dword(), Some(42));

Threading and Synchronization

use ergonomic_windows::thread::{Thread, Mutex, Event};
use std::sync::Arc;

// Spawn a thread
let thread = Thread::spawn(|| {
    println!("Hello from thread!");
    42
})?;
let exit_code = thread.join()?;

// Use a mutex
let mutex = Mutex::new(false)?;
{
    let _guard = mutex.lock()?;
    // Protected region
}

// Use an event for signaling
let event = Event::new_manual(false)?;
event.set()?; // Signal
event.wait()?; // Wait for signal

System Information

use ergonomic_windows::sysinfo::{system_summary, OsVersion};
use ergonomic_windows::security::is_elevated;

let summary = system_summary()?;
println!("OS: {}", summary.os_version);
println!("CPUs: {}", summary.processor.processor_count);
println!("Memory: {} MB", summary.memory.total_physical / 1024 / 1024);
println!("Elevated: {}", is_elevated()?);