Windows 11 New Run Dialog in WinUI 3: 94ms Speed Test vs Legacy

On May 1, 2026, Microsoft began testing a rebuilt Windows 11 Run dialog in Insider Experimental builds, replacing the decades-old Win32 surface with an opt-in C# and WinUI 3 version that Microsoft says opens in a median 94 milliseconds. The number should have been a quiet engineering footnote. Instead, it became a small proxy war over whether Microsoft still knows how to build Windows. The better reading is less theatrical and more important: Microsoft is trying to prove that modern Windows UI does not have to be slower than the legacy code users have learned to tolerate.

The Smallest Box in Windows Became a Referendum on the Whole OS​

The Run dialog is not glamorous software. It is a rectangle, a text field, a few buttons, and thirty years of accumulated muscle memory. Press Win + R, type cmd, regedit, mstsc, winword, control, a UNC path, or some private incantation known only to your help desk, and Windows does the thing.
That simplicity is exactly why the reaction to Microsoft’s new version became so sharp. The old Run box looks like a fossil from Windows 95 because, in spirit and in user experience, it is one. For many power users, that fossil status is not a bug. It is proof that the feature survived every design fad because it was fast, boring, predictable, and difficult to monetise.
Microsoft’s pitch is that the new Run keeps those virtues while finally joining the rest of Windows 11. It has a modern Fluent-style look, dark mode support, a cleaner interface, better keyboard-oriented navigation, and the ability to type ~\ to jump into the user profile directory. More provocatively, Microsoft says it is faster than the old one: 94 milliseconds median time-to-show, compared with 103 milliseconds for the legacy dialog.
That 9 millisecond improvement is both tiny and revealing. Nobody’s workday changes because Win + R appears nine milliseconds sooner. But if Microsoft can rebuild one of Windows’ oldest utilities in WinUI 3, ship it with richer visuals, compile it ahead-of-time, and still beat the old Win32 baseline, then the old assumption that “modern Windows UI” automatically means “sluggish Windows UI” becomes harder to defend.

The Backlash Confused a Doorbell With a Conveyor Belt​

The loudest criticism of the 94 millisecond figure leaned on a seductive but wrong comparison. If a gaming PC can render frames every 8, 10, or 16 milliseconds, critics asked, why should a text box take almost a tenth of a second to appear? The implication is that Microsoft is celebrating mediocrity.
That argument mistakes two different worlds of performance. A game rendering its next frame is usually operating on a hot path. The engine is already running, its memory is allocated, assets are staged, the graphics pipeline is alive, and the GPU is being fed continuously. The work is not trivial, but it is the next turn of a machine already in motion.
Opening the Run dialog is closer to ringing a doorbell and waiting for a whole room to assemble itself. Windows has to react to the keyboard shortcut, create or activate the relevant UI surface, load code and framework pieces that may not already be resident, instantiate controls, populate history, apply system theme rules, and hand the new window to the Desktop Window Manager for composition. The first frame is the expensive one because it includes the cost of becoming an application surface at all.
This does not mean 94 milliseconds is sacred or beyond criticism. Microsoft itself says there is room for improvement. But comparing cold-start UI latency with steady-state game frame rendering is like comparing how fast a car factory can stamp a door panel with how fast a driver can open the finished car door. Both involve metal and motion; they are not the same job.
The better criticism would ask whether the new dialog remains consistently fast on low-end machines, domain-joined systems, bloated user profiles, remote sessions, and heavily managed enterprise images. That is the Windows question that matters. Median numbers are useful, but tails are where sysadmins live.

Microsoft’s Real Claim Is About Trust, Not Speed​

Microsoft’s announcement matters because Windows 11 has spent much of its life fighting a credibility problem around polish. The operating system is modern in some places, ancient in others, and oddly duplicated in too many. Users can move from a carefully animated Settings page to a dialog that looks like it was preserved in amber before USB became normal.
That inconsistency has consequences beyond aesthetics. It trains users to assume that the old surfaces are the dependable ones and the new surfaces are decorative wrappers. Every slow context menu, delayed Settings page, or half-migrated Control Panel applet reinforces the idea that Windows’ modern shell is a layer placed on top of the real operating system rather than the operating system growing up.
The Run dialog is a test case precisely because it is small. Microsoft cannot hide behind complexity here. If the company modernises something this simple and makes it slower, the verdict writes itself: Windows 11’s design stack is still too heavy for its own everyday tools.
Instead, Microsoft is claiming the opposite. The new Run is a WinUI 3 application written in C#, compiled with .NET ahead-of-time compilation, borrowing from work proven in PowerToys and Command Palette, and still opening faster than the old dialog in Microsoft’s telemetry. That is not a revolution, but it is an important proof point.
The company is effectively saying that the modern Windows app model can compete with the old one when engineers treat performance as a requirement rather than an aspiration. That is the message behind the milliseconds.

The Old Run Dialog Was Never Just a Text Box​

Part of the backlash also rests on a charmingly incomplete description of Run itself. Yes, Run looks like a text box. But it is a text box with a surprising amount of history behind it.
It launches executables by name, resolves paths, opens folders, handles shell commands, accepts network locations, stores history, and fits into workflows built by developers, admins, support technicians, and office workers who never think of themselves as power users. It is one of the few Windows interfaces that still feels like a handshake between the GUI and command line. You can use it without knowing much about Windows internals, but the more you know, the more useful it becomes.
That is why Microsoft had to be careful. If Run becomes a search box with branding, suggestions, promotions, Copilot hooks, or unpredictable ranking, it stops being Run. If it swallows keystrokes, changes command behaviour, breaks history navigation, or delays launch while showing some animated flourish, it loses the only constituency that cares deeply about it.
The developer blog’s most encouraging detail is not the dark mode support. It is Microsoft’s claim that the team measured how people actually used the old dialog before changing it. The company found a median 103 millisecond time-to-show for the legacy version, saw vanishingly low usage of the Browse button, and discovered odd but real workflows such as using the dialog as a quick clipboard formatting scrubber.
That is the kind of telemetry story Windows users should want: not “we observed engagement and added more surfaces,” but “we measured a utility so we would know what not to break.”

The Browse Button’s Near-Death Is a Design Lesson​

The reported Browse button usage number is almost comically low. Microsoft says only 0.0038 percent of users in a 35 million-user sample clicked it. Even allowing for the limitations of telemetry, that is not a feature with a passionate silent majority. That is a button mostly performing nostalgia.
Its demotion in the new design is the right kind of simplification. Windows has too often treated backward compatibility as a reason to preserve every visible affordance forever, even when the real compatibility contract is behavioural rather than visual. If the command line, path handling, history, and launch semantics still work, the interface does not need to keep a low-value button in prime position just because it was there when people installed Windows from CDs.
This is where the new Run borrows from PowerToys in a useful way. PowerToys has become Microsoft’s unofficial proving ground for enthusiast features: FancyZones, PowerToys Run, Command Palette, Text Extractor, and a long list of utilities that often feel more responsive to actual power users than Windows itself. Folding some of that thinking back into Windows is not capitulation to nerds. It is how a mature operating system should metabolise its own experimental edge.
The risk, as always, is that Microsoft overlearns the lesson. Run should not become PowerToys Run in miniature, and it should not become Start search with a different keyboard shortcut. It can learn from those tools without becoming them.
The new ~\ shortcut is a good example of the right scale of enhancement. It is small, familiar to command-line users, and useful without being noisy. It makes Run more capable while preserving its essential bargain: type a thing, get to the thing.

WinUI 3 Needed a Win Like This​

