# How SharpEmu Integrates with the Windows Host Platform: Native API Implementation

> Discover how SharpEmu integrates with Windows by implementing native APIs like Registry queries and exception handling for high-performance Xbox 360 emulation.

- Repository: [Berk/sharpemu](https://github.com/par274/sharpemu)
- Tags: internals
- Published: 2026-07-16

---

**SharpEmu leverages Windows-specific APIs including Registry queries, Thread-Local Storage, Vectored Exception Handling, and Virtual Memory management to enable high-performance Xbox 360 emulation on Windows hosts.**

SharpEmu is a cross-platform Xbox 360 emulator written in C# that implements deep **Windows host platform integration** through P/Invoke calls to native system libraries. When running on Windows, the emulator activates platform-specific code paths in [`SharpEmu.Core/Runtime/SharpEmuRuntime.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.Core/Runtime/SharpEmuRuntime.cs) that handle hardware detection, JIT compilation support, and resource management while maintaining portability for Linux and macOS targets.

## Hardware Detection and System Enumeration

SharpEmu queries the host Windows system for diagnostic logging and compatibility checks by accessing the Windows Registry and native APIs.

### CPU and Memory Detection via Registry

In [`SharpEmu.Logging/HostSystemInfo.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.Logging/HostSystemInfo.cs), the emulator retrieves CPU identification by reading the Windows Registry key `HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0`. For system memory statistics, it calls **GlobalMemoryStatusEx** from *kernel32.dll* to determine total RAM available on the host.

```csharp
// Produces something like:
// "Host hardware: CPU: 12th Gen Intel(R) Core(TM) i7-12700K; GPU: NVIDIA GeForce RTX 3080; RAM: 32,768 MB (32.0 GB)."
string hardwareInfo = SharpEmu.Logging.HostSystemInfo.Summary;
Console.WriteLine(hardwareInfo);

```

### Graphics Adapter Enumeration

The same [`HostSystemInfo.cs`](https://github.com/par274/sharpemu/blob/main/HostSystemInfo.cs) file uses **EnumDisplayDevices** from *user32.dll* to enumerate installed graphics adapters and retrieve GPU names. This allows SharpEmu to log the exact graphics hardware present when generating diagnostic reports.

## JIT Backend Integration and Exception Handling

The direct-execution JIT compiler requires low-level Windows services to manage per-thread state and handle runtime faults generated by emulated guest code.

### Thread-Local Storage for the Direct Execution Backend

In [`SharpEmu.Core/Cpu/Native/DirectExecutionBackend.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.Core/Cpu/Native/DirectExecutionBackend.cs), SharpEmu manages thread-local storage using the Windows TLS API. It imports **TlsAlloc**, **TlsFree**, **TlsSetValue**, and **TlsGetValue** from *kernel32.dll* to store per-thread JIT state without interfering with other threads.

### Vectored Exception Handling for Guest Code

To catch access violations and other faults generated by JIT-compiled guest code, SharpEmu sets up a vectored exception handler by importing **AddVectoredExceptionHandler**, **RemoveVectoredExceptionHandler**, and **SetUnhandledExceptionFilter** from *kernel32.dll*. This mechanism, also implemented in [`DirectExecutionBackend.cs`](https://github.com/par274/sharpemu/blob/main/DirectExecutionBackend.cs), allows the emulator to intercept and translate hardware exceptions into emulated signals.

## Process Isolation and Resource Management

SharpEmu leverages Windows Job Objects to isolate the emulator process and limit resource consumption.

In [`SharpEmu.GUI/EmulatorProcess.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.GUI/EmulatorProcess.cs), the code imports **CreateJobObjectW**, **CreateProcessW**, **AssignProcessToJobObject**, and **SetInformationJobObject** from *kernel32.dll*. These functions create a sandboxed environment that restricts CPU time and memory usage when launching Xbox 360 executable files (XEX).

```csharp
var procInfo = SharpEmu.GUI.EmulatorProcess.Start(
    exePath: @"C:\Games\Xbox360\MyGame.xex",
    args:    "",
    workingDirectory: @"C:\Games\Xbox360"
);
// The process now runs inside a Windows Job that limits CPU time and memory.

```

## Audio Output Implementation

For Windows hosts, SharpEmu implements audio playback through the legacy Windows Multimedia API.

In [`SharpEmu.GUI/SndPreviewPlayer.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.GUI/SndPreviewPlayer.cs), the code calls **waveOutOpen** and **waveOutWrite** from *winmm.dll* to stream PCM audio data to the host sound system. This provides low-latency audio output specifically for the Windows platform.

## Memory Management for Host Buffers

The emulator requires fine-grained control over memory allocation and protection for JIT-generated code and guest memory mappings.

In [`SharpEmu.HLE/HostMemory.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.HLE/HostMemory.cs), SharpEmu wraps **VirtualAlloc**, **VirtualFree**, **VirtualProtect**, **VirtualQuery**, and **FlushInstructionCache** from *kernel32.dll*. These functions allocate executable memory regions and manage protection flags required for the dynamic recompiler.

```csharp
IntPtr execBuf = SharpEmu.HLE.HostMemory.VirtualAlloc(
    IntPtr.Zero,
    size: 0x2000,
    allocationType: AllocationType.Commit | AllocationType.Reserve,
    protect: MemoryProtection.ExecuteReadWrite);

```

## Summary

- **SharpEmu integrates with the Windows host platform** through P/Invoke calls to *kernel32.dll*, *user32.dll*, and *winmm.dll* for hardware detection, process management, and memory operations.
- **Hardware detection** relies on Registry queries and **EnumDisplayDevices** to log CPU, GPU, and RAM information in [`HostSystemInfo.cs`](https://github.com/par274/sharpemu/blob/main/HostSystemInfo.cs).
- **JIT compilation** uses **Thread-Local Storage** and **Vectored Exception Handling** from [`DirectExecutionBackend.cs`](https://github.com/par274/sharpemu/blob/main/DirectExecutionBackend.cs) to manage execution state and catch guest faults.
- **Process isolation** is implemented via Windows Job Objects in [`EmulatorProcess.cs`](https://github.com/par274/sharpemu/blob/main/EmulatorProcess.cs) to sandbox the emulator runtime.
- **Memory management** uses **VirtualAlloc** and **VirtualProtect** in [`HostMemory.cs`](https://github.com/par274/sharpemu/blob/main/HostMemory.cs) to allocate executable buffers for the JIT backend.
- **Platform detection** occurs at runtime using `OperatingSystem.IsWindows()` to activate these Windows-specific code paths while keeping the core emulator cross-platform.

## Frequently Asked Questions

### How does SharpEmu detect the host hardware on Windows?

SharpEmu queries the Windows Registry at `HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0` to read CPU identifiers and calls **GlobalMemoryStatusEx** from *kernel32.dll* to obtain total system RAM. For graphics hardware, it uses **EnumDisplayDevices** from *user32.dll* to enumerate GPUs, all implemented in [`SharpEmu.Logging/HostSystemInfo.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.Logging/HostSystemInfo.cs).

### What Windows APIs does SharpEmu use for JIT compilation support?

The emulator uses **TlsAlloc**, **TlsSetValue**, and **TlsGetValue** for thread-local storage management, and **AddVectoredExceptionHandler** to catch access violations generated by guest code. These functions are imported in [`SharpEmu.Core/Cpu/Native/DirectExecutionBackend.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.Core/Cpu/Native/DirectExecutionBackend.cs) to support the direct-execution JIT backend.

### Why does SharpEmu use Windows Job Objects for process management?

Job Objects provide resource isolation and limits. By calling **CreateJobObjectW** and **AssignProcessToJobObject** in [`SharpEmu.GUI/EmulatorProcess.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.GUI/EmulatorProcess.cs), SharpEmu can constrain CPU time and memory usage for the emulated process, preventing the guest Xbox 360 code from consuming excessive host resources.

### How does SharpEmu allocate executable memory for the JIT on Windows?

Through [`SharpEmu.HLE/HostMemory.cs`](https://github.com/par274/sharpemu/blob/main/SharpEmu.HLE/HostMemory.cs), the emulator calls **VirtualAlloc** with executable protection flags and **FlushInstructionCache** to ensure processor coherence. This allows the JIT compiler to generate and execute native x86-64 code within the emulator's address space.