Developers behind ReactOS, the open-source project aiming to build a binary-compatible Windows replacement, reached a milestone on July 1, 2026, by merging the operating system’s first NT6-era system call into its kernel. The newly implemented function, NtGetCurrentProcessorNumberEx, is a stub that marks the beginning of long-awaited compatibility with Windows Vista and later versions, shattering the long-held NT 5.2 ceiling that has defined the project since its inception.

The change, submitted as a combined kernel and NTDLL patch, introduces the syscall without any functional logic—simply returning zero and the STATUS_NOT_IMPLEMENTED status code. But for the ReactOS community, the symbolic weight is enormous. For over two decades, the project has clung to the Windows Server 2003/XP kernel architecture (NT 5.2) as its blueprint. Moving into NT6 territory signals that ReactOS is finally ready to expand its ambitions and tackle the massive architectural shifts Microsoft introduced with Windows Vista.

Why a Single Stub Matters

To an outsider, adding a function that does nothing might seem trivial. Yet in the world of kernel development, every new system call represents a pact between user mode and the deepest layers of the operating system. NtGetCurrentProcessorNumberEx is used by later Windows versions to retrieve the logical processor number of the current thread, a critical piece of information for efficient NUMA-aware scheduling and multi-core optimization. Its presence—even as a stub—allows applications that check for NT6 APIs to load and potentially run, rather than crashing immediately upon seeing an unknown kernel.

The ReactOS kernel, known internally as the NT kernel-compatible “ntoskrnl” replacement, had until now implemented only the system calls found in Windows XP and Server 2003. This meant that countless modern applications, drivers, and even components of later Windows itself simply could not function. The stubborn limitation eroded ReactOS’s practical usefulness, confining it to running software abandoned by the commercial world over a decade ago.

The Long Road to NT6

ReactOS began in 1996 with the goal of cloning Windows NT 4.0. Over the years, it progressed to Windows 2000 and then XP/2003 compatibility, but the jump to Vista proved a formidable barrier. Microsoft’s kernel underwent radical surgery in Vista: the introduction of user-mode driver frameworks, a rearchitected I/O manager, new synchronization primitives, and a slew of new syscalls designed to support the flashy Aero interface and enhanced security.

For a volunteer-driven project operating on reverse-engineering and clean-room documentation, the sheer number of new APIs was overwhelming. Beyond system calls, NT6 introduced kernel-mode changes like ALPC (Advanced Local Procedure Call), a revamped object manager, and the infamous PatchGuard that made kernel patching far more difficult. ReactOS developers opted to stabilize what they had rather than chase a moving target, leading to the multi-year stagnation in compatibility levels.

The July 1 merge ends that drought. The patch was authored by a core developer after months of preparatory work, including updates to the kernel’s syscall table, the NTDLL DLL, and the build system to recognize NT6-specific exports. The commit message, brief as it was, indicated that while the full implementation will be tackled later, the mere availability of the stub is a “first guard” that lets the team start testing how existing NT6 software interacts with ReactOS.

NtGetCurrentProcessorNumberEx: The Bridge Function

To understand why this particular syscall was chosen as the first NT6 addition, it helps to examine what it does. On Windows Vista and later, NtGetCurrentProcessorNumberEx returns the current processor number, optionally supporting different modes via a maximum processor count parameter. The function replaces the older NtGetCurrentProcessorNumber (without “Ex”) from earlier NT versions, which operated on a simple return value without the extended parameters.

The “Ex” suffix has a storied history in Windows API design, indicating an extended or enhanced version of an existing function. By bridging from an existing NT5 syscall, ReactOS developers could leverage familiar infrastructure while introducing the newer calling convention. The kernel’s system service dispatch table must be aware of both the old and new functions, routing them appropriately. This dual routing is a first step toward a more complex compatibility layer that will eventually allow applications compiled for Vista or Windows 7 to run seamlessly.

Architectural Implications

Under the hood, adding a new syscall touches many components. The ReactOS kernel’s KeServiceDescriptorTable—the master list of system services—had to be extended with an entry for NtGetCurrentProcessorNumberEx. Simultaneously, the NTDLL library, the user-mode front door to kernel services, required an assembly stub that pushes the correct arguments onto the stack and triggers a software interrupt or SYSENTER instruction.

Moreover, the build system needed to recognize the new NT6 target version. ReactOS uses a version configuration that defines which set of APIs to expose. Until now, _WIN32_WINNT was pegged to 0x0502 (Windows Server 2003). With this commit, a new NT6 pathway is being carved out, though it remains disabled by default. Developers can test with a custom compile-time flag, but the long-term plan is to increment the target version gradually as more system calls are implemented.

The stub’s simplicity belies the groundwork needed: header files had to be updated with the correct function prototype, the public syscall number mapping had to be verified against known lists, and the linker needed to export the symbol with the right ordinal. ReactOS’s kernel is written mostly in C with some assembly, so adding a function involves changes to ntoskrnl/ke/i386/syscall.asm or its AMD64 equivalent, plus the dispatch layer.

Community Reaction and Hopes

On the ReactOS forums and development mailing lists, the mood was jubilant yet tempered. Longtime contributors recalled that similar “first step” announcements had been made before, only to see progress stall. But this time, the groundwork was more mature: the 0.4.x series had stabilized the core, the MM (Memory Manager) and Cache Controller had been rewritten, and the team had grown by a handful of persistent new developers.

