Low-Level Programming news and engineering summaries

AnyPS5 automatically ports PS5 executables to Linux and Windows without emulation or a separate runtime process. Its relinker converts executables to native target formats, while implementations of system prx libraries support dynamic linking. The project includes SDL-mapped controller input, configurable keyboard and mouse controls, and a shader recompiler that produces validated SPIR-V. Dreaming Sarah reaches stable 60 fps on a GTX 1050 Ti and i5-7500; unsupported states terminate with std::runtime_error.

A developer successfully ported Mac OS X 10.0 Cheetah to the Nintendo Wii. By writing a custom bootloader, patching the Mach-O kernel, and developing IOKit drivers for the Wii's Hollywood SoC, the project achieved a functional desktop environment. This effort involved solving complex challenges like endianness, framebuffer rendering, and USB hardware communication.

Hardware researcher Christopher Domas created the CPU Deoptimization leaderboard to identify the slowest x86 instructions. By manipulating PCIe fabric through MMIO and state restoration, he achieved a record-breaking 198 billion cycle latency (62 seconds) for the xrstore64 instruction. This project highlights deep architecture vulnerabilities and provides a unique, tongue-in-cheek perspective on low-level performance bottlenecks.

A developer successfully used the Logitech MX Vertical mouse as a tiny, persistent storage device by hacking its HID++ protocol. By writing arbitrary two-byte data into the DPI register, they demonstrated that the mouse maintains state across devices. The project highlights reverse engineering, firmware communication, and understanding OS-level hardware management through experimental technical exploration.

The Assembly Hall of Shame is a project by Christopher Domas that identifies the slowest possible single instructions on x86 architectures. By deliberately triggering microcode assists, hardware traps, or saturating PCIe fabric with high-latency MMIO transactions, it reveals extreme performance penalties, with the record-holding 'fxrstor64' instruction taking over 198 billion cycles to complete.

NVIDIA is developing native GPU programming in Rust through two early-stage CUDA Rust tracks: cuda-oxide for SIMT kernels and cutile-rs for Tile kernels. Both compile or JIT-compile Rust to GPU code while using Rust’s ownership and type systems to catch aliasing and safety errors. Tile simplifies architecture mapping; SIMT preserves low-level control, including performance-critical tuning.

In a unique case of software archaeology, a researcher successfully bypassed hardware-based copy protection for a legacy RPG (Report Program Generator) II compiler used by an accounting firm. The firm was incredibly still running Windows 98 in 2026 to execute 40-year-old software requiring a physical dongle on a parallel port. By using the Reko disassembler to analyze 16-bit x86 executables, the researcher identified a specific 0x90-byte code segment responsible for dongle communication. Analysis revealed that the routine returned a constant value in the BX register regardless of input. Through brute-force testing within DosBox, the constant was identified as 7606h. Applying a four-byte assembly patch (MOV BX, 7606; RETF) successfully emulated the dongle presence, allowing the software—and its compiler—to run on modern emulators without the original hardware.

RollerCoaster Tycoon remains a benchmark for game performance, largely due to Chris Sawyer’s expert use of Assembly and aggressive low-level optimizations. By balancing technical constraints with design choices—such as clever pathfinding limitations and simplifying complex agent interactions—Sawyer prioritized engine efficiency, creating a seamless simulation that holds up decades later.

Microsoft has designated Rust a Tier-1 language, providing internal teams with secure toolchains, production workflows, and deep Windows integration. Its new rustc_codegen_utc backend connects rustc to MSVC, enabling shared code generation, security, diagnostics, optimization, and Rust/C++ interoperability. Production-ready since early 2026, it already supports over 100 Microsoft repositories.

Rust’s borrow checker accepts an unsound program involving a generic type with a custom `Drop` implementation. The example stores a reference to a stack-local `String` in `Q`, whose `Drop` moves it into a global `Mutex<Vec<Box<dyn Any + Send>>>`, then reads it after the local expires. It compiles on current nightly and stable versions back to 1.85.0, prints unrelated stack data, and triggers AddressSanitizer’s stack-use-after-scope error.

