# ZKEACMS: a visual design CMS on .NET 9

> ZKEACMS is a C# content management system where pages are assembled by dragging rows, columns and widgets instead of writing templates. It targets .NET teams that want an admin-side page builder, and it carries a GPL-3.0 licence with a paid path for closed-source commercial use.

**SeriaWei/ZKEACMS** — ZKEACMS build with .Net 8 (.Net CMS)可视化设计在线编辑内容管理系统

- Repository: https://github.com/SeriaWei/ZKEACMS
- Website: http://www.zkea.net/cms
- Stars: 2,841 · Forks: 859
- Language: C#
- License: GPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/seriawei-zkeacms

## The problem ZKEACMS solves, and who ends up using it

Most CMS platforms split work between a developer who writes templates and an editor who fills them in. Every new page layout becomes a developer ticket. ZKEACMS takes the opposite position: the repository describes it as a visual design, WYSIWYG content management system, and the README's own screenshots show page design and adding content to a page as the two headline workflows. Layout is built from rows and columns on a Bootstrap 3 grid, and content is placed as widgets, which the README calls HTML components. Multiple widgets can sit in the same zone and be reordered by drag and drop.

The audience follows from that. It suits a .NET shop that already has SQL Server, MySQL or SQLite in production and wants marketing or content staff to compose landing pages without a deploy. It is a poor fit for a team that wants a headless CMS returning JSON to a separate front end, because the whole design assumes the CMS renders the page. It is also a poor fit for anyone who needs a permissive licence: the project is GPL-3.0, and the README states that commercial users keep source private by purchasing a commercial or Enterprise licence.

## How a page is assembled: zones, widgets and Bootstrap 3 rows

The architecture is MVC on .NET, and the repository topics list cms, cms-framework, mvc-cms and netcore-mvc. The README describes three layers. A layout defines the zones of a page, and the user drags rows and columns to shape it on the Bootstrap 3 grid. Widgets are then dropped into those zones; the README notes they can be sorted by drag and drop inside a zone. Themes sit underneath and are written in LESS on top of Bootstrap, so changing theme variables is the intended way to restyle a site rather than editing compiled CSS.

The build pipeline matches that split. The root package.json exists to compile theme assets, minify JavaScript and style sheets, and it pins gulp 5 with gulp-less, gulp-clean-css and gulp-uglify-es as dev dependencies. So a theme change is a Node build step, not a runtime setting. The repository also carries ARCHITECTURE.md and AGENTS.md at the top level, which is where the maintainers put the structural description; the README itself stays at the level of feature screenshots and links.

## Installing ZKEACMS and publishing a first build

The README points at .NET 9 SDK for development, with Microsoft SQL Server 2016+, MySQL 5.6+ or SQLite 3 as the database, and Visual Studio 2022 or Visual Studio Code as the editor. The supported install path for a release build is the ZKEACMS.Publisher dotnet tool, installed globally:

```bash
dotnet tool install -g ZKEACMS.Publisher
```

From there the repository ships a wrapper script rather than a raw dotnet publish. Run it from the WebHost project directory:

```bash
./src/ZKEACMS.WebHost/publish-zkeacms
```

To produce a self-contained output for a specific platform, the README adds a runtime flag. This is the form you would use when the target machine has no .NET runtime installed:

```bash
./src/ZKEACMS.WebHost/publish-zkeacms -r win-x64
```

The README also mentions Publish.cmd and Publish.sh at the repository root as alternatives to the tool. What you should see after either route is a publish output directory under the WebHost project; the Dockerfile confirms the layout by copying from bin/Release/PublishOutput, which is where the published site and its appsettings.json end up. On first run the site needs a database, and the Dockerfile shows the SQLite route: it creates App_Data, loads Database/SQLite/ZKEACMS.sqlite.sql into Database.sqlite, and copies Database/SQLite/appsettings.json over the published one.

## Running the Docker image and switching the admin to English

The project publishes an image on Docker Hub under the zkeasoft account. The README gives a single command, mapping container port 8080 to host port 5000:

```bash
docker run -d -p 5000:8080 zkeasoft/zkeacms:ent
```

That tag is the one the README shows; the Dockerfile in the repository builds the same shape of image from mcr.microsoft.com/dotnet/aspnet:9.0, exposes 8080, and its entrypoint copies Database.sqlite into App_Data only if it is not already there, then runs dotnet ZKEACMS.WebHost.dll. The cp -n in that generated run.sh is what makes a mounted volume survive a restart.

