# Radzen Blazor: 145+ native components for Blazor Server, WebAssembly and MAUI Hybrid

> Radzen Blazor is an MIT-licensed C# component library for Blazor, with a DataGrid, Scheduler, Charts and ten built-in themes. It is the right fit when you want native components and no JavaScript wrapper, and the wrong fit when you need premium themes or an IDE without paying for Radzen Blazor Pro.

**radzenhq/radzen-blazor** — Radzen Blazor is the most sophisticated free UI component library for Blazor, featuring 145+ native components including DataGrid, Scheduler, Charts, and advanced theming with full support for Material Design and Fluent UI. If Radzen Blazor is useful to you, a ⭐ on GitHub helps other Blazor developers find it.

- Repository: https://github.com/radzenhq/radzen-blazor
- Website: https://blazor.radzen.com
- Stars: 4,360 · Forks: 959
- Language: C#
- License: MIT
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/radzenhq-radzen-blazor

## The gap Radzen Blazor fills for Blazor teams

Blazor gives you a component model and a renderer, not a widget set. Out of the box you get an InputText and not much else, so any line-of-business screen forces you to build a grid, a date picker, a scheduler and a chart layer before you ship a single feature. Radzen Blazor is a NuGet package that supplies those pieces: the README lists 145+ native components, grouped by the maintainers into AI, Data, Forms, Layout, Navigation, Feedback, Utility and Theming.

The audience is narrow and specific. You are writing Blazor Server, Blazor WebAssembly or .NET MAUI Blazor Hybrid, your app is C# end to end, and you would rather not bolt a JavaScript widget framework onto it. The README states the library is written entirely in C# with no JavaScript framework dependencies and no wrappers, which is the claim that decides most evaluations. If your team already has a React or Angular UI layer that Blazor only hosts, the value proposition mostly evaporates.

The licence matters here too. Radzen Blazor Components is MIT licensed and free for commercial use, with no per-developer fees and no runtime royalties according to the README. That is a different commercial model from the vendor's own Pro subscription, and the split is the single most important thing to understand before you standardise on it.

## How the component library is wired into a Blazor app

There is no server, no runtime service and no proxy process. Radzen Blazor is a Razor class library: you reference the NuGet package, the components compile into your assembly, and the only shipped static asset is a JavaScript file the library needs for browser-side behaviour. The repository layout confirms this shape. Radzen.Blazor holds the component code, Radzen.Blazor.Tests and Radzen.Blazor.TrimTest sit beside it, and RadzenBlazorDemos, RadzenBlazorDemos.Server, RadzenBlazorDemos.Host and RadzenBlazorDemos.Tools make up the demo site.

Data flows the way any Blazor component data flows. You bind a collection to a component such as DataGrid, the component renders rows in the render tree, and events come back to your C# handlers. Because everything is C#, there is no interop boundary to cross for sorting, filtering or paging logic. The cost is the usual Blazor cost: the render tree lives on the server in Blazor Server, so grid interactions are round trips unless you configure otherwise.

Theming is handled by a theme service rather than by hand-written CSS. The README describes 10 built-in themes with light and dark variants, full CSS variable customisation, and a built-in theme service for runtime switching. Five themes are free (Material, Standard, Default, Humanistic, Software) and two named premium themes, Material 3 and Fluent, ship with Radzen Blazor Pro. That is a real architectural boundary inside a library that is otherwise MIT: the theming engine is open, but part of the theme catalogue is not.

## Installing Radzen Blazor and rendering a first DataGrid

The README's quick start is four steps. Add the package, import the namespaces, wire the theme and script into your root component, and register the services. The install command is a plain dotnet add:

```bash
dotnet add package Radzen.Blazor
```

Next, the README says to add two using directives to _Imports.razor so the component tags resolve without a per-file import:

```razor
@using Radzen
@using Radzen.Blazor
```

Then App.razor needs the theme component inside the head element and the script tag after the last script element. The README's example uses the material theme:

```html
<!-- inside <head> -->
<RadzenTheme Theme="material" />

<!-- after the last <script> -->
<script src="_content/Radzen.Blazor/Radzen.Blazor.js"></script>
```

Services are registered in Program.cs. Without this call, components that depend on Radzen's service layer, including dialogs and notifications, will not resolve:

```csharp
builder.Services.AddRadzenComponents();
```

A minimal component then looks like the README's button example, which binds a Click handler:

```razor
<RadzenButton Text="Hello World" Click="@OnClick" />
```

Swap that for a DataGrid once the wiring works. Point Data to an IEnumerable of your own type and add a column per property; the grid handles the header, body and paging chrome. If nothing renders, the two usual causes are a missing AddRadzenComponents call and a missing Radzen.Blazor.js script tag, because the theme and the script are separate registrations in the README's instructions.

## What the free tier does not include

The limitation is commercial rather than technical, and it is stated plainly in the README. Material 3 and Fluent are premium themes included only with Radzen Blazor Pro. If your design system is Material 3 or Fluent, the free package gives you the theming engine and five other themes, not the two you wanted. You can customise CSS variables, but you would be rebuilding the premium theme yourself.

The same subscription gates the tooling. Radzen Blazor Studio is a standalone Blazor IDE with a WYSIWYG design canvas, database scaffolding, CRUD wizards, app templates and deployment to IIS or Azure. Radzen Blazor for Visual Studio is separate Blazor tooling integrated into Visual Studio 2026. Radzen Blazor MCP is a cloud-hosted MCP server that gives AI coding assistants access to Radzen component docs, APIs and templates. None of these are in the MIT package. Dedicated support with a guaranteed 24-hour response time and priority fixes is also a Pro feature; the free path is the community forum.

