Framework
stephenmcd/mezzanine avatar
stephenmcd/mezzanine

Mezzanine: a Django CMS whose features ship enabled by default

CMS framework for Django

4,813 stars1,601 forksPythonBSD-2-Clause

At a glance

What is it?
Mezzanine is Stephen McDonald's content management platform built on Django, and its central decision is the one it makes against WordPress: rather than assembling a site from modules and reusable applications, it provides most of its functionality out of the box. That is why pages, blog, forms and scheduled publishing are in its feature list, while ecommerce comes from the separate Cartridge module.
Who is it for?
Adopt Mezzanine if you want a Django project that is editable from the front page on day one, with drafts, scheduling, tagging, forms and an admin dashboard already working, and you would rather fork a project than assemble plugins. Do not adopt it if you want features you do not use to stay out of the way, because the default-everything approach means turning something off is a code change rather than an uninstall.
Can I use it commercially?
Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 7 months ago.
What is it written in?
Mainly Python, 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.

From daily snapshots

Star history

  • stephenmcd/mezzanine4,813 ★ · -3
Star history
Repository2026-09-232026-11-15
stephenmcd/mezzanine4.8k4.8k

-3 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The design bet is that most functionality ships enabled

The README draws the comparison with WordPress and then rejects the part of it that matters. Mezzanine offers the same intuitive interface for managing pages, blog posts, form data, store products and other content types, but unlike platforms that make extensive use of modules or reusable applications, it provides most of that functionality by default. The claimed result is a more integrated and efficient platform. The other side of that bet is rarely stated and matters more in practice: a feature you never wanted is not an application you can uninstall, it is code in the framework you have to configure, override or edit. For a team that intends to fork the project, that is a good trade. For a team assembling a site from parts, it is the opposite.

Django supplies the framework, Mezzanine supplies the content layer

The feature list starts by crediting Django for what a web framework already does: MVC architecture, an ORM, templating, caching and an automatic admin interface. Everything after that is Mezzanine's own contribution, and the list is long enough to show the shape of the product: hierarchical page navigation, save as draft with preview on site, scheduled publishing, drag-and-drop page ordering, WYSIWYG editing, in-line page editing, SEO friendly URLs and meta data, a blog engine, tagging, user accounts and profiles with email verification, configurable dashboard widgets, an API for custom content types, a search engine with its own API, and multi-lingual sites. It is translated to over 35 languages, runs on a JVM through Jython, and includes a one step migration path from other blogging engines.

Ecommerce is Cartridge, and the themes marketplace is elsewhere

Two things named in the feature list live outside the package. The ecommerce and shopping cart module is Cartridge, hosted at its own site. The free themes marketplace is a separate GitHub project. The feature list also names a set of integrations: Disqus or built-in threaded comments, Gravatar, Google Analytics, bit.ly for link shortening, Akismet for spam filtering, and Twitter Bootstrap for styling.

Editing happens in the page, publishing happens on a schedule

The editing model is where a front-end CMS earns its keep. In-line page editing puts the WYSIWYG editor into the page itself, so an edit does not require opening a separate admin screen, and drafts can be saved and previewed on site before anyone sees them. Scheduled publishing moves the step after that into the future, and drag-and-drop page ordering handles the hierarchy that hierarchical page navigation renders. Custom templates can be attached per page or per blog post, which is the escape hatch that keeps a hierarchical tree from dictating one layout for the whole site. The dashboard widgets are configurable, which is the other place an editor spends time.

Forms are built by dragging and leave as CSV

The forms builder is a drag-and-drop HTML5 form builder with CSV export, and form data sits alongside pages and blog posts as one of the content types the admin manages. That combination is the practical argument for this CMS over a blog engine with a plugin bolted on: submissions are content, they appear in the same admin, and they can be handed to something else as a spreadsheet when the person receiving them does not want database access. The CSV export is the hand-off point, and it is also the constraint: a form that needs branching logic, file uploads with processing, or a workflow belongs in code rather than in the builder, and the README says nothing about those cases.

setup.py is three lines and the packaging lives in setup.cfg

The repository's packaging is split across a few files. `pyproject.toml` contains nothing but a Black configuration, listing the directories to exclude from formatting, and `setup.py` is three lines that import setuptools and call `setup()` with no arguments, so the package metadata lives in `setup.cfg` alongside `MANIFEST.in`. Around them sit the files a maintained library accumulates: `CHANGELOG`, `AUTHORS`, `CONTRIBUTING.rst`, `pytest.ini`, `tox.ini`, `.coveragerc` and `.isort.cfg`, plus `docs/` for the documentation, `mezzanine/` for the package and `tests/` for the suite. `.releaserc` and `.tx/` also sit at the top level. The distribution is on PyPI as `mezzanine`, reached from the badges at the top of the README.

Two version control systems, and a private channel for security bugs

Mezzanine is managed with both Git and Mercurial, hosted on GitHub and BitBucket respectively, and the tree still carries `.hgignore` and `.hgtags` beside `.gitignore`, so both histories are real and contributing means forking on whichever host you prefer. Support is split by kind of problem. Security issues go by private email to the address given in the README, specifically so the project can fix the issue and cut an official release before it becomes public. Everything else belongs on the mezzanine-users mailing list, and the GitHub issue tracker is for bugs you are certain about, ideally with a small sample repository someone can fork and run, plus the stack trace, operating system, database and Python version. If you are not sure it is reproducible, the README asks you to start at the mailing list. Communications in Mezzanine spaces are expected to follow the Django Code of Conduct, and there is an IRC channel on Freenode for chat. Releases are v6.0.1, v6.1.0 and v6.1.1, the last on 2025-06-04, with the last recorded push dated 2026-04-19 and a BSD-2-Clause license.

Editorial conclusion

Adopt Mezzanine if you want a Django project that is editable from the front page on day one, with drafts, scheduling, tagging, forms and an admin dashboard already working, and you would rather fork a project than assemble plugins. Do not adopt it if you want features you do not use to stay out of the way, because the default-everything approach means turning something off is a code change rather than an uninstall. Verify first which optional pieces you actually need, since ecommerce is Cartridge, the themes marketplace is separate, and several integrations are named in the README without being described.

Frequently asked questions

What is Mezzanine the CMS?

A content management platform built on the Django framework, created by Stephen McDonald and BSD licensed. It manages pages, blog posts, form data, store products and other content types, and it provides most of that functionality by default rather than assembling it from modules and reusable applications.

Does Mezzanine build on Django?

Yes. Mezzanine is built using Django and inherits what Django provides: MVC architecture, an ORM, templating, caching and an automatic admin interface. Mezzanine adds the content layer, including page navigation, drafts and preview, scheduled publishing, tagging, forms and a blog engine.

Does Mezzanine include a shopping cart?

Not in the core package. The ecommerce and shopping cart module is Cartridge, a separate project. The free themes marketplace is separate too, and the README lists Disqus, Gravatar, Google Analytics and bit.ly integration and Akismet spam filtering among its features.

How do I report a security issue in Mezzanine?

Send it privately by email to the address named in the README, so the project can fix it and cut an official release before the issue is made public. Everything else goes to the mezzanine-users mailing list, with the GitHub issue tracker reserved for bugs you can reproduce with a sample repository and a stack trace.

Official sources

  1. License: BSD-2-Clause
  2. Project website
  3. README
  4. Releases
  5. stephenmcd/mezzanine on GitHub
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/stephenmcd-mezzanine.svg)](https://hysenlabs.com/projects/stephenmcd-mezzanine)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/stephenmcd-mezzanine.svg)](https://hysenlabs.com/projects/stephenmcd-mezzanine)

Was this useful?