One developer noted, “It’s a stub, yes, but it’s like putting a flag on the moon. It shows we can reach NT6. Now we need to fill in the functions that matter most for real applications.” The sentiment highlights the pragmatic reality: a single syscall won’t let users run modern software. But it opens the door to incremental progress, which is how ReactOS has always advanced.

What NT6 Compatibility Means for Users

For the average user, the immediate benefit is nil. No applications will actually use NtGetCurrentProcessorNumberEx until ReactOS can return a valid processor number and handle the extended parameters correctly. However, once a critical mass of NT6 syscalls is implemented, a wide range of software becomes potentially usable. That includes:

  • Chromium-based browsers: Modern Chrome and Edge expect Windows 7 or later; they rely on APIs like GetThreadId and condition variables that were introduced in Vista.
  • Microsoft Office 2010+: Later Office versions require Vista APIs for smooth operation.
  • .NET Framework 4.x: Parts of the runtime require NT6 features, blocking many enterprise tools from running on ReactOS.
  • Driver frameworks: KMDF and UMDF v2 demand NT6 kernel support, so hardware compatibility would surge.

Hardcore enthusiasts already run ReactOS in virtual machines or on vintage hardware for nostalgic purposes. But with NT6 stubs, the dream of powering modern thin clients or even low-end laptops with a free, Windows-compatible OS inches closer.

The Road Ahead: From Stubs to Functionality

The ReactOS team has outlined a practical roadmap: first, stub out the most commonly queried NT6 syscalls so that applications which only check for existence can proceed. Next, implement the simpler syscalls that provide basic thread and process information. Finally, tackle the heavy hitters like ALPC, which underpins many system services. The prioritization is driven by the applications that developers most want to see running: web browsers, productivity suites, and development tools.

NtGetCurrentProcessorNumberEx will eventually be replaced by a real implementation that reads from the kernel’s processor control region (KPCR) or uses the CPUID instruction to determine the physical processor ID. On multi-socket systems, this involves querying the local APIC ID and mapping it to a logical index. That work is non-trivial, as it must be lock-free and extremely fast—it’s called frequently during scheduling decisions.

Historical Context: The NT Version Chasm

Windows NT kernel versions map to a confusing array of marketing names. NT 5.0 was Windows 2000; NT 5.1 was XP; NT 5.2 was Server 2003 and XP x64. Then came NT 6.0 (Vista), NT 6.1 (Windows 7), NT 6.2 (Windows 8), NT 6.3 (Windows 8.1), and finally NT 10.0 (Windows 10 and 11). Throughout these jumps, the syscall table expanded dramatically. ReactOS had been frozen in the 5.2 era, effectively ignoring all the innovations—and breaking changes—that came later.

Windows Vista alone added over 40 new system calls, many of them for multimedia, synchronization, and I/O. Windows 7 and 8 added dozens more. The ReactOS team’s strategy of stubbing first allows them to tackle the table in a manageable order. By comparison, the Wine compatibility layer for Linux has long had NT6 support because it translates Windows calls to Linux equivalents; ReactOS, running directly on hardware, must implement everything itself.

Potential Pitfalls

Skeptics point out that other open-source projects, such as Haiku (the BeOS reimplementation), have struggled for decades to reach full compatibility with their targets. The challenge of replicating a closed-source kernel without proprietary documentation is immense. Microsoft’s public symbols and leaked debug information provide some guidance, but the precise behavior of many syscalls remains undocumented, requiring painstaking reverse engineering or trial-and-error.

There is also the risk of breaking existing NT5 compatibility. As new syscalls are added, the kernel’s internal state management becomes more complex. A bug in an NT6 stub could accidentally corrupt structures used by NT5 paths. To mitigate this, ReactOS uses extensive automated testing, including a suite that boots the OS and runs thousands of regression tests. The NT6 code will be shielded behind a compile-time option until it passes all existing tests.

The Bigger Picture: ReactOS in 2026

By mid-2026, ReactOS had reached version 0.4.14, featuring improved USB support, sound drivers, and a redesigned shell. Still, it remained a curiosity more than a daily driver. The first NT6 syscall may seem small, but it symbolizes a strategic shift. The project’s leaders have publicly acknowledged that without Vista-era compatibility, ReactOS cannot attract users beyond a niche of retrocomputing fans. This merge is the tangible proof that the team is serious about modernizing.

Funding for ReactOS has always been sparse, relying on donations and the occasional grant. The NT6 push could attract new contributors who want to see modern Windows apps running on an open-source base. It also opens the door to commercial spin-offs: an industrial embedded system, for example, that needs to run legacy Windows software without paying Microsoft licensing. If ReactOS can achieve Windows 7-level compatibility, the TCO (total cost of ownership) advantage becomes compelling for certain use cases.

Conclusion: A Small Step, A Giant Leap

NtGetCurrentProcessorNumberEx is just a stub. But history shows that the most profound changes in software begin with humble commits. For ReactOS, this first NT6 syscall is the cornerstone of a future where freedom and Windows compatibility are no longer mutually exclusive. The project has endured for three decades because of stubborn optimists who believe that no proprietary system should be the only gateway to running existing software.

The next few months will be crucial. Will the stub remain an isolated novelty, or will it be joined by a wave of NT6 implementations? The ReactOS community is betting on the latter, already drafting plans for the next batch of syscalls. As one developer wrote in the merge commit, “This is just the beginning.”