This repository provides a comprehensive reverse-engineered source code analysis of the 1982 Atari 2600 classic, Raiders of the Lost Ark, originally designed by Howard Scott Warshaw. The analysis detail includes the disassembly of 8KB of ROM code across two banks, explaining how the 6502 assembly manages the hardware limitations of the Atari Television Interface Adaptor (TIA). Key technical features explored include the bank-switching mechanism using zero-page RAM trampolines, the division of game logic across TV signal phases (VSYNC, VBLANK, Kernel, and Overscan), and the specific rendering kernels for rooms like the Thieves' Den and the Ark Room. The project also documents unique programming tricks such as using bit 7 of sprite data for inline TIA register modification and the logic behind inventory management, collision detection, and the scoring system.

Christopher Domas’s skitter-creek-bath-salts research demonstrates how modifying undocumented AMD Family 16h DRAM-controller address transformations can create aliases to protected memory. Using cache/TLB coordination and GF(2) linear algebra with z3, the toolchain reportedly reads or writes PSP, SMRAM, C6 state, and microcode stored in DRAM, exposing limits of higher-level isolation mechanisms.

Armstrong Subero challenges Dmitry Grinberg’s criticism of RISC-V, acknowledging flaws in extensions and encoding but arguing they matter less than affordability, availability, and openness. Using CH32, Baochip, and OrangePi examples, he shows one ISA scaling from ultra-cheap MCUs to protected Linux-class systems, unlike ARM’s licensed product boundaries, enabling global education and experimentation.

Writing USB drivers is accessible without deep kernel knowledge, thanks to userspace libraries like libusb. This guide explains USB enumeration, endpoints, and descriptors using an Android phone in Fastboot mode. By understanding device identification and transfer types (Control, Bulk, Interrupt, Isochronous), developers can create functional drivers in userspace, mirroring simple network socket communication.

FEX explains why emulating x86-TSO on ARM remains difficult: ARM’s weaker ordering, alignment rules, split-lock atomicity, and write-combine memory create severe performance and correctness problems. Newer LRCPC/LSE2 features, Apple’s hardware TSO mode, Qualcomm’s coherent cachelines, kernel patches, and UMA workarounds help, but full split-lock and uncached-memory support still require architectural improvements.

Android 17 September 2026 builds contain a bionic libc regression in `wcscspn()` and `wcspbrk()`: with reject sets of at least two characters all below U+0100, both incorrectly stop at the first haystack character ≥ U+0100. The table-based scan treats that character as a match, breaking Unicode text handling; `wcsspn()` remains correct. Pixel 7 and 8a are affected, and Visual Pinball required plain-loop workarounds. Public June sources do not contain the regression.

The article redesigns conversion of a daily timestamp into hour, minute, and second by breaking dependency chains and replacing division with fixed-point multiplication. Its V1, V2, and V3 algorithms achieve substantially lower latency—down to five cycles—while preserving throughput, with platform-specific SIMD variants. It also covers milliseconds, leap seconds, compiler limitations, and benchmark results across x86, ARM, and Apple Silicon.

Modern Windows apps, often built on memory-heavy web frameworks, have lost the unique visual identity of the Win32 era. This technical analysis explores how raw Win32 API enables non-rectangular, custom-shaped, and animated windows. While challenging to implement, this low-level control offers a powerful alternative to generic, bloated desktop software, restoring creative freedom to application interface design.

After seven years with Rust, the author reimplemented JSONPath (RFC 9535) in Zig, comparing both languages through IDE support, build tooling, project structure, testing, functional programming, mutation, allocators, ownership, and libraries. Zig’s CLI workflow, simplicity, speed, and low-level potential impressed them, but manual memory management, immature ecosystem, and evolving APIs made Rust safer and more readable.

openTPU is an open-source AI accelerator that unifies SystemVerilog RTL, an 8×32-bit ISA, bit-exact simulator, kernel language/compiler, host tools, and profiler to make neural-network inference understandable and runnable on hardware. It targets a 4 GiB Kintex-7 PCIe card, runs models including Qwen3, LFM2.5, and Qwen3.5, and matches simulator tokens bit for bit. Its explicit instruction-driven architecture exposes data movement and timing, while 4-bit weights and expert offloading extend capacity and improve decode speed.