# ShadUI and the shadcn-style control library for Avalonia
> ShadUI is an Avalonia-based cross-platform UI library for C# that borrows its design language from shadcn/ui and Suki UI, shipping a default theme, a set of controls, dialogs, toasts and a composable sidebar as a NuGet package. The interesting part is the install path, where the theme has to be wired into App.xaml by hand, and the interesting constraint is that the project is still at version 0.2.x.
**accntech/shad-ui** — Avalonia-based UI Library inspired by shadcn and Suki UI Library
- Repository: https://github.com/accntech/shad-ui
- Stars: 569 · Forks: 56
- Language: C#
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/accntech-shad-ui
## What ShadUI is, and what it borrows
ShadUI is described as an Avalonia-based cross-platform UI library, and the repository description adds that it is inspired by shadcn/ui and the Suki UI Library. The stated goal is to deliver a modern, beautiful and intuitive UI library for Avalonia applications across supported platforms.
The name is the point. shadcn/ui is a React project, and a .NET developer who likes its look has generally had two options: accept that it is a web-only aesthetic, or rebuild the components by hand. ShadUI exists to close that gap, and the second inspiration, Suki UI, is itself an Avalonia library, which is why the design principles and the control ideas are described as coming from both.
The project is C#, MIT licensed, and published on NuGet as ShadUI. The primary language in the repository metadata is C#, and the solution files at the root are ShadUI.sln and ShadUI.Mac.sln, the second presumably there for a macOS-specific build.
The audience is a .NET developer building a cross-platform desktop application with Avalonia who wants a coherent visual style without assembling one. The README's framing is that the library provides a default theme out of the box, allowing you to get started quickly with a professional look and feel, and the acknowledgements are unusually specific about what the project leans on: Avalonia itself, shadcn/ui and Suki for the design, Lucide Icons for the icon set, Responsive.Avalonia for responsive layout, LiveCharts for charts, MvvmToolkit for the MVVM pattern, Jab as a compile-time dependency injection container, and AvaloniaEdit.TextMate for a syntax-highlighting text editor component.
That list is a good description of what a working Avalonia application stack looks like in 2026, and ShadUI sits on top of it rather than replacing it.
## The browser demo, and why it matters for evaluation
Before anything else, the README points you at a browser demo where you can try the full ShadUI component catalog, and it gives you the commands to run it locally.
The local run needs the WebAssembly tooling first:
```bash
dotnet workload install wasm-tools
dotnet run --project src/ShadUI.Demo.Browser/ShadUI.Demo.Browser.csproj
```
The workload install is the standard .NET step for anything that compiles to WebAssembly, and the second command starts the development server, which prints a local URL. The README then tells you to open that URL, and to publish it as a static site with `dotnet publish -c Release --project src/ShadUI.Demo.Browser/ShadUI.Demo.Browser.csproj`.
This is a genuinely useful decision for anyone evaluating the library, and it is worth spelling out why. A UI library is judged on how it looks and how the components behave, and a static site hosted on GitHub Pages lets you click through the whole catalog without installing anything, without a display server, and without writing a line of code. The same demo doubles as a usage reference once you have installed the package.
The fact that the library runs in a browser at all is a consequence of building on Avalonia rather than on WPF, and it is a fair proxy for how portable the components are. A control that renders in a WebAssembly browser is a control that does not depend on Windows-specific behaviour.
There is a third path for evaluation. The README links a ShadUI App download from the Microsoft Store for examples of how to use ShadUI controls, which is a different thing from the demo: an example application rather than a component gallery.
## Installing the package and wiring up the theme
The library setup is a NuGet add:
```powershell
dotnet add package ShadUI
```
The README notes that this installs the latest version automatically, and that you can pin one instead:
```powershell
dotnet add package ShadUI --version [version]
```
The second part is where most of the friction is, and it is worth reading carefully rather than assuming the package just works once installed. The theme has to be included in App.xaml:
```xml
```
The mechanism is XAML resource merging. The ShadTheme control has to be declared inside Application.Styles, which is Avalonia's application-wide style collection, and that is what puts the theme's resource dictionaries in scope for every control in the application. The namespace declaration is what makes the type resolvable.
There is one further recommendation that a reader should not miss. For desktop targets, the README advises using ShadUI.Controls.Window instead of Avalonia.Controls.Window to get the full ShadUI experience. That is the library's own window control rather than the platform one, and the phrasing suggests the difference is visible rather than cosmetic.
The practical implication for adoption is that there are two integration points, not one: the package reference and the styles entry. An application that adds the package but forgets the ShadTheme element will compile and run, and will look like unstyled Avalonia, which is a confusing first experience. The README does not call that failure mode out, so it is worth checking the theme element is present as soon as you start.
## The feature set: theme, controls, dialogs, toasts, sidebar
The README breaks the library into five areas, each with a demo clip in the docs folder.
The theme is the default one that ships with the package, so you get a professional look without authoring a style sheet. The controls section describes a growing set of essential UI controls, inspired by shadcn/ui and Suki UI, and it says the team is actively working to expand the library with additional controls and advanced features. That sentence is a specification of what is missing, so treat the control list as a floor rather than a ceiling.
Dialogs are described as a simple yet powerful system for creating interactive and responsive user experiences. Toasts are a built-in notification system for quick, non-intrusive messages. And the sidebar is a flexible, composable system for dynamic navigation.
The sidebar is the one worth pausing on, because composable navigation is where UI libraries tend to differ most in practice. A navigation model that you assemble from parts rather than accept as a fixed widget gives you control over grouping, expansion and item content, which is exactly what an application with more than a dozen screens needs and what a fixed menu cannot provide. It is also the component most likely to need custom work in a real application, since real navigation usually involves state that the library cannot know about.
The word to watch across all five sections is growing. The library is young, and the honest way to read the feature list is as a snapshot of a 0.2.x release rather than a finished catalogue.
## Version, licensing and the project state
The release history is short and recent. The versions are 0.2.2 from 2026-05-08, 0.2.3 from 2026-05-10 and 0.2.4 from 2026-07-17, and the last push to the repository was on 2026-07-19. The repository is not archived.
Two things follow from a 0.2.x line. The first is that the version number carries no compatibility promise, so an upgrade between 0.2.x releases can change behaviour, and the fact that the releases cluster in May and July 2026 suggests the pace will continue. Pinning a version in your project file is the sensible default, which the README's --version flag supports directly.
The second is that the API surface is still moving, so a project that binds deeply to ShadUI internals rather than to its public controls is taking on more churn than a 1.0 library would.
The licence is MIT, with the LICENSE file at the repository root, and the README states it plainly. That is the permissive end of the scale, so a commercial application can use the library, and the notice is the only obligation. The project is also described as free and open source, with no paid tier described anywhere in the README.
The governance documents are present, which is a good sign for a project with a public contribution path: CODE_OF_CONDUCT.md, CONTRIBUTING.md, SECURITY.md and PRIVACY.md sit at the root alongside the .impeccable.md file. The README asks contributors to review the contributing guidelines and the code of conduct before starting, and invites issues, feature suggestions and pull requests.
The development tooling has a sponsor worth noting: the README credits JetBrains for free use of Rider, the IDE used in development, alongside .NET and shadcn/ui.
## How this compares to Suki UI and to writing it yourself
Since ShadUI names its inspirations, the honest comparison is with Suki UI, which is the closer of the two.
Suki UI is an Avalonia library in its own right, and ShadUI's acknowledgement describes it as one of the foundations of the design principles and control ideas. So the difference is not Avalonia versus something else, it is a library that took the shadcn/ui visual language and applied it to Avalonia against one that has its own lineage in the Avalonia ecosystem. If you already use Suki UI, the question for ShadUI is whether the shadcn look is the one you want; if you are coming from shadcn/ui on the web, ShadUI is closer to what you remember.
The shadcn/ui comparison has a different character, because shadcn/ui is not a component package in the usual sense. It ships source that you copy into your own project and own from that point, rather than a dependency you install. ShadUI is the conventional model, a NuGet package you reference. That is a real trade: the copied-source model gives you total control over a component and no upgrade path, while a package gives you upgrades and a smaller surface in your own repository, and you work around the package rather than with it.
The third option is to build the look yourself in Avalonia. The acknowledgements list is the argument against that, in effect: Lucide Icons for the icon set, Responsive.Avalonia for responsive layout, LiveCharts for charts, MvvmToolkit for MVVM, Jab for compile-time dependency injection, AvaloniaEdit.TextMate for the editor. That is a considerable amount of assembly before you have a single themed control, and ShadUI's value proposition is precisely that it arrives with a theme and a set of controls rather than only with a colour palette.
One dependency deserves a specific mention. Jab is described as a fast compile-time dependency injection container without runtime dependencies. For an Avalonia application that already needs a container, that is a meaningful architectural choice rather than a styling one, and it is the kind of decision a library can make for you that you may or may not want made for you.
## Conclusion
ShadUI is a good fit for an Avalonia team that wants the visual language of shadcn/ui without the React toolchain behind it, because the package ships a default theme and the control set as a normal NuGet dependency and the browser demo lets you evaluate the whole catalog before installing anything. It is a poor fit if you need the surface to be stable, since the version line is 0.2.x and the README says the control set is still growing, and a poor fit if you want the library to be the only dependency, because the acknowledgements list Lucide Icons, Responsive.Avalonia, LiveCharts, MvvmToolkit, Jab and AvaloniaEdit.TextMate as part of the stack. Before adopting, look at the browser demo at accntech.github.io/shad-ui, and note that on desktop targets the README recommends ShadUI.Controls.Window over Avalonia.Controls.Window to get the full experience.
## FAQ
### How do I install ShadUI in an Avalonia project?
Add the NuGet package with `dotnet add package ShadUI`, or pin a version with `dotnet add package ShadUI --version [version]`. You then have to include the theme in App.xaml by declaring `` inside Application.Styles.
### Can I try ShadUI before installing it?
Yes. The README links a browser demo of the full component catalog at accntech.github.io/shad-ui, and you can run it locally with `dotnet workload install wasm-tools` followed by `dotnet run --project src/ShadUI.Demo.Browser/ShadUI.Demo.Browser.csproj`.
### What components does ShadUI provide?
The README lists a default theme, a growing set of essential controls, a dialog system, a built-in toast notification system and a flexible composable sidebar for dynamic navigation. It also notes that the team is actively working to expand the library with additional controls and advanced features.
### Do I need to use ShadUI's own window control?
For desktop targets the README recommends using ShadUI.Controls.Window instead of Avalonia.Controls.Window to get the full ShadUI experience.
### What licence is ShadUI released under?
The MIT License, with the LICENSE file at the repository root. The latest release is 0.2.4 from 2026-07-17, and the last push to the repository was on 2026-07-19.
## Sources
- [accntech/shad-ui on GitHub](https://github.com/accntech/shad-ui)
- [Issues](https://github.com/accntech/shad-ui/issues)
- [License: MIT](https://github.com/accntech/shad-ui/blob/main/LICENSE)
- [README](https://github.com/accntech/shad-ui/blob/main/README.md)
- [Releases](https://github.com/accntech/shad-ui/releases)
---
Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/accntech-shad-ui