For years, Microsoft’s Windows UI strategy has suffered from naming fatigue and trust erosion. Win32, UWP, XAML Islands, WinUI, Windows App SDK, WPF, Windows Forms, Fluent Design, Project Reunion — the architecture story has often sounded less like a platform roadmap than a shelf of half-opened toolboxes. Developers can be forgiven for wondering which stack is the future and which one is merely being politely maintained.
WinUI 3 is supposed to be part of the answer. It is Microsoft’s modern native UI framework for Windows apps, decoupled from some of the old UWP constraints and aligned with the Windows App SDK. In theory, it gives developers modern controls, Fluent styling, and a path to current Windows experiences without abandoning desktop app realities.
In practice, perception has lagged. Users do not judge frameworks by architecture diagrams. They judge them when a context menu takes too long, when a Settings page stutters, or when a modern app uses more memory than seems reasonable for the job. For many Windows enthusiasts, “WinUI” became less a framework name than a suspicion.
That is why the Run dialog matters more than its size. A fast WinUI 3 Run dialog is a public demonstration that the stack can serve latency-sensitive shell-adjacent experiences. It is not definitive proof that every Windows surface should be rewritten tomorrow. It is proof that the framework can be made to behave when the team responsible treats startup time as a first-class product feature.
Ahead-of-time compilation is doing real work in that story. By compiling .NET code before runtime rather than relying on just-in-time compilation at launch, Microsoft can reduce some startup overhead while retaining the development benefits of C#. That does not make managed code magic, and it does not eliminate the need for careful engineering. But it weakens the lazy assumption that C# plus modern UI equals unacceptable latency.

The Windows 95 Comparison Cuts Both Ways​

It is tempting to frame this as Microsoft finally dragging Windows 95 into the present. That is true visually, but incomplete politically. The Windows 95-era dialog survived because it represented a contract Microsoft has often been better at preserving than explaining: if you learn Windows deeply, Windows will keep your habits working for a very long time.
That contract is a competitive advantage. Enterprises depend on it. Enthusiasts love it. Even casual users benefit from it invisibly every time an old shortcut, command, installer, script, or peripheral continues to function. Windows is not elegant in the way a tightly controlled platform can be elegant, but its messiness is also the map of what it refuses to break.
Modernising that world requires humility. Microsoft cannot simply declare old UI bad and new UI good. Too many Windows 11 transitions have felt like lateral moves at best: a prettier Settings app that still punts advanced work to Control Panel, a modern context menu that initially hid common commands, a Start menu that looked cleaner while losing configurability people actually used.
The new Run dialog avoids some of that trap because it is opt-in for Insiders and because the performance comparison is explicit. Microsoft is not asking users to accept a slower surface in exchange for rounded corners. It is claiming the old thing can be preserved in function and improved in form.
That is the only acceptable bargain for Windows modernisation. If a replacement is prettier but less capable, users will call it regression. If it is prettier, equally predictable, and faster, even the skeptics eventually run out of ammunition.

Experimental Means Microsoft Is Still Buying Insurance​

The new Run dialog is not landing on every Windows 11 PC today. It is rolling out to Windows Insiders in the Experimental channel as an opt-in feature, enabled through Settings under System and Advanced. That detail matters because it shows Microsoft understands the blast radius of changing even a tiny Windows surface.
The company’s newer Insider channel structure is also part of the story. Microsoft has been trying to make preview builds less confusing, with clearer Beta and Experimental lanes and more user control over feature flags. That is a response to a familiar Insider frustration: reading about a feature, installing the build, and discovering that the feature is hidden behind a gradual rollout or unavailable on that device.
For Run, opt-in testing is the right move. This is the sort of feature where failure will not be measured in crash dumps alone. It will be measured in small irritations: a command that resolves differently, a history list that behaves wrong, a keyboard focus bug, a multi-monitor placement issue, a high-DPI glitch, a screen reader regression, or a delay on machines that do not look like Microsoft’s test fleet.
The Experimental channel lets Microsoft collect that pain before it becomes everyone’s pain. It also gives power users a veto of sorts, not over Microsoft’s direction but over the details. The people who live in Win + R are the people most likely to find the edge cases.
That is how Windows should evolve. Not by treating legacy users as blockers, and not by letting nostalgia freeze the shell in place, but by making the replacement earn its promotion.

