Win32 in Windows 11: Why “Windows 95 code” Still Shapes Microsoft’s Future

Mark Russinovich, Microsoft’s Azure CTO and one of the original architects of Windows NT, made it official: Win32 isn’t going anywhere. In a Microsoft Dev Docs video posted May 6, 2026, Russinovich stated that Win32—the API lineage that powered Windows 95, Windows NT, and virtually every desktop application for three decades—remains a first-class citizen in Windows 11. The declaration ends years of developer anxiety over whether Microsoft would eventually pull the plug on the aging but omnipresent programming interface in favor of modern alternatives.

For enterprises running thousands of line-of-business apps and for indie developers whose tools trace back to the Windows 9x era, the confirmation is more than a footnote. It’s a guarantee that the immense investment in Win32 code—estimated to number in the billions of lines globally—is safe for the foreseeable future. But it also crystallizes a fundamental tension: can Windows truly evolve into a sleek, secure, cloud-connected OS while dragging decades of compatibility baggage?

The 32-bit foundation that refused to die

Win32 wasn’t Microsoft’s first API, but it became the one that defined desktop computing. When Windows NT shipped in 1993 and Windows 95 followed two years later, the 32-bit application programming interface replaced the hybrid 16-bit/32-bit mess of Windows 3.x. It gave developers direct memory access, a rich GUI toolkit, file system controls, and threading—everything needed to build powerful, performance-critical software. Unlike the sandboxed environments that later emerged, Win32 gave apps the run of the system, for better and worse.

The API proved so durable that multiple attempts to depose it came up short. .NET Framework, introduced in 2002, offered managed code and a more developer-friendly model but never fully replaced native Win32 for system-level tasks. Windows Runtime (WinRT), launched with Windows 8 in 2012, tried to create a sandboxed, mobile-app-style environment but suffered from poor adoption and a bifurcated ecosystem. Universal Windows Platform (UWP) refined WinRT but still couldn’t shake the stigma of being locked-down and incompatible with decades of legacy code.

Each time, Microsoft learned that the Win32 ecosystem was simply too vast to bulldoze. Not only did major ISVs like Adobe, Autodesk, and SAP build their entire product suites on it, but internal Microsoft teams—including Office—did the same. Even in 2026, the desktop version of Outlook and the core of Microsoft Word sit atop Win32 APIs. The sunk cost is measured not just in dollars but in decades of institutional knowledge, driver models, and vertical applications that have no easy migration path.

What Russinovich actually said—and what it means

In the Dev Docs video, Russinovich, whose current title is Azure CTO but whose fingerprints remain all over Windows internals, drew a clear line between the API’s status and its future. While the full transcript isn’t public, attendees and early viewers reported key takeaways:

• Win32 is a “first-class developer surface” in Windows 11. This means it isn’t relegated to some compatibility shim or legacy mode; it’s actively supported with new features, security improvements, and performance enhancements.
• The Windows kernel, derived from NT, remains deeply intertwined with Win32. Even new subsystems, like the Windows Subsystem for Linux (WSL), sit alongside—not on top of—the Win32 layer, using it for certain operating system services.
• Modern frameworks, including Windows App SDK and WinUI 3, are built to co-exist with Win32. Rather than replace it, they extend it, allowing developers to call Win32 APIs where needed while tapping into modern UI and packaging.

This reaffirms what many developers already suspected: the “one API to rule them all” era never materialized. Instead, Microsoft settled on a layered approach where new capabilities—AI integration, pen and touch, cloud connectivity—are exposed through modern APIs that can be intermixed with classic Win32 calls. For example, a Win32 app can host a WinUI 3 control to get Fluent Design visuals, or use the Windows Package Manager for MSIX containment without a full rewrite.

Enterprise reality: “We’re not rewriting our ERP”

Walk into any Fortune 500 company and you’ll find Win32 apps that date back to the Windows XP era—or earlier. Manufacturing plants run equipment-control software coded for Windows 2000. Hospitals schedule staff with applications compiled for Windows 7. Financial institutions process transactions through interfaces originally built for Windows NT 4.0.

