Ant Design Pro Blazor: an enterprise dashboard template you install with dotnet new

The template ships every admin page already built

Ant Design Pro Blazor is described as an out-of-box UI solution for enterprise applications packaged as a Blazor boilerplate, and the README is mostly a list of the pages it generates for you.

The templates list is organised as a menu tree. Under Dashboard there are Analytic, Monitor and Workspace. Under Form there are Basic Form, Step Form and Advanced From. Under List there are Standard Table, Standard List, Card List, and a set of Search List pages for projects, applications and articles. Under Profile there are Simple Profile and Advanced Profile. Account brings Account Center and Account Settings. Result covers Success and Failed. Exception covers 403, 404 and 500. And User covers Login, Register and Register Result.

That list matters for the evaluation. A boilerplate is only useful if it covers the screens you would otherwise write by hand, and this one covers the standard set of an internal tool: list views with three different table shapes, three form complexities, two profile pages, an account area, and the result and exception pages that every application ends up needing. The exception pages in particular are the kind nobody wants to design and everybody ends up shipping.

The project is the .NET member of the Ant Design family, sharing the visual language of the React Ant Design Pro template, with the homepage at pro.antblazor.com. It is Apache-2.0 licensed, and the repository carries both an English README and a Simplified Chinese one.

Installing it is a dotnet new command

The template is distributed through the .NET templating system, so installation is a single command:

dotnet new install AntDesign.Templates

And removing it later is the matching command:

dotnet new uninstall AntDesign.Templates

Those two commands are the entire installation story. There is no package manager step, no Node toolchain to install before the template will work, and no separate copy of the component library, because the components come from the NuGet packages the generated project references.

Once the template is installed, you generate a project from it with the dotnet new antdesign command. The README shows the override case, where an existing project is regenerated with the force flag:

## You can override an existing project with the --force
dotnet new antdesign --host webapp --force

That comment in the code block is the project's own voice, which is a small indicator of how lightly the documentation is written. The content of the flag matters more than the tone: without it, dotnet new will refuse to overwrite a directory that already exists, and with it you replace what was there, so it is worth checking what you are about to clobber.

The repository structure is small and confirms what the project is. There is a templates.csproj at the root, a .template.config directory holding the template definition, a src directory with the AntDesign.Pro application, an AntDesign.Pro.sln solution, and a package.json for the theming tooling.

The four switches that decide what you get

The template exposes four options and they are worth reading as a group, because they cover how much you get, where it runs, how it is themed and whether it restores packages.

The full option, given as --full, generates all pages of Ant Design Pro. Its default is false, which means the default generation gives you a subset. This is the option most likely to surprise someone who expects the entire demo, and it is the first thing to change if you want the whole set of screens.

The host option, --host, specifies the hosting model and accepts webapp, wasm or server, defaulting to webapp. That choice is the architectural one in the template, since it decides whether the Blazor code runs on the server, in WebAssembly in the browser, or in the .NET hosting model. The .NET naming here is worth noting, since the server option refers to Blazor Server style hosting.

The styles option, --styles, chooses whether to use NodeJS and Less to compile your custom themes, accepting css or less, with css as the default. The Less path pulls in a Gulp pipeline, and the package.json in the repository confirms the toolchain with gulp, gulp-less, gulp-concat-css, gulp-clean-css, gulp-rename, gulp-sourcemaps, gulp-uglify, vinyl-source-stream and vinyl-buffer as dev dependencies, plus a less-plugin-npm-import for resolving imports from node_modules.

The last option, --no-restore, skips the automatic restore of the project on creation, and defaults to false, meaning the restore runs unless you opt out.

The JavaScript side exists only for theming

The package.json is small and reveals the shape of the frontend story. The name is AntDesign.Pro at version 1.6.2, the license is Apache-2.0, and the dependency list holds a single package, antd at 4.16.0 or newer.

That single antd dependency is interesting, because antd is the React component library rather than a Blazor one. It is present because the Less build imports styles from the node package, which is what the less-plugin-npm-import dependency handles. So the JavaScript toolchain in this repository is a build-time asset pipeline for theme compilation, not a runtime.

The npm scripts make the same split clear. The start script runs `dotnet watch -p ./src/AntDesign.Pro run`, which is the .NET development loop, not a JavaScript dev server. The build script runs `dotnet publish -o dist`. The gulp:pro script invokes the gulpfile inside the project directory for the theme pipeline.

The test script is the placeholder that echoes an error and exits with 1, which is the default value the .NET tooling generates when no test framework is wired in. That is worth knowing if you are evaluating the template as a starting point for a team with testing standards: the generated project does not come with a test project, and the template repository itself does not advertise one in its scripts.

Maintenance and what the release numbers say

The repository is not archived, and the last push was on 2026-10-19, days before this article, so the code is current even though the last tagged release is older.

The release history shows 1.1.4 on 2025-01-26, 1.2.1 on 2025-02-27 and 1.4.0 on 2025-05-13. The npm package version in the repository is 1.6.2, so the JavaScript asset versions have moved past the last template release. That gap between the template release number and the package version tells you the two parts of the project are released on their own cadence.

The .NET component library that the generated project depends on is a separate repository, and the version it needs is not stated in this README. The practical consequence is that you are choosing your .NET dependency versions yourself when you generate the project, and the template gives you a starting point rather than a pinned set.

What the template gives you, in licensing terms, is simple. Apache-2.0 covers both the template and the components, and the commercial Ant Design Pro products for other frameworks do not apply here because this is the open source Blazor implementation with its own site at pro.antblazor.com.

Where Ant Design Pro Blazor is the wrong choice

The first limitation is genre. Every page in the list is an admin screen, and there is nothing else. If your application is a content site, a store, a dashboard for a customer, or anything with a public-facing part, this template gives you the wrong half of the problem and none of the right half. The three form pages and the four list pages are variations on internal tooling patterns, and they do not transfer to a consumer interface.

The second is that a generated project is a fork of a template, not a dependency on one. There is no update path. When the template adds a page or the component library ships a breaking change, your copy does not receive it, because your copy is your code. Teams that expect to pull in improvements the way they pull in a NuGet package will be disappointed, and the number of pull requests against the template repository is not the kind of thing you can rely on for a dependency either.

The third is the Ant Design visual language itself. The look is defined by that design system, and using it means accepting its spacing, its density and its conventions, which is fine for internal consistency and wrong for a product with its own brand. The theming pipeline with Less and Gulp gives you a way to adjust variables, but the component behaviour and layout stay as the design system defines them.

The comparison with the alternatives is fair to make. A bare Blazor project with a component library of your choice gives you full control over both design and dependency updates, at the cost of writing every screen. The React Ant Design Pro template has a much larger community and more examples, if you are willing to be on the JavaScript side. And for a team that already has a design system, the template saves you nothing, because you are going to replace the components anyway. The template is at its best when a team wants the admin look, the page set, and a working Less pipeline on day one, and then takes ownership of the result.

Editorial conclusion

Ant Design Pro Blazor fits a team that wants the familiar Ant Design Pro admin layout in a .NET codebase without designing one page by page, and that is prepared to accept the component set and the Less or CSS theming pipeline that comes with it. It does not fit a team that needs a bespoke design system, that wants a Blazor app outside the admin genre, or that expects the template to be a maintained product rather than a starting point you own. Before generating a project, read the template options rather than accepting the defaults, since the default host model is webapp and the default styles option is plain css, and plan for the fact that the generated project is your code from the first commit rather than something you can update from upstream.

Frequently asked questions

Official sources

1. ant-design-blazor/ant-design-pro-blazor on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases