Home Philosophy Release Notes E-commerce with Umono View on GitHub
Build websites that stay maintainable after launch.
Umono is an open source CMS for developers, freelancers and agencies who are tired of fragile site architecture, theme lock-in and plugin-driven complexity. It helps you build websites with clear boundaries between content, themes and functionality, so projects remain easier to change, safer to customize and more predictable over time.
Most CMS projects do not become painful because content is hard. They become painful because content, themes and plugins get tangled together over time.
A redesign starts touching content.
A plugin change starts affecting presentation.
A small customization turns into long‑term maintenance debt.
What felt fast at the beginning becomes fragile later.
Umono is built around a different idea:
Content, themes and plugins should not own each other.
That separation creates clearer boundaries, reduces lock‑in and makes websites easier to understand after launch not only during development.
Keep content, presentation and functionality in separate layers so each
part can evolve with less risk.
Reduce the cost of changing how your website looks or behaves later.
Make changes without dragging old architectural decisions into every new feature.
Build websites that remain understandable months later, even after handoff.
Many CMS setups optimize for short‑term convenience but quietly create long‑term fragility.
Themes often shape how content is written.
Plugins start behaving like product architecture.
Presentation decisions leak into content.
Over time the system becomes harder to reason about, harder to replace and harder to maintain.
This is where lock‑in really begins.
Not only vendor lock‑in.
Not only tool lock‑in.
But architectural lock‑in.
Umono is designed to fight that from the beginning.
Umono is built for:
-> freelancers delivering client websites
-> agencies managing long‑lived projects
-> developers building content‑heavy websites with structure in mind
-> teams who want stronger architectural boundaries than traditional plugin‑heavy CMS systems
If you care about maintainability, predictability and separation of
concerns, Umono is built for you.
Umono is currently a developer-first CMS.
Today, content is authored through Compono, a text-based format designed for structural clarity and long-term maintainability. That makes Umono powerful for developers, but not yet ideal for non-technical editors.
Future versions aim to introduce safer editing workflows for clients and content teams, without compromising the architectural boundaries that make Umono maintainable.
Umono uses its own content model to keep content reusable, structured and less dependent on presentation decisions.
That means your content is not trapped inside a theme mindset.
It is not forced to follow whatever happens to be convenient for the
current frontend.
It is treated as a real layer of the system.
This gives you more freedom to evolve the presentation of your website
without turning content into collateral damage.
A website should not become harder to manage every time it grows.
A CMS should help you make changes with confidence.
It should help teams hand projects over cleanly.
It should help websites survive redesigns, new requirements, and future
decisions without dragging old mistakes forever.
Umono exists for that reason.
Build websites that age well.
Run Umono from the command line:
curl -fsSL https://umono.io/install.sh | sh
umono create my-website
cd my-website
umono up
Umono is built on a simple belief:
A CMS should not trap your content.
Content should outlive redesigns.
Themes should be replaceable.
Plugins should extend behavior, not define the architecture.
Websites should stay maintainable after launch.
That belief shapes every part of Umono.
Umono is probably not for you if:
- you want a huge plugin marketplace on day one
- you prefer convenience over architectural clarity
- you want themes and plugins to freely shape your content model
- you are optimizing for ecosystem size instead of system boundaries
Umono is for people who are willing to trade a bit of short‑term comfort for better long‑term structure.
Umono is open source and developed in public.
Explore the repository, follow the project and try it in a real‑world
setup.
View on GitHub
Stop building websites that get harder to maintain every time they
evolve.
Build with clearer boundaries.
Reduce lock‑in.
Create websites that stay stable after launch.
Start with Umono.
Made with Umono ♥️