Blazor Blueprint, nine months on: what I've learned from my first open source project

Mathew — Tue, 22 Sep 2026 11:10:31 +0000

Back in February, I wrote about why I built Blazor Blueprint: I wanted the modern, clean look of shadcn/ui in Blazor, and nothing out there gave me that. You can read that post here.

That post covered the what. This one covers what has happened since, and a bit of the backstory I didn't share at the time.

I nearly gave up on Blazor

In December 2025, my company decided to build its own commercial product, and I had to choose the technology. I wanted the whole stack in one technology, so I took a serious look at Blazor.

I liked it straight away. Building with C# end to end felt right. Making it look good didn't. I tried the existing Blazor UI libraries and just didn't like their style, and I seriously considered going back to a JavaScript frontend.

Instead, I started building my own components.

Building it alongside a real product

Looking back, the best decision was building the components while building a real product. Every component went straight into real use, so I got instant feedback on what worked and what didn't. After a while, I wondered whether other Blazor developers felt the same way I did, so I released it as open source.

The good moments

The first GitHub star. Well, the second one. The first was from me.

Then came the Reddit post. I got a lot of really positive comments and feedback, and within a week the project had passed 160 stars. For a first open source project, that meant a lot.

The part I wasn't ready for

Soon after the release, someone forked the repo and started building on my work in parallel.

I wouldn't call it stress or anxiety, but it was an uncomfortable feeling, and it stayed with me for a while. It was my first time releasing open source code, and watching someone take what I'd made and head off in their own direction felt strange.

Nine months after I started building it, and having watched Blazor Blueprint grow into what it is today, I see that moment as part of the learning curve that comes with being in the open source community.

Where it's used now

Blazor Blueprint now runs in my company's new commercial product, in several client projects and in internal tools. Here are a couple of examples I can share:

Beaacon, an anonymous analytics tool for monitoring websites without needing Google Analytics or PostHog.
Merlin, a tool for managing ISO 27001 requirements.

Both are built in Blazor. Having a large library of ready-made, good-looking components to reach into makes building fast and, honestly, fun. That's all I wanted when I started.

Where it is today

The project has gone from 160 stars in its first week to over 600. Version 4 added a lot of new components and brought it much closer to the major Blazor libraries in coverage. Version 4.1 adds:

A fully functional Scheduler
A Pivot Data Grid
Rose, Sankey and Map charts
A Signature Pad
Barcode and QR Code components
Speed and stability improvements

A Spreadsheet component is coming soon.

If you've been where I was

If you've looked at Blazor and thought, "I like this, but I can't make it look the way I want," that's exactly why this exists. Give it a try, and let me know what works and what doesn't. Feedback from real projects has shaped it from day one.

Docs: blazorblueprintui.com
GitHub: github.com/blazorblueprintui/ui

Bringing shadcn/ui to Blazor — Why I Built Blazor Blueprint

Mathew — Tue, 17 Feb 2026 15:57:19 +0000

I've been writing C# for over 20 years, mostly backend implementations, APIs, services, infrastructure etc… I built frontend too, but it always meant switching to a completely different world. C# on the backend, JavaScript on the frontend. Different patterns, different tooling, different mental models. Every project meant context switching between two ecosystems.

Then I properly dug into Blazor, and something clicked.

Being able to build full stack with C# end-to-end was genuinely enjoyable in a way I didn't expect. No more jumping between languages. No separate JS ecosystem to maintain. Just C# all the way through.

But one thing was missing.

The Gap

If you've worked with React, you've seen libraries like shadcn/ui and Radix UI. They just look and work great out of the box. They are modern, clean, composable. The kind of UI that makes you want to build things because you know that it’ll actually look good once built!

Blazor didn't have that.

Most Blazor UI libraries either look like enterprise software from 2015 or lock you into a rigid design system with their own opinions about everything. I wanted something that looked modern, felt flexible, and didn't fight me when I needed to customize it.

So I built my own.

What is Blazor Blueprint?

Blazor Blueprint is a component library inspired by shadcn/ui. It brings that same design philosophy to Blazor:

80+ styled components — buttons, dialogs, data tables, forms, charts, and more
15 headless primitives — unstyled building blocks for when you need full control
1,640+ Lucide icons — same icon set shadcn uses. I’ve also included heroicons and feather icons too
Theme compatibility — drop in any theme from shadcn/ui or tweakcn.com and it’ll just work

The key idea is a two-tier architecture.

Two-Tier Architecture

Most component libraries give you one thing: styled components. Take them or leave them.

I wanted something more flexible. So Blazor Blueprint has two layers:

Primitives - headless components that handle behavior, accessibility, and keyboard navigation with zero styling. They're the bones. Use them when you need complete control over how things look.

Components - pre-styled components built on top of the primitives. They follow shadcn/ui design patterns and work out of the box. Use them when you want to move fast.

You can use the styled components for 90% of your UI and drop down to primitives when you need something custom. Best of both worlds.

Patterns That Worked

A few implementation patterns that made the architecture work:

Cascading values for context — Parent components pass state down to children without prop drilling. An accordion item knows its parent's state without explicit wiring.

@bind- for controlled/uncontrolled state — Components work out of the box (uncontrolled) but can be fully controlled when you need it.

AsChild pattern — Lets you delegate rendering to a child element. Useful for things like making a button render as a link while keeping all the button behavior.

Theme Compatibility

One thing I really wanted was compatibility with existing shadcn themes. The React ecosystem has years of beautiful themes built for shadcn/ui. I thought it would be a waste not to tap into that.

Blazor Blueprint uses the same CSS variable structure as shadcn. You can grab a theme from shadcn/ui or tweakcn.com, drop it into your project, and it just works. No conversion needed.

One Week In

I posted about Blazor Blueprint on Reddit last week and the response genuinely surprised me. 160+ GitHub stars, mass of feedback, people actually using it in real projects.

The .NET community has been incredibly supportive. It's given me a lot of motivation to keep building. I just shipped v3 with performance improvements, new components, and fixes based on community feedback.

This is a passion project I've been pouring my evenings and weekends into. Seeing people find it useful makes all that time worth it.

Try It

Blazor Blueprint is free, open-source, and available now:

dotnet new install BlazorBlueprint.Templates
dotnet new blazorblueprint -n MyApp

Or add to an existing project:

dotnet add package BlazorBlueprint.Components

📚 Docs: blazorblueprintui.com
💻 GitHub: github.com/blazorblueprintui/ui

If you're building Blazor apps and want modern UI without the enterprise aesthetic, give it a try. Feedback and contributions welcome.

DEV Community: Mathew