If the admin comes up in Chinese, the README says to change the culture code to en-US in appsettings.json:

```json
"Culture": {
  "Code": "en-US"
}
```

This is a configuration change, not a UI toggle, so on a container you either bake it into the image or mount an appsettings.json that carries it. The README documents no admin setting that does the same thing.

## Where ZKEACMS gets in your way

The upgrade story is the weakest part. The repository ships releases as versioned tags, v4.2 in November 2024, v4.3 in May 2025 and v4.4 in May 2026, so roughly one release a year. The README says nothing about migrating a database between those versions, and the Dockerfile's approach of loading a fresh ZKEACMS.sqlite.sql suggests a clean install rather than a migration path. If you run ZKEACMS long enough to cross a major version, you are on your own until the wiki or release notes say otherwise.

There is also a version mismatch worth noticing. The README title says .NET 9, the Dockerfile and the development prerequisites both say .NET 9, but the repository description still says .NET 8. The description is the stale one, but it is the line most people read first.

Two smaller constraints. The layout system is Bootstrap 3, which is an old grid; teams standardised on Bootstrap 5 will be working against the theme rather than with it. And theming runs through a gulp build with gulp-less and gulp-uglify-es, so anyone editing a theme needs Node and the dev dependencies installed, not just the .NET SDK. The README does not document a rollback procedure for a bad publish, and the last push to the repository was on 2026-08-09.

## ZKEACMS against a code-first .NET CMS such as Orchard Core

The natural comparison is Orchard Core, the other well-known .NET CMS. The difference is where the page definition lives. Orchard Core leans on code and content-type definitions, with Liquid templates and a module system for developers to extend. ZKEACMS puts the layout in the admin UI: rows and columns on a Bootstrap 3 grid, widgets dropped into zones, drag and drop to sort. That means a non-developer can produce a new landing page in ZKEACMS without a deployment, which is exactly the trade Orchard Core makes in the other direction.

The cost is extensibility. A widget in ZKEACMS is an HTML component, and adding a genuinely new one is a .NET development task against the CMS's own model, whereas Orchard Core's module and template story is documented in far more depth. If your site is mostly articles and a few fixed templates, ZKEACMS's builder is more machinery than you need. If your site is mostly campaign pages that marketing rebuilds monthly, the builder is the reason to pick it.

## Conclusion

Adopt ZKEACMS if your team already runs .NET 9 and wants editors to assemble pages from widgets rather than wait on template work. Do not adopt it if you need a documented rollback path, a published upgrade procedure between major versions, or a permissive licence for a closed-source product. Before committing, verify three things on the demo site and in a local SQLite build: that the widget set covers your page types, that the Culture code switch to en-US actually changes the admin interface, and that your legal team accepts GPL-3.0 or you buy the commercial licence.

## FAQ

### What database does ZKEACMS support?

The README lists Microsoft SQL Server 2016 or later, MySQL 5.6 or later, and SQLite 3. The Dockerfile uses the SQLite route, loading Database/SQLite/ZKEACMS.sqlite.sql into Database.sqlite and copying Database/SQLite/appsettings.json into the publish output.

### How do I run ZKEACMS with Docker?

The README gives one command, docker run -d -p 5000:8080 zkeasoft/zkeacms:ent, which maps container port 8080 to host port 5000. The image is published under the zkeasoft account on Docker Hub.

### Can I use ZKEACMS in a commercial closed-source product?

The project is licensed GPL-3.0. The README states that commercial users keep their source private or proprietary by purchasing a Commercial License or Enterprise Edition, and links to a wiki page for that purchase.

### How do I switch the ZKEACMS interface to English?

Set the culture code to en-US in appsettings.json under the Culture section, as shown in the README. It is a configuration file change rather than an option inside the admin interface.

### What do I need installed to develop ZKEACMS?

The README lists the .NET 9 SDK, one of the supported databases, and either Visual Studio 2022 or Visual Studio Code. Theme work additionally needs the Node dependencies in the root package.json, which compile LESS and minify assets through gulp.

## Sources

- [License: GPL-3.0](https://github.com/SeriaWei/ZKEACMS/blob/master/LICENSE)
- [Project website](http://www.zkea.net/cms)
- [README](https://github.com/SeriaWei/ZKEACMS/blob/master/README.md)
- [Releases](https://github.com/SeriaWei/ZKEACMS/releases)
- [SeriaWei/ZKEACMS on GitHub](https://github.com/SeriaWei/ZKEACMS)

---

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