These aren’t niche cases; they’re the backbone of global commerce. System administrators have long feared that a forced migration to a UWP-only or web-based model would require multi-million-dollar rewrites or wholesale replacement of mission-critical tools. Russinovich’s statement directly addresses that fear, signaling that Microsoft’s enterprise sales teams will continue to assure customers that Windows 11—and whatever follows—won’t break their existing software stack.

That compatibility comes at a cost. Win32’s permissive nature makes it a favorite vector for malware. Because a Win32 executable can directly manipulate the file system, registry, and memory, it’s far harder to sandbox than a UWP app. Microsoft has gradually introduced mitigations—SmartScreen, controlled folder access, AppLocker—but these are opt-in or policy-driven band-aids. The underlying tension between legacy power and modern security remains unsolved.

The community reaction: relief, skepticism, and finger-pointing

The developer community reacted with predictable fervor. On forums, social media, and comment threads, the sentiment broke into three camps.

Relieved pragmatists pointed to their own codebases: “I maintain a 25-year-old MFC app that our factory runs. This means I can keep applying security patches and keep my job,” wrote one user on a popular Windows forum. Another noted that even new languages like Rust rely on Win32 bindings for Windows GUI work, making the API an unseen dependency even in modern toolchains.

Skeptics questioned the long-term viability. “First-class today doesn’t mean first-class in Windows 12 or 13,” one commenter argued. “This feels like placation while they quietly build a successor that will one day lock out Win32 for ‘security reasons.’” Others pointed to the fate of technologies like Silverlight and XNA as evidence that Microsoft can and will sunset large platforms.

Modernists expressed frustration that the ecosystem remains shackled. “We can’t get a unified, fast, secure platform because we’re catering to code written when Bush was president,” one developer griped. They argue that Windows struggles to compete with macOS and ChromeOS precisely because it can’t enforce a clean cut from the past.

Notably, the discussion also highlighted an irony: many of the “modern” frameworks themselves rely on Win32 under the hood. WinUI 3, for instance, uses a Win32 window class for its MainWindow, and WinRT components often wrap Win32 APIs for file pickers, notifications, and process management. The abstraction is thinner than it appears.

A compatibility table: Win32 vs. other API surfaces in Windows 11

What comes next for Win32 and Windows

Russinovich didn’t just defend the past; he hinted at an evolving future where Win32 remains a bedrock but adapts. Key areas of investment include:

• ARM64 support: Microsoft has ported the entire Win32 subsystem to ARM64, allowing native execution on Snapdragon X and other ARM chips. The compatibility is such that most Win32 apps can be recompiled for ARM with minimal changes, and x86/x64 emulation fills the gap for unmodified binaries.
• Security hardening: Without breaking compatibility, Microsoft is gradually introducing opt-in features like “Win32 app isolation” (in preview), which uses AppContainers to sandbox individual Win32 processes. This could let legacy apps run with restricted access without rewriting them.
• AI integration: New AI APIs, accessible from Win32 calling conventions, allow desktop apps to tap into on-device models (like NPU-accelerated text summarization) without migrating to a new framework.

For developers, the immediate takeaway is pragmatic: keep building on Win32 where it makes sense, but adopt modern tooling where possible. The hybrid model isn’t elegant, but it’s the reality of maintaining a 1.5-billion-user platform while honoring three decades of compatibility promises.

Microsoft’s path forward will likely involve continued refinement rather than revolution. The vision of a unified API never died entirely—Project Reunion (now part of Windows App SDK) aimed to bridge the gap—but the company now acknowledges that unification doesn’t require a clean-room rewrite. As Russinovich put it in an earlier conference talk: “The NT kernel is designed to run any subsystem you throw at it. Win32 just happens to be the one that won.”

For Windows 11 users, the news is invisible but reassuring. That dusty old accounting program that refuses to install on anything else? It will keep working. The 20-year-old game that relies on Direct3D 9? It will still run. And the next generation of blazing-fast AI apps might just call the same CreateWindowEx function their ancestors did in 1995.