The Internet Was Right to Be Suspicious, Wrong About the Evidence​

The backlash is not coming from nowhere. Windows users have been trained to doubt Microsoft’s priorities. They have watched ads appear in places that used to be quiet, Copilot occupy more oxygen than File Explorer reliability, and basic shell behaviours change for reasons that sometimes seemed more aligned with strategy decks than workflows.
So when Microsoft says “we made Run modern,” some users hear “we made it heavier.” When Microsoft says “94 milliseconds,” some hear “we are bragging about a tenth of a second to show a box.” When Microsoft says “improved usability,” some hear “we moved the cheese.”
That suspicion is healthy up to a point. It is why Microsoft had to publish the old baseline. Without the 103 millisecond comparison, 94 milliseconds is just a number waiting to be mocked. With the comparison, it becomes evidence that the new implementation is not merely a design exercise.
The criticism goes off the rails when it refuses to update in the face of that evidence. If the legacy dialog had a 103 millisecond median time-to-show and the new one has a 94 millisecond median, then the argument cannot honestly be “Microsoft made Run slower.” It has to become a more nuanced argument about whether the new implementation preserves all behaviours, whether median performance hides bad tail latency, and whether this work should have ranked above other Windows problems.
Those are fair questions. But they are not the same as dunking on WinUI because a video game can draw frames quickly after it is already running.

A Tiny Utility Reveals Microsoft’s Bigger Windows Strategy​

The new Run dialog fits a broader pattern in Windows 11’s current development cycle. Microsoft is trying to show renewed attention to performance, reliability, and craft after years in which many users felt the company was more interested in cloud tie-ins and AI surfaces than in making Windows feel solid. The Run dialog, File Explorer work, Insider channel changes, and modernization of old dialogs all point in that direction.
The cynical view is that Microsoft is repainting the trim while the foundation still creaks. There is truth there. Windows still has too many duplicated settings surfaces, too many inconsistent menus, too many update mysteries, and too many moments where enterprise manageability and consumer experimentation collide awkwardly.
But operating systems are experienced through small surfaces. The Run dialog is not the kernel, the scheduler, or the graphics stack. It is also not trivial to the people who use it hundreds of times a week. Fixing the small things is not a distraction from fixing the big things; it is one way trust is rebuilt.
The challenge for Microsoft is sequencing. If users see modern Run, modern Properties dialogs, faster File Explorer paths, fewer shell crashes, and clearer update controls, they may conclude that Windows 11 is finally getting the craft pass it needed at launch. If they see modern Run alongside more promotions, more mandatory account nudges, and more AI affordances they did not ask for, the 94 millisecond number will not save the narrative.
Windows users can forgive change. They are less forgiving when change feels like extraction.

The PowerToys Pipeline Is Becoming Windows’ R&D Lab​

One of the most interesting pieces of the new Run story is how much of it traces back to PowerToys and Command Palette. PowerToys has always occupied a strange space: official enough to carry Microsoft’s name, experimental enough to move quickly, and enthusiast-focused enough to reveal what Windows’ most demanding users actually want.
That model is valuable because Windows itself is too large and too risk-averse to use as the first draft for every idea. PowerToys gives Microsoft a place to test workflows with people who are both critical and unusually articulate. If something fails there, it fails in front of users who opted into experimentation. If something succeeds, Microsoft has evidence that it can graduate.
The new Run dialog suggests that pipeline is maturing. It is not just that PowerToys inspired the design. Microsoft says the same code behind Command Palette’s run command provider is part of the new Run experience. That is a stronger form of reuse than “we borrowed some ideas.”
For open-source contributors, that is a meaningful signal. Contributing to PowerToys can now mean influencing Windows itself, not merely improving an accessory pack. For Microsoft, it is a way to lower the cultural wall between community tooling and inbox features.
The danger is that inboxing a power-user tool can sand off the very qualities that made it good. Windows must serve a broader audience than PowerToys does. But Run is one of the rare inbox surfaces whose audience is already self-selecting. Casual users may never touch it; those who do are likely to appreciate improvements that respect speed and keyboard flow.

The Right Lesson Is Not “Rewrite Everything”​

A successful modern Run dialog should not become a blank cheque for rewriting every legacy Windows component in WinUI 3. Rewrites are expensive, risky, and often overpromised. The old code may be ugly, but it encodes behaviours that no spec fully documents because the spec is the behaviour users have depended on for decades.
Microsoft should be selective. The best candidates are surfaces where the legacy UI is visually jarring, accessibility and theming are limited, telemetry shows low-risk simplification opportunities, and the team can publish performance baselines before and after. The worst candidates are deep administrative tools where obscure behaviours matter more than visual consistency and where the new surface would inevitably ship half-complete.
Run looks like a good candidate because the core interaction is narrow and measurable. That does not make it easy, but it makes success legible. Does it open quickly? Does it focus the text box? Does history work? Do paths and commands resolve correctly? Does it respect theme and accessibility settings? Does it stay out of the way?
Other parts of Windows are harder. Control Panel migrations, device management, advanced networking, file associations, permissions, and administrative consoles carry decades of enterprise assumptions. A modern UI that hides complexity rather than organising it will not be progress.
The broader lesson is discipline. Modernisation works when Microsoft can prove that the new thing is at least as fast, at least as capable, and more coherent. Anything less is renovation theatre.

The 9 Milliseconds Are a Symbol, Not the Prize​

A nine millisecond gain is not something users will perceive in isolation. Human perception is messy, hardware varies, and Windows PCs are not lab instruments. The important part is not that the new dialog is 8.7 percent faster at the median, but that Microsoft treated the old dialog’s speed as a bar to clear rather than a relic to ignore.
That mindset is what users have wanted from Windows 11 all along. They do not object to rounded corners. They object to waiting. They do not object to dark mode. They object to inconsistency. They do not object to modern frameworks. They object to modern frameworks being used as an excuse for regressions.
The Run dialog’s performance claim is therefore a small but useful reversal of a tired pattern. Instead of telling users that a slower or less functional change is worth it because it aligns with a design vision, Microsoft is saying the design vision had to meet the existing utility on its own ground.
That is how trust gets rebuilt in a platform as old and widely used as Windows. Not through a keynote. Not through another promise that AI will reorganise the desktop. Through mundane proof that the next version of a thing can be better without making the old users pay a tax.

The Win + R Crowd Gets the Receipts​

The practical meaning of this preview is narrow today, but concrete. The feature is still an Insider experiment, and the old Run dialog is not vanishing from production machines overnight. Still, the early facts give Windows power users a reasonable basis for cautious optimism.

• Microsoft’s new Run dialog is currently an opt-in Insider Experimental feature, not a forced replacement for all Windows 11 users.
• Microsoft says the modern WinUI 3 version opens in a median 94 milliseconds, compared with 103 milliseconds for the legacy dialog it measured.
• The new implementation is written in C# with WinUI 3 and compiled using .NET ahead-of-time compilation to reduce startup overhead.
• The redesign adds dark mode support, a cleaner Windows 11-style interface, and ~\ navigation to the user home directory.
• Microsoft’s telemetry found the Browse button was clicked by only 0.0038 percent of users in a 35 million-user sample, which helps explain why the new design de-emphasises it.
• The real test will be behavioural compatibility, tail latency, accessibility, enterprise manageability, and whether Microsoft keeps the dialog focused on launching things rather than turning it into another engagement surface.

The new Run dialog will not decide the fate of Windows 11, but it does reveal the standard Microsoft now has to meet: modernise the parts of Windows that look and feel abandoned, but do it with receipts, baselines, and respect for the muscle memory that made those parts valuable. If Microsoft applies that standard beyond this one little box, the Windows desktop can become more coherent without becoming less Windows; if it does not, 94 milliseconds will be remembered only as another number in another argument.

---

Source: Windows Latest Microsoft's new Windows 11 Run dialog is faster than the Windows 95-era version it's replacing