Prism splits one framework into per-platform release lines
Prism is a framework for building loosely coupled, maintainable, and testable XAML applications in WPF, Xamarin Forms, and Uno / Win UI Applications..
At a glance
- What is it?
- Prism is a C# pattern library for XAML applications, shipping separate NuGet packages for WPF, Avalonia, .NET MAUI and Uno Platform/WinUI on independent release timelines. It gives you MVVM, dependency injection, commands and an EventAggregator, and from 9.0 it asks larger organizations to buy a commercial licence.
- Who is it for?
- Adopt Prism when your team already knows MVVM and needs the same pattern layer across more than one XAML stack, and decide the container and platform before you write the composition root. Skip it if you want a library that also gives you controls and styles, or if an undefined licence boundary is a problem for your company.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly C#, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- PrismLibrary/Prism6,873 ★ · +22
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| PrismLibrary/Prism | 6.9k | 6.9k |
22 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
One repository, five platform release lines
Prism is a single repository that publishes a different package set for every XAML stack it supports: WPF, Avalonia, .NET MAUI, Uno Platform and WinUI. The consequence is stated without hedging in the README: separate releases are available for each platform and those will be developed on independent timelines. A WPF application and an Avalonia application can therefore sit on different Prism versions at the same time, and a change landing in one platform's library does not automatically reach the others.
The shared part lives in Prism.Core, built as a cross-platform assembly against .NET Standard 2.0, .NET Framework 4.6 / 4.7 and .NET 6.0 / .NET 8.0. Prism.Events, Prism.Container.Abstractions, Prism.Container.DryIoc and Prism.Container.Unity sit in that same cross-platform group. Only the pieces that have to touch a specific UI stack are split out, which is the point of the whole arrangement: the pattern vocabulary stays identical while the implementation underneath is per platform.
The repository reflects that split at the solution level. There are five solution filters, PrismLibrary_Core.slnf, PrismLibrary_Wpf.slnf, PrismLibrary_Avalonia.slnf, PrismLibrary_Maui.slnf and PrismLibrary_Uno.slnf, alongside a PrismLibrary.slnx that spans them. Build each platform in isolation and you build one library set; build the whole solution and you are compiling five timelines at once.
That structure has a price. Because the timelines are independent, the version number alone tells you nothing about which platform libraries moved. The pattern names stay put. The surface does not.
MVVM, commands and EventAggregator, and the list that stops there
Prism describes itself as an implementation of a collection of design patterns that are helpful in writing well-structured and maintainable XAML applications, and then it names them: MVVM, dependency injection, commands, EventAggregator, and others. That is the whole advertised scope, and it deserves a close read, because neither the project description nor the README adds controls, styles, themes, a navigation shell or a visual designer to the list. Prism is plumbing, and it is honest about that.
What you get concretely is a dependency injection layer split into abstractions plus adapters for two named containers, a command abstraction, and an event mechanism.
The gap that bites hardest is documentation depth. The public documentation lives in a different repository, Prism-Documentation, under /docs, published at docs.prismlibrary.com. You are expected to read a separate site to learn what those package names imply.
For a team that already knows the patterns, that is a fair trade. For a team learning MVVM, Prism is a list of names before it is a list of classes, and the gap between the two is filled by documentation that lives somewhere else.
The container and the platform are picked by package name
Starting with version 7.0 the project moved to a separate package for each platform, and the naming rule is explicit: Prism.*Container.Platform*.dll, with Prism.Unity.Wpf.dll given as the example. The package you add is the whole configuration decision, because each supported IoC container has its own package assisting in the setup and usage of that container together with Prism.
For WPF you pair Prism.Wpf with either Prism.DryIoc or Prism.Unity. For Avalonia the container package listed is Prism.DryIoc.Avalonia. For .NET MAUI the table names Prism.Maui and Prism.DryIoc.Maui. The container implementations themselves, Prism.Container.DryIoc and Prism.Container.Unity, are cross-platform and sit next to Prism.Core and Prism.Events in the core table, so the container choice and the platform choice are two separate axes that the package names spell out.
DryIoc and Unity are not interchangeable labels over one abstraction. Picking one fixes which registration and resolution calls your composition root is written against, and the assembly carrying those calls is named after the pair. Moving later means changing the package reference and rewriting that root. In the tables, DryIoc appears under WPF, Avalonia and MAUI, while Unity appears under WPF, so a project on Avalonia has one container option in that list and a project on WPF has two.
That decision is left to you, and it is the first thing to get right.
Prism 9.0 is dual licensed and the free tier has no stated cutoff
Prism 9.0 changed the licence terms. The project is now dual licensed through the LICENSE file, the Community License remains free for what the README calls the vast majority of the community, and the Commercial License is now required by larger organizations. The wording does not define a headcount, a revenue figure or a company size, so the line between the two categories is a question for whoever sells it rather than something you can read off the page. Enterprise Support goes by email to [email protected], which is the practical route for that conversation.
The paid tier also moves the code. Commercial Plus License holders get access to a number of additional support libraries that build on top of Prism, plus a private Discord channel. Prism packages are also published to the private Commercial Plus Feed that is updated with each merged pull request, which means the newest work in the repository reaches paying users before it reaches the public NuGet packages. A critical fix shows up there first.
For a solo developer or a small team, the free Community License and the public packages are enough, though new features and critical fixes reach the Commercial Plus Feed first. For a larger organization, adopting Prism means accepting a licence whose boundary is not defined in the documentation, on a dependency that sits underneath your view models and would be a rewrite rather than a swap if you changed your mind.
This is not legal advice, and it is not meant as a recommendation. It is a boundary to confirm before you standardise a company on the framework.
StackOverflow answers are no longer the team's responsibility
Prism's support policy contains one line that should weigh heavily in an adoption decision. The team no longer supports or engages with questions posted on StackOverflow, and answers there may or may not receive correct answers. General questions go to GitHub Discussions, bugs and feature requests to the issue tracker, and enterprise support goes by email.
The course catalogue is a set of Pluralsight courses, and it dates unevenly. The current one is Introduction to Prism for WPF, the previous course is marked Legacy, and the rest of the catalogue is pinned to Prism 5.0 or to specific problems such as showing multiple shells, mastering TabControl, loading modules based on user roles and loading dependent views. Those are real design questions, and answering them is the kind of thing a pattern framework exists for, but the versions referenced are behind the current release line.
The documentation is a separate repository too. Prism-Documentation holds the docs under /docs and publishes them at docs.prismlibrary.com, so the code you bind your application to lives in one repository and the text you read lives in another. What is described there is one documentation site and no versioned path, which means matching documentation to a package version is left to you.
The repository metadata also lists no homepage field for the project. In practice, a good number of Prism answers end with reading source in another repository and matching it against the packages in this one.
The newest stable tag is 9.0.537, cut on 2024-08-20
The published release list tops out at 9.0.537, released on 2024-08-20. Before it sit two preview builds, 9.0.401-pre from 2024-02-14 and 9.0.271-pre from 2023-10-08, so the team shipped previews between stable tags rather than cutting many stable releases. The last push to the default branch, master, was on 2026-10-27. The repository is not archived, and commits have landed well after the newest stable tag was cut.
That gap is the interesting part, and it is the part with a commercial edge. More than two years of commits sit behind a stable tag that has not moved, and the documented route to fixes in that window is the private feed that updates on every merged pull request. Code taken from the public packages is two years behind the branch, and the paywalled packages are where the in-between work shows up.
The build is configured centrally rather than per project. version.json sits alongside Directory.Build.props, Directory.Build.targets, Directory.Packages.props and global.json, so version numbers and package references are managed in one place. Tests live under tests, end-to-end coverage under e2e, and xunit.runner.json with CodeCoverage.runsettings configure the run. winappsdk-workarounds.targets exists for the Windows App SDK build, which is a reminder that even the framework has to carry platform-specific build workarounds.
Continuous integration is split the same way the packages are, with separate workflows for Core, Wpf, Avalonia, Uno and Maui plus a full build. A green full build therefore says something about every platform, and a green per-platform build says something about one.
Building the source with the per-platform solution filter
Prism ships as NuGet packages, so the normal route is adding packages to your own XAML project rather than cloning anything. If you want the source instead, take the repository and build the filter that matches the stack you are actually targeting:
git clone https://github.com/PrismLibrary/Prism
cd PrismFrom there, build the solution filter for one platform rather than PrismLibrary.slnx. A full build compiles every platform's projects and every platform's toolchain, which on a machine without the mobile and Windows App SDK workloads is a long way to find out you have a missing workload. The per-platform workflows in .github already build Core, Wpf, Avalonia, Uno and Maui independently, so the filters exist for a reason.
The first-use checklist for a consumer is short and entirely made of decisions. Decide the platform. Decide between the DryIoc and Unity container packages. Add the base package that goes with them, Prism.Wpf for WPF or Prism.Avalonia, Prism.Maui or Prism.Uno for the others. Then read the docs under /docs in the Prism-Documentation repository, because that is where the API behind those package names is described, and check whether the version you pinned has moved since 2024-08-20.
Taking Prism.Container.DryIoc instead of the whole framework
The clearest alternative inside this project is to take less of it. If the only thing you want from Prism is the dependency injection half, add Prism.Container.DryIoc or Prism.Container.Unity and leave Prism.Wpf, Prism.Avalonia, Prism.Maui and Prism.Uno out. You get the container adapters and their abstractions without the rest of the pattern set, and you keep ownership of the command layer, the event aggregator and the module structure.
The difference in approach is real. Prism's adapters bind Prism's own registration and module concepts to the container you choose, which is convenient when you are already using the framework and limiting when you are not. Using DryIoc or Unity directly means the composition root is yours, and Prism's abstractions stay out of your application types.
The other axis is the platform. Avalonia, MAUI and Uno Platform with WinUI are each a full XAML stack, and Prism wraps them rather than replacing them. The README is explicit that the platform-specific pieces are implemented in the respective libraries for the target platform, so choosing Prism does not remove the platform's own APIs from your code, only adds a layer above them.
Set against hand-writing the patterns, the trade is code against ceremony: one implementation shared across five stacks with a dual licence boundary and per-platform version skew, or one implementation per application with neither of those costs.
Editorial conclusion
Adopt Prism when your team already knows MVVM and needs the same pattern layer across more than one XAML stack, and decide the container and platform before you write the composition root. Skip it if you want a library that also gives you controls and styles, or if an undefined licence boundary is a problem for your company. Before standardising, check what your platform's newest published package actually is, read the version history of the tag you plan to reference, and settle the Community versus Commercial question in writing rather than from the wording of the licence summary.
Frequently asked questions
Is Prism free to use?
Prism 9.0 is dual licensed. The Community License stays free for the vast majority of the community, while the Commercial License is now required by larger organizations. The separate Commercial Plus License adds support libraries that build on top of Prism and a private Discord channel.
Which Prism package should a WPF application reference?
Take the Prism.Wpf base package plus the container package for your chosen IoC, either Prism.DryIoc or Prism.Unity. Since version 7.0 the packages are split per platform, so install the package matching the container and the platform you picked.
Does Prism work outside WPF?
Yes. Prism.Core is a cross-platform assembly supported in .NET Standard 2.0, .NET Framework 4.6 / 4.7 and .NET 6.0 / .NET 8.0, and separate releases exist for WPF, Avalonia, .NET MAUI, Uno Platform and WinUI, each developed on independent timelines.
Where should I ask a Prism question?
The Prism team no longer supports or engages with questions posted on StackOverflow, and answers there may be incorrect. Use GitHub Discussions for general questions, the issue tracker for bugs and feature requests, and the docs in the Prism-Documentation repository for the API.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/prismlibrary-prism)Star history chart for your README
[](https://hysenlabs.com/projects/prismlibrary-prism)Was this useful?