Piranha.Core is the open-source, MIT-licensed Content Management System for .NET that runs either as an integrated CMS inside an ASP.NET Core application or as a headless content API for a separate front end, and it is built for .NET developers and editorial teams who want a code-first CMS they host themselves rather than a hosted SaaS product.
What it is
Piranha.Core is a decoupled, cross-platform CMS written in C# and built for .NET 8 on top of Entity Framework Core. It has a modular and extensible architecture and supports a wide range of hosting and deployment scenarios, which is why the same core can be mounted directly into a web application as a full editor-facing CMS or exposed as a headless API that serves content to whatever front end a project already uses. The repository carries the topics asp-net-core, asp-net-core-mvc, asp-net-core-razor-pages, cms, cms-framework, dotnet-core, dotnet6, entityframeworkcore and piranha, and the project is published under the MIT licence.
The concrete problem it solves is the content management layer that an ASP.NET Core team would otherwise have to write and maintain itself. Instead of hand-building page, post and media management against Entity Framework Core, a team installs the project templates from NuGet and gets a Manager interface together with the routing, storage and content model already wired into the application. The same installation can be run in headless mode, so the content store is not tied to a particular rendering stack.
Key capabilities
- Runs in two modes from one codebase: an integrated CMS mounted inside the host application, or a headless API for external front ends.
- Ships project templates on NuGet, installed with
dotnet new install Piranha.Templates and scaffolded with commands such as dotnet new piranha.razor.
- Provides the Manager editor interface at the
~/manager URL.
- Targets ASP.NET Core with support for Razor Pages and MVC, as reflected in the
asp-net-core-razor-pages and asp-net-core-mvc topics.
- Persists content through Entity Framework Core, the subject of its own topic tag.
- Has a modular and extensible architecture, with localization handled through the Crowdin project.
- Builds and tests on both Windows and Linux through GitHub Actions workflows.
Who uses it and how
- .NET teams that want an editor-facing administration area at
~/manager inside an application they already own, without adopting an external CMS service.
- Projects that deploy headless, publishing content through the API and rendering it in a separate front end.
- Cross-platform deployments, since the project builds on Windows and Linux and is described as decoupled and cross-platform.
- Evaluators and new adopters who start from the
examples/MvcWeb sample, which is run with dotnet run after dotnet restore and dotnet build.
- Teams that customize the editor experience, running
npm install followed by gulp min:js and gulp min:css inside core/Piranha.Manager to build and update the JavaScript and CSS assets.
Getting started
Prerequisites are the .NET 8.0 SDK and an IDE or editor of choice. Install the templates with dotnet new install Piranha.Templates in an empty folder and scaffold a Razor Pages project with dotnet new piranha.razor, or clone the repository, run dotnet restore and dotnet build, then dotnet run from examples/MvcWeb.
How it compares
The facts provided name no paid products that this project replaces, and they name no directly comparable tools. Piranha.Core therefore stands alone in this registry on the evidence available.
When to use it — and when not to
A self-hoster must run the .NET 8 runtime, operate the Entity Framework Core database behind the content store, and run the Node and gulp asset pipeline when the Manager front end is customized. The default Manager credentials are admin / password, and the README advises removing that user or changing the password and updating the password strength policy in production, so anyone unwilling to harden authentication should not deploy it as-is. Teams outside the .NET and ASP.NET Core ecosystem, and teams that want a managed hosted service instead of an application they operate, are better served elsewhere; minor friction is also documented, including a dotnet restore failure when a project is named Piranha, and the topic list still carries dotnet6 while the README states .NET 8.
project readme (upstream, from github) — read inline
Welcome to Piranha.Core
About
Piranha CMS is a decoupled, cross-platform CMS built for .NET8 and Entity Framework Core. It has a modular and extensible architecture and supports a multitude of hosting and deployment scenarios.
Getting started
Prerequisites
Create a new project from our templates
To use our project templates you first need to download and install them from NuGet. This can be done with:
dotnet new install Piranha.Templates
When creating a new project with dotnet new you should first create a new empty folder. The default behaviour is that the new project is named after its containing folder.
Please note that naming your project Piranha (even if it is a test project) will result in a circular reference error when you try to restore the packages. This is due to a limitation in dotnet restore.
After this is done you can create a new web project for razor pages with:
dotnet new piranha.razor
To read more about of our available project templates, please read more on https://piranhacms.org/docs/basics/project-templates
Get the latest source code and get going
> git clone https://github.com/PiranhaCMS/piranha.core.git
> cd piranha.core
> dotnet restore
> dotnet build
> cd examples/MvcWeb
> dotnet run
Log into the Manager
The manager interface can be found at the URL ~/manager with the default credentials:
admin / password
For production scenarios we advise you to remove this user, or change the password
and update the password strength policy. More information on this can be found in
the official documentation here.
Build and update javascript/css assets
> cd piranha.core/core/Piranha.Manager
> npm install
> gulp min:js
> gulp min:css
Backers
Support Piranha CMS with a monthly donation and help us focus on giving you even more features and better support. Piranha CMS @ Open Collective
Sponsors
These are our financial sponsors! You can also become a sponsor either through GitHub or Open Collective.
Code of Conduct
This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community.
For more information see the .NET Foundation Code of Conduct.
.NET Foundation
This project is supported by the .NET Foundation.
