DEV Community

Cover image for Build the CMS we always wanted: MonkeysCMS (contributors wanted)
Jorge Peraza
Jorge Peraza

Posted on

Build the CMS we always wanted: MonkeysCMS (contributors wanted)

#webdev #cms #opensource #php

There are two kinds of CMS projects:

  • The ones that are easy until you need real structure, relationships, permissions, and performance.
  • The ones that are powerful but come with a heavy config surface, fragile update paths, and a lot of "CMS ceremony".

MonkeysCMS is my attempt to take the best ideas from Drupal and WordPress and rebuild them in a modern, code-first way—on top of the MonkeysLegion framework.

If you like building systems (entities, schema, permissions, content modeling, tooling), I'd love your help shaping this into a real community CMS.

What MonkeysCMS is (in plain terms)

MonkeysCMS is a modern CMS where content types are PHP classes. No YAML stacks, no UI-first configuration as your source of truth.

The core ideas

  • Code-first entities with PHP attributes: define content types as typed PHP classes.
  • Auto-sync schema: enable a module → tables are created immediately (no migrations or extra CLI steps for schema updates).
  • True modularity: isolated modules with namespaces, dependencies, and lifecycle hooks.
  • Normalized relational database (with proper relationships), avoiding the classic EAV pain.
  • API-first: REST endpoints for CMS operations (content, users, permissions, taxonomy, menus, settings, modules…).
  • Modern PHP (8.4+) with strict types and modern patterns.

Current progress (what's already in the repo)

This isn't a blank README—the repository already documents and scaffolds several major CMS building blocks:

1) Modules + schema sync

Enabling a module triggers discovery of entity classes, reads their attributes, generates SQL, and executes schema creation.

2) Entity system (attributes + field types + relations)

There's an attribute-based model for ContentType, Field, Relation, and Id, plus a mapped set of field types.

3) RBAC inspired by Drupal (but simplified)

System roles and permission patterns are defined and documented, including auto-registration of entity permissions on module enable.

4) Taxonomy system (Drupal-like)

Vocabularies, hierarchical terms, and entity-term assignment are part of the documented design.

5) Menus, settings, CLI tooling, caching, themes

The README outlines endpoints and CLI commands (./monkeys ...), caching via MonkeysLegion-Cache, and a theme system driven by .mlc configuration.

And yes: it's early-stage—right now the GitHub repo shows 0 issues and 0 PRs, which means contributors can still heavily influence the architecture and conventions.

Why I'm inviting contributors now

Because this is the sweet spot:

  • The direction is clear (code-first, modular, relational, API-first).
  • The foundation exists.
  • The project hasn't ossified into "that's how it's always been".

If you've ever wished you could build a CMS with the structure of Drupal but the developer experience of modern frameworks, this is that moment.

Where you can contribute (high-impact areas)

Here are contribution tracks that would immediately move MonkeysCMS forward:

Backend / Core

  • Harden the schema generator (indexes, constraints, diffs, safe updates)
  • Entity hydration/serialization edge cases
  • Relations: many-to-many helpers, cascade rules, eager loading patterns
  • Permissions middleware + auditability (deny reasons, permission tracing)

Admin API & DX

  • Consistency: error formats, pagination conventions, filtering/sorting spec
  • API docs (OpenAPI), example clients, Postman collections
  • CLI improvements around module lifecycle and schema preview

Content modeling features

  • Revisions, publishing workflows, moderation states (the README already hints at publishable/revisionable concepts via attributes)
  • Media handling (image/file/gallery field types)

Themes & rendering

  • Improve the theme manager + template engine integration
  • Starter themes and real-world example templates

Tests

  • Unit + integration coverage (schema generation, permissions checks, taxonomy trees, CRUD flows)

Quick start (run it locally)

Requirements: PHP 8.4+, MySQL 8+ or SQLite, Composer 2.x.

git clone https://github.com/MonkeysCloud/MonkeysCMS.git
cd monkeyscms
composer install
cp .env.example .env
composer serve
# or
./monkeys serve
Enter fullscreen mode Exit fullscreen mode

How to contribute

The current contribution flow is simple: fork → branch → PR.

If you want something easy to start with:

  1. Pick one small improvement in docs or tests
  2. Open a PR
  3. We'll shape conventions together as we go

The vision (what we're building toward)

A CMS that feels like this:

  • You define content models like you define application code.
  • Enabling a module makes the system real immediately (schema + permissions + API).
  • You get "CMS power" (content types, taxonomy, menus, blocks, roles) without legacy complexity.

If that resonates, jump in.

Repo: MonkeysCloud/MonkeysCMS

Built on: MonkeysLegion Framework

Questions? Drop a comment below or open an issue on GitHub. Let's build something great together.

Slack: https://join.slack.com/t/monkeyslegion/shared_invite/zt-36jut3kqo-WCwOabVrVrhHBln4xhMATA

Top comments (0)