# Orchard Core: a modular ASP.NET Core framework and CMS, and when it fits

> Orchard Core splits into an application framework and a CMS built on top of it. This review covers how the module and tenant model works, how to install it from NuGet or Docker, and where it stops being the right tool.

**OrchardCMS/OrchardCore** — Orchard Core is an open-source modular and multi-tenant application framework built with ASP.NET Core, and a content management system (CMS) built on top of that framework.

- Repository: https://github.com/OrchardCMS/OrchardCore
- Website: https://orchardcore.net
- Stars: 8,191 · Forks: 2,601
- Language: C#
- License: BSD-3-Clause
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/orchardcms-orchardcore

## Orchard Core is two projects, and the split decides whether you want it

The README draws a line that most CMS comparisons skip. Orchard Core is not one product. It is an application framework for building modular, multi-tenant applications on ASP.NET Core, and separately a CMS built on top of that framework. That sentence is the whole adoption decision.

If you are building a line-of-business application and want content editing, tenancy and a module system as libraries, you take the framework and ignore the CMS shell. If you want a website with an admin UI, you take the CMS, which is the framework plus a set of built-in modules. The same repository ships both, so the boundary is a packaging choice rather than a fork.

Who this is for: .NET teams. The primary language is C#, the build targets modern .NET, and every extension point is a C# module. Teams coming from PHP-based CMS platforms will find the concepts familiar but the tooling entirely different. The project is supported by the .NET Foundation and licensed BSD-3-Clause, which matters if you plan to redistribute a modified build.

## Modules, tenants and the ASP.NET Core host

The architecture visible in the repository is a standard ASP.NET Core web application plus a module discovery layer. OrchardCore.slnx sits at the root, source lives under src/, and the CMS web host is a single project, src/OrchardCore.Cms.Web/OrchardCore.Cms.Web.csproj. The Dockerfile publishes exactly that project, which tells you the CMS is a normal web app that happens to load modules.

Multi-tenancy is a first-class concept rather than an add-on. The framework describes itself as multi-tenant, meaning one running host can serve several sites with separate content, and the documentation points to a reference of built-in modules for what ships in the box. That reference is the honest inventory: before writing anything, read it, because a large share of what teams build by hand in other systems already exists as a module here.

