When a Reddit thread about "reviving WinForms" pulls in 350+ comments, it tells you something.
Developers still care about the fast iteration loop that WinForms nailed. Even if the framework itself is decades old.
"WinForms was ugly but damn was it fast."
"If WinForms worked on macOS and Linux, I'd still be using it daily."
"Microsoft will never revive WinForms. They barely keep it alive."
Then there's the XAML Designer for .NET MAUI thread on Visual Studio Developer Community. Started in December 2022. Over 3 years of developer requests for a visual designer.
In September 2025, Microsoft closed the thread with this response:
"A drag-and-drop UI designer is not part of our direction for .NET MAUI. We're focused on providing a high-fidelity design-time experience through XAML Live Preview and Hot Reload."
— Beth Massi, Microsoft [MSFT]
The community response was... mixed:
"Live Preview works fine after you build the UI. Then you don't need it." — Larry Leach
"Microsoft need to realise that a drag and drop designer and a hot reload system serve two distinct functions. One allows for content creation, while the other allows for content debugging and testing." — David Newman
These two threads, one about nostalgia, one about current direction, point to the same gap.
Microsoft isn't reviving WinForms. They're not building a designer for MAUI. But the need for a fast, reliable, visual UI workflow hasn't disappeared.
What WinForms Got Right (And What It Left Behind)
WinForms worked because it was fast.
You could drag controls, wire up events, and see results in minutes. For internal tools, dashboards, and small apps, nothing matched that loop.
But it wasn't perfect:
- Windows-only lock-in limited its lifespan
- High-DPI scaling was (and is) painful
- Designer mismatch: what you saw at design-time rarely matched runtime
- Messy at scale: small apps thrived, large ones turned brittle
Developers didn't love WinForms because it was modern. They loved it because it let them move fast.
Why Microsoft Won't Revive It
Microsoft has shifted focus.
Their investment is in web, mobile, and cross-platform frameworks like MAUI and Blazor. WinForms still runs. But it isn't evolving.
Designers in general have been deprioritized. Visual tools are expensive to build and maintain. The industry has moved toward code-first workflows. Microsoft's bet is on XAML Live Preview, Hot Reload, and AI-assisted development.
From the official response on the MAUI thread:
"You should be able to efficiently create and iterate on your UI, particularly when paired with Copilot Vision."
This is the stated direction. XAML Live Preview for design-time feedback. Hot Reload for runtime iteration. Copilot for code assistance.
The challenge? Many developers don't find this workflow as efficient as a visual designer. The feedback loop is still longer. You write XAML, preview it, adjust, repeat.
But productivity gaps don't disappear because the tooling changes. The demand for faster UI iteration is still there. Both threads prove it.
What's Out There (And Why It's Still Not Enough)
Let's talk about what already exists.
XAML Hot Reload and Live Preview
Visual Studio has two features: XAML Hot Reload and XAML Live Preview. Hot Reload lets you tweak XAML and see changes without rebuilding. Live Preview shows a real-time render of your XAML as you type.
But both have limitations:
- Instability: Hot Reload frequently breaks or requires restarts
- Design-time vs runtime gap: You're still editing code, not manipulating a live UI
- Platform-specific: Works best on Windows, less reliable for iOS/Android emulators
- Preview-only: Live Preview shows you the UI but you can't drag and drop controls
JetBrains Rider XAML Previewer
Rider has a XAML previewer that works across platforms. It's faster than Visual Studio's. But:
- WPF-only. No support for MAUI, UWP, or WinUI3
- Limited to preview-only. You're still writing XAML by hand
- No drag-and-drop or visual manipulation
VS Code XAML Extensions
Extensions like XAML Complete add IntelliSense and snippets. But they're text-first tools. They don't solve the core problem: the feedback loop is still too long.
The gap: These tools are all improvements over writing raw XAML in Notepad. But none of them fully recreate the "drag, click, see it running" experience that WinForms delivered across all major .NET UI frameworks. They're either preview-only, framework-specific, or still require the rebuild-redeploy cycle.
Microsoft's position is that Live Preview and Hot Reload address this need. But for many developers coming from WinForms, the gap remains.
Hot Design: A Modern Take on the WinForms Loop
If WinForms was the "fast, drag-drop, get-it-running" bedrock, Hot Design is a modern, cross-platform successor built for the Uno Platform ecosystem.
Here's how it works.
The Mechanism
Hot Design is a runtime visual designer. It transforms your live, running app into a real-time design environment.
That means:
- Changes you make in the designer are reflected in real, running UI, not a render approximation
- You're manipulating actual controls with actual data contexts
- Works with real data or mock data sources
- Supports MVVM and MVUX architectures
- What you see is what you ship. No design-time vs runtime mismatch
It's IDE-agnostic. Works in Visual Studio, VS Code, and JetBrains Rider. The designer syncs instantly with your XAML code.
The difference isn't just speed. It's flow. You stay in the design context instead of context-switching between editor, compiler, and emulator.
How It Addresses WinForms' Gaps
| WinForms Appeal / Gap | How Hot Design Addresses It |
|---|---|
| Drag-and-drop + fast loop | Drag-and-drop + adjust UI in your running app, see changes instantly. No rebuild/deploy cycle |
| Windows-only lock-in | Runs on Windows, macOS, Linux, iOS, Android, and WebAssembly. IDE-agnostic (VS, VS Code, Rider) |
| Scaling / DPI pain | Test responsive layouts, switch themes, preview on remote devices in real-time |
| Messy at scale | Supports MVVM and MVUX architectures. Works with real or mock data sources |
| Designer instability | Built on Uno Platform's stable tooling, actively maintained since 2018. Integrates with Hot Reload |
| Limited reach | One codebase, multiple targets: iOS, Android, Web, Desktop |
Key difference: Hot Design works at runtime, not design-time. Your app is running. You're designing in the live environment. That's how it avoids the preview vs runtime mismatch that plagued WinForms and still affects XAML Live Preview.
Why Designers Still Matter
Developers are tired of the compile-debug dance.
They want to see real changes in real time. That's what WinForms gave us. That's what we've lost in modern frameworks.
Visual designers aren't about replacing code. They're about shortening the loop. When you can preview real states, test across themes, and tweak layouts instantly, you save hours of context-switching.
That's productivity. That's flow.
A typical XAML tweak in MAUI takes 30-60 seconds (edit, build, deploy to emulator). Multiply that by dozens of tweaks per feature, and you're looking at significant time lost. Hot Design removes that cycle entirely.
Hot Design isn't nostalgia. It's a reminder that visual feedback still matters. Especially when you're building cross-platform apps where complexity multiplies.
The Bottom Line
Microsoft won't revive WinForms. But the gap it filled is still there.
Fast, visual, low-friction UI work. That's what developers want.
Hot Design isn't nostalgia. It's an attempt to solve the same problem WinForms solved, in a world where cross-platform is the default. Whether it's the right tool for you depends on your workflow and whether you're already in (or willing to adopt) the Uno Platform ecosystem.
But if you've spent more time fighting XAML preview bugs than actually designing? Worth understanding what's possible.
The WinForms iteration loop doesn't have to be a relic. It just needs to work across more than one platform.
Top comments (1)
Hot Design ftw! Wish we see sth similar in the JS ecosystem.