There is a second, quieter constraint. The library targets current .NET and the README names .NET 10 support. The Dockerfile in the repository builds against mcr.microsoft.com/dotnet/sdk:10.0 and locates the library at lib/net10.0/Radzen.Blazor.dll. If you are pinned to an older .NET version, check the package's target frameworks on NuGet before you plan around it. The README does not document a rollback or downgrade path, so version pinning is your responsibility.

## Radzen Blazor compared with MudBlazor

The comparison people actually search for is Radzen Blazor vs MudBlazor, and the two libraries make different bets. MudBlazor is built around Material Design as its organising principle: the component set and the visual language are one decision. Radzen Blazor separates them. You get a component set and then choose from a theme catalogue, with the README listing Material, Standard, Default, Humanistic and Software as free themes plus Material 3 and Fluent as premium ones, and CSS variable customisation underneath.

That separation is the practical difference. If you want Material and nothing else, MudBlazor's tighter coupling is not a drawback. If you want a data-heavy admin application and the visual language is negotiable, Radzen's DataGrid, Scheduler, Gantt, PivotDataGrid, Spreadsheet and the long chart list (the README enumerates more than twenty chart types including Candlestick, OHLC, SankeyDiagram and GaugeCharts) are the reason to pick it. Neither library is a wrapper around a JavaScript grid, so the choice is about component coverage and theming model rather than about interop overhead.

The honest caveat is that this is a feature-surface comparison, not a performance one. Nothing in the README or the repository layout tells you how either grid behaves at high row counts, and you should measure that against your own data shape rather than trust a component count.

## Maintenance cadence, upgrade cost and the MIT licence

The repository is not archived and the last push was on 2026-09-22, the same day as the v11.4.2 release. The two preceding releases, v11.4.1 and v11.4.0, landed on 2026-09-17 and 2026-09-14. Three releases inside nine days is a fast cadence, and the README describes the intent directly: the project ships as soon as features are ready instead of batching into quarterly releases.

Fast cadence cuts both ways. You get fixes quickly, and you also get minor version bumps you need to absorb. Radzen.Blazor is a UI library, so upgrades can move rendered markup and CSS variables, which is exactly the kind of change that breaks visual regression tests. Pin the package version in your csproj and read the release notes before moving between minor versions. The README does not describe a deprecation policy or a long-term support branch, so plan for continuous upgrades rather than periodic ones.

The MIT licence is the part with the fewest surprises. It permits commercial use, and the README states there are no per-developer fees and no runtime royalties. The boundary to keep straight is that MIT covers the component library, not the Radzen Blazor Pro subscription, the premium themes, Radzen Blazor Studio, the Visual Studio tooling or the MCP server. Those are separate commercial products with their own terms. Read the LICENSE file in the repository for the actual grant, and read the Pro pricing page for the rest; this is a description of what the repository states, not legal advice.

## Conclusion

Adopt Radzen Blazor if you are building Blazor Server, WebAssembly or MAUI Hybrid and want MIT-licensed native C# components with a DataGrid, Scheduler and chart set already in the package. Do not adopt it if you need the Fluent or Material 3 themes, Radzen Blazor Studio, or guaranteed 24-hour support, because those sit behind the Radzen Blazor Pro subscription. Before committing, verify two things yourself: that your target framework is covered by the current package, and whether you can live with the free theme set (Material, Standard, Default, Humanistic, Software) or will need to pay for the premium ones.

## FAQ

### Is Radzen Blazor free?

Yes. The README states the component library is MIT licensed and free for commercial use, with no per-developer fees and no runtime royalties. The paid Radzen Blazor Pro subscription is a separate product covering premium themes, Radzen Blazor Studio, the Visual Studio tooling, the MCP server and dedicated support.

### How to install Radzen Blazor?

Run dotnet add package Radzen.Blazor, add @using Radzen and @using Radzen.Blazor to _Imports.razor, place RadzenTheme in the head and the Radzen.Blazor.js script after the last script in App.razor, then call builder.Services.AddRadzenComponents() in Program.cs.

### What is Radzen Blazor?

It is a free UI component library for Blazor, written entirely in C# and published as the Radzen.Blazor NuGet package. The README lists 145+ native components including DataGrid, Scheduler, Gantt, Spreadsheet and Charts, and states support for Blazor Server, Blazor WebAssembly and .NET MAUI Blazor Hybrid.

### What is Radzen Blazor Studio?

According to the README, it is a standalone Blazor IDE included with the Radzen Blazor Pro subscription. It provides a WYSIWYG design canvas, database scaffolding, CRUD wizards, app templates, and deployment to IIS or Azure. It is not part of the MIT-licensed component package.

### Which is better for coding, MudBlazor or Radzen Blazor?

The README does not compare the two, so the honest answer is that it depends on your theming model. MudBlazor couples its components to Material Design, while Radzen Blazor ships a component set plus a theme catalogue, with Material 3 and Fluent available only through Radzen Blazor Pro.

### Is Radzen Blazor Studio free?

No. The README lists Radzen Blazor Studio as part of the Radzen Blazor Pro subscription, alongside the Visual Studio tooling, the MCP server, premium themes and dedicated support. The MIT-licensed Radzen.Blazor component package is the free part.

## Sources

- [License: MIT](https://github.com/radzenhq/radzen-blazor/blob/master/LICENSE)
- [Project website](https://blazor.radzen.com)
- [radzenhq/radzen-blazor on GitHub](https://github.com/radzenhq/radzen-blazor)
- [README](https://github.com/radzenhq/radzen-blazor/blob/master/README.md)
- [Releases](https://github.com/radzenhq/radzen-blazor/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/radzenhq-radzen-blazor