The frontend is not an afterthought either. package.json defines a Yarn 4 workspace with assets-manager scripts, and the workspaces list points at src/OrchardCore.Modules/*/Assets/** and src/OrchardCore.Themes/*/Assets/**. Modules and themes carry their own asset pipelines, built through the assets-manager tooling rather than a single global bundler config. That is a real structural difference from CMS platforms where theme assets are assembled by one site-wide build.

## Installing Orchard Core and running the CMS locally

The README does not print install commands. It points to the getting started documentation at docs.orchardcore.net, and to a test drive page for readers who want to try the CMS as a user before writing code. The two distribution channels named in the repository are NuGet, via the OrchardCore.Application.Cms.Targets package, and Docker, via the Dockerfile at the repository root.

The Dockerfile is the most concrete install path in the repository. It builds with the .NET 10 SDK, publishes the CMS web project for net10.0, and runs on the ASP.NET Core 10 runtime image. The relevant lines are these:

```dockerfile
FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:10.0 AS build-env
RUN dotnet publish src/OrchardCore.Cms.Web/OrchardCore.Cms.Web.csproj -c Release -o /app --framework net10.0 /p:RunAnalyzers=false
FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS build_linux
EXPOSE 80
ENV ASPNETCORE_URLS=http://+:80
ENTRYPOINT ["dotnet", "OrchardCore.Cms.Web.dll"]
```

Two things to note before you copy it. The image exposes port 80 and sets ASPNETCORE_URLS to http://+:80, so a container run needs that port published. And the build stage disables Roslyn analyzers with /p:RunAnalyzers=false to keep the image build fast; if you want analyzer output, drop that property.

If you prefer the SDK route, the package named in the README is OrchardCore.Application.Cms.Targets, and the getting started docs describe creating an application from it. The README does not reproduce those commands, so treat the documentation site as the source of truth for the exact template invocation and the first-run setup screen.

## Where Orchard Core is the wrong tool

The framework and CMS split is the main source of friction. If you only need a brochure site, you are adopting a modular application framework to render a handful of pages, and you will pay for that in build complexity, module discovery and an admin surface you barely touch. A static site generator or a lighter CMS will get you there with fewer moving parts.

The second limit is the toolchain. The frontend build is Yarn 4 with a custom assets-manager, and the backend is C# on a specific .NET version. The Dockerfile targets net10.0 and the .NET 10 SDK. A team without .NET experience is not going to extend this by editing templates; they will be learning a framework. That is a staffing constraint, not a defect, but it decides the answer for many organisations.

The third is documentation depth. The README is a signpost, not a manual. It links to docs.orchardcore.net for getting started, to a built-in module reference, and to a Gurubase AI assistant for questions. It does not document rollback, upgrade procedures between major versions, or database migration behaviour. If your adoption decision depends on a documented upgrade path from v2.x to v3.x, the README will not settle it and you should read the release notes and milestones directly.

## Orchard Core versus Umbraco: the difference is the framework layer

Umbraco is the comparison people search for, and the distinction is structural rather than cosmetic. Both are .NET CMS platforms with an admin UI, both target ASP.NET Core, and both expect C# developers. The difference is what sits underneath.

Orchard Core is explicitly two products: a multi-tenant application framework, and a CMS built on that framework. The framework is usable on its own for non-CMS applications, which is why the README describes it that way instead of calling the whole thing a CMS. Umbraco is positioned as a CMS first; its extension model exists to serve the content application, not to be a general application framework you adopt independently.

That changes what you get for free. If your roadmap includes multi-tenant SaaS behaviour, background processing or custom modules that have nothing to do with publishing pages, Orchard Core's framing suggests those concerns are in scope from the start. If your roadmap is a marketing site with editors, the extra layer is overhead. Neither answer is universal, and the repository does not claim otherwise.

The second axis is licensing. Orchard Core is BSD-3-Clause, a permissive licence that allows modification and redistribution. If you need to ship a modified CMS inside a commercial product, check the licence text yourself; this is a description of the identifier, not legal advice.

## Maintenance, releases and what an upgrade costs

The last push to the repository was on 2026-09-21, one day before this writing, so the project is not dormant. The release history shows v3.0.1 on 2026-07-09, v3.0.0 on 2026-06-18, and v2.2.1 on 2025-10-07. Two things follow from those dates. First, the 3.0 line is recent and already has a patch release, which is the normal shape after a major version. Second, the gap between v2.2.1 and v3.0.0 is roughly eight months, so major versions are not frequent, and a team that adopts 3.0 should expect to sit on it for a while rather than chase releases.

The README states the software is production-ready and that the maintainers are not aware of fundamental bugs or missing features they deem crucial. Treat that as the maintainers' assessment, not an independent audit. The build status section separates a stable release branch, release/3.0, from a nightly main branch, and preview packages come from a Cloudsmith feed rather than the default NuGet source. If you run preview builds, you are opting into a separate package source with its own configuration.

Upgrade cost is the part the README does not cover. There is no documented migration procedure in the repository, so the practical answer is to read the release notes for each version you cross and check the issue milestones for what is planned. Budget for it explicitly: a CMS with a module ecosystem means third-party or in-house modules can lag a major release, and the repository gives no compatibility matrix.

## What to check before you commit

Start with the built-in module reference the README links to. It is the fastest way to find out whether the features you plan to build already exist, and that inventory should shape your estimate more than any architecture diagram.

Then confirm your runtime. The Dockerfile builds and runs on .NET 10, publishes for net10.0, and listens on port 80 with ASPNETCORE_URLS=http://+:80. If your hosting platform or base image policy pins an older runtime, that is a blocker you want to find on day one, not after a proof of concept.

Finally, decide which of the two projects you are adopting. Teams that take the CMS when they needed the framework, or the reverse, end up carrying the other half as dead weight. The README states the split plainly; the mistake is reading past it.

## Conclusion

Adopt Orchard Core if your team already writes C# and ASP.NET Core and you want content and tenancy as composable modules rather than a fixed admin product; the release notes put the current line at v3.0.1 on .NET 10, and the BSD-3-Clause licence keeps redistribution open. Do not adopt it if you have no .NET skills in house, need a PHP-style theme marketplace, or want a small static site, because the framework and CMS split will be weight you never use. Before committing, verify three things on your own machine: that your hosting platform can run the net10.0 image the Dockerfile targets, that the built-in module reference covers the features you would otherwise write yourself, and that your database and media storage choices match what you intend to run in production.

## FAQ

### What is Orchard Core?

It is an open-source, modular, multi-tenant application framework and CMS for ASP.NET Core, licensed BSD-3-Clause. The repository describes it as two projects: the Orchard Core Framework for building modular applications, and the Orchard Core CMS built on top of that framework.

### How do I install Orchard Core CMS?

The README points to the getting started documentation at docs.orchardcore.net rather than printing commands. The two distribution channels named in the repository are the OrchardCore.Application.Cms.Targets NuGet package and the Dockerfile at the repository root, which publishes the CMS web project for net10.0.

### How does Orchard Core compare with Umbraco?

Both are .NET CMS platforms that expect C# developers. Orchard Core is explicitly split into an application framework and a CMS built on it, and it describes itself as multi-tenant, so the framework layer is usable for non-CMS applications; Umbraco is positioned as a CMS first. Orchard Core is BSD-3-Clause.

### Is Orchard Core an alternative to WordPress?

It occupies the same category, a CMS with an admin interface, but the stack is different: Orchard Core is C# on ASP.NET Core with modules and themes as .NET projects, while WordPress is PHP. The repository does not compare the two, so the choice comes down to whether your team works in .NET.

## Sources

- [License: BSD-3-Clause](https://github.com/OrchardCMS/OrchardCore/blob/main/LICENSE)
- [OrchardCMS/OrchardCore on GitHub](https://github.com/OrchardCMS/OrchardCore)
- [Project website](https://orchardcore.net)
- [README](https://github.com/OrchardCMS/OrchardCore/blob/main/README.md)
- [Releases](https://github.com/OrchardCMS/OrchardCore/releases)

---

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