Razor Pages Should Evolve Into a Livewire-Style Framework — No Page Reload, No SPA Complexity

[ben0707]

I believe Microsoft should take Razor Pages to the next level by officially supporting a server-driven SPA model (just like Laravel Livewire).

The vision is simple:

▶ Build fully interactive, reactive web apps
▶ Use only Razor Pages + C#
▶ With no full page reload
▶ With no React/Vue/Angular
▶ With no SPA build tools
▶ Minimal or zero custom JavaScript
▶ DOM updates streamed from the server

Basically:

Razor Pages → Livewire for .NET.

A clean, modern, productive model where UI updates, form actions, component re-renders, and validation all happen server-side, while the browser updates only the changed HTML.

Why this matters

Frontend complexity is out of control.
Most business dashboards don’t need a full SPA framework.

A Livewire-style Razor Pages approach gives .NET developers:

✅ SPA-level interactivity
✅ Zero page reloads
✅ Real-time UI updates
✅ Strong security (all logic server-side)
✅ Faster development in pure C#
✅ No JS ecosystem headaches

.NET already has the pieces:

Razor Pages

Razor Components

Partial rendering

Blazor Server diffing

SignalR

What’s missing is a unified, official, documented pattern that says:

“Build reactive modern web apps entirely in Razor — no page reloads, no client SPA required.”

This would make .NET one of the most productive full-stack frameworks in the world.

[ben0707]

Blazor Adds Unnecessary Complexity — Razor Pages Can Solve This Much Simpler

A lot of people suggest “Just use Blazor” when we talk about building interactive .NET applications.

But the truth is:

Blazor introduces a new layer of complexity that many teams don’t need.
Razor Pages can achieve the same interactive experience with far less overhead.

Here’s the core issue:

Blazor (WASM or Server) adds:

Component lifecycle rules

Render trees

States & disposables

JS interop

SignalR/WebAssembly runtime

Large client payloads

Debugging complexity

A learning curve separate from Razor Pages

For enterprise dashboards and SaaS apps, this is often overkill.

Razor Pages already solves this — if Microsoft gives it Livewire-style power:

Server-side events

Partial component re-renders

No full page reload

HTML-over-the-wire updates

Zero JS frameworks

Zero hydration

Pure C# logic

Familiar and stable

Razor Pages is simpler, lighter, and more intuitive for 90% of real-world business apps.

We don't need a full Blazor runtime to update a button, form, or dashboard widget.
We just need Razor Pages to support partial DOM updates natively — the Livewire approach.

Blazor is great for complex apps.

But Razor Pages + server-driven updates is perfect for:

fintech dashboards

admin panels

onboarding flows

merchant back offices

wallet interfaces

internal enterprise tools

CRM/helpdesk platforms

multi-tenant SaaS systems

The simplicity is the strength.

A Livewire-style Razor Page engine would give .NET developers SPA interactivity
without Blazor's architectural weight
and
without JavaScript frameworks.

This is the future .NET should embrace.

[ben0707]

.NET Should Have First-Class Tailwind Support Built In
Today’s reality:

Tailwind is the #1 CSS framework globally.

It has overtaken Bootstrap, Bulma, Material, and others.

Most modern frameworks now ship Tailwind presets or templates.

.NET currently:

Has basic Bootstrap scaffolding

No Tailwind template

No official Tailwind integration

Requires Node.js or external tools to setup

This creates unnecessary friction for developers, especially beginners or teams trying to move quickly.

🚀 Why Your Recommendation Is Valid and Smart

1. Tailwind is the standard for modern UI

Tailwind is:

Faster to prototype

More flexible

Easier to maintain

Perfect for dashboards and admin panels

Perfect for Razor Pages and Blazor

Used heavily by startups and SaaS builders

It is now the industry standard.

2. Node-based Tailwind setup is a barrier for many ASP.NET developers

Many .NET developers prefer:

C#

Visual Studio / Rider

Zero JavaScript build pipelines

But today Tailwind requires:

Node

NPM

PostCSS

Build watchers

This contradicts .NET’s promise of simplicity.

3. Microsoft can solve this easily

Microsoft could provide:

✔ Built-in Tailwind bundling via .NET SDK

(No Node, no NPM)

✔ A template like:
dotnet new razor-tailwind
dotnet new mvc-tailwind

[guardrex]

Hello @ben0707 ... We only work on documentation here. Give your feedback to the product unit by opening an issue here ...

https://github.com/dotnet/aspnetcore/issues

... and BTW ... what you're asking for Microsoft already offers ... Blazor!

The docs on Blazor start here ..........

https://learn.microsoft.com/aspnet/core/blazor/

I see in a later comment that you remark on Blazor, discussing its complexity. However, Blazor is what the product unit is going recommend to you. WRT how Razor Pages could be improved, they'll probably find your remarks on that interesting, so I recommend that you open an issue for them to look at on their repo.

[ben0707]

Blazor is great, but it’s far too complex for most real-world apps.

What .NET really needs is:

1. MVC + Razor with built-in SPA functionality

No page reloads, server-driven updates, Livewire-style interaction — all in pure Razor and C#.

2. Simple, fast, familiar development

No WebAssembly, no component lifecycle overhead, no complex client runtime.

This would make .NET far more productive for dashboards, SaaS apps, admin panels, and fintech UIs.