Typemill

Typemill is an open-source, flat-file CMS built for technical writers, documentation teams, and micro-publishers who need to create and maintain structured, long-form content. By storing all content as Markdown and YAML files, it eliminates database overhead entirely and makes the entire site version-controllable with Git.

Built on Slim 4 (PHP) with a Vue.js admin interface and Twig-based theming, Typemill supports installation via ZIP upload, Composer, or Docker. Its visual block editor lets authors write in a WYSIWYG environment while the underlying storage remains clean Markdown, giving developers full control over output.

The plugin and theme ecosystem extends core capabilities significantly: a paid eBook plugin enables PDF and ePUB generation using Paged.js and custom CSS, while additional plugins handle SEO, search, forms, and revisioning. A built-in AI editor (Kixote) provides content suggestions and AI-powered translation directly from the admin panel.

Typemill is well-suited for documentation sites, user manuals, knowledge bases, wikis, and handbooks — any project where content structure and authoring experience matter more than dynamic database-driven features.

What You Get

• Flat-File Content Storage - All pages, settings, and structure are stored as Markdown and YAML files on disk, eliminating any database requirement and enabling full version control with Git.
• Visual Block Editor - A Vue.js-powered WYSIWYG block editor (vue-blox) lets authors compose content visually with drag-and-drop reordering, alongside a toggle to raw Markdown for power users.
• Single-Source eBook Publishing - The eBook plugin converts your documentation into PDF and ePUB formats using Paged.js and custom Twig templates, enabling professional print-quality output from the same Markdown source.
• Multi-Project and Multilanguage Support - Manage multiple documentation projects within a single Typemill instance, each with isolated content, settings, and URL structure. AI-powered translation via Kixote automates multilingual publishing.
• Plugin and Theme System - Extend Typemill with PHP/Vue.js plugins that hook into a Symfony EventDispatcher system, adding routes, middleware, and UI components without touching core code.
• Integrated AI Editor (Kixote) - A built-in AI writing assistant directly in the admin UI supports content generation, editing suggestions, and automatic translation across installed languages.
• Media Library - Centralized upload and management of images, video, audio, and document files with drag-and-drop support and inline insertion into content blocks.
• REST API - A configurable REST API exposes content for integration with external applications or headless front-end consumption.
• Role-Based Access Control - Granular user roles and permissions (powered by Laminas ACL) restrict editing, publishing, and admin access to defined user groups.
• Docker and Composer Installation - Official DockerHub image for container-based deployment; also installable via ZIP upload or Composer for traditional PHP hosting.

Common Use Cases

• Technical product documentation - A SaaS company maintains its user manual in Typemill, with contributors editing Markdown via the block editor and the operations team exporting PDF versions for each product release.
• Internal company handbooks - HR teams use Typemill’s multi-project feature to host onboarding guides, HR policies, and compliance documents with role-based access ensuring only authorized staff can edit sensitive sections.
• Open-source project documentation sites - Developers self-host Typemill on a VPS to publish API docs and tutorials, keeping content in Git and deploying updates via CI pipeline without a database.
• Multilingual knowledge bases - A global support organization uses Typemill’s project-based language structure and Kixote AI translation to maintain synchronized English, German, and French versions of help articles.
• eBook and handbook publishing - A technical author manages a comprehensive software handbook in Typemill, publishing it as both a navigable website and downloadable ePUB for offline reading on e-readers.

Under The Hood

Architecture Typemill follows a clean layered architecture built on Slim 4 with explicit dependency injection via PHP-DI. The bootstrap sequence proceeds through distinct phases: settings load first, then the event dispatcher is constructed, plugins are scanned and registered as Symfony EventDispatcher subscribers, middleware is layered onto the Slim application, and finally routes are loaded. This separation ensures that plugin code never needs to touch core routing or middleware files — each plugin registers its own routes and middleware through well-defined plugin interfaces, and communicates with core through a rich set of named events like onPageUpdated, onMarkdownLoaded, and onCspLoaded. The license validation system operates at bootstrap time, checking a locally-stored cryptographic license file to determine which premium plugin features are enabled, enabling a commercial ecosystem on top of the MIT core.

Tech Stack The backend is PHP 8.1+ on Apache, using Slim 4 as the HTTP micro-framework with PHP-DI for dependency injection and Twig 3 for server-side template rendering. Markdown is processed by Parsedown and ParsedownExtra with a custom extension layer for shortcodes and block serialization. Configuration and content metadata use Symfony YAML, while access control is managed via Laminas Permissions ACL. The admin frontend is Vue.js 3 bundled as pre-compiled static files (no frontend build step required for deployment), with Tailwind CSS 4 for utility-first styling. Docker deployment is supported with an official DockerHub image using PHP 8.3-Apache as the base. PHPMailer handles email delivery, and Cypress provides end-to-end test coverage.

Code Quality Typemill’s testing story relies primarily on Cypress end-to-end tests, with no evidence of PHPUnit unit or integration test coverage. The GitHub Actions CI pipeline covers Docker image builds on release tags but does not run automated tests. Core PHP classes use PHP 8.1+ features but lack consistent type declarations or typed properties in model classes, reducing static analysis confidence. Error handling in storage and model layers returns false on failure rather than throwing typed exceptions, which can make debugging harder in complex call chains. Code organization is clear at the top level (Controllers, Models, Events, Middleware, Static) but individual files mix concerns. No PHP linter or code style enforcer is configured in the repository.

What Makes It Unique Typemill’s most distinctive engineering decision is the dual-format content pipeline: draft content is stored as JSON-encoded block arrays (from the vue-blox editor) while published content is written as clean standard Markdown, keeping the published output portable and tool-agnostic. The Symfony EventDispatcher-based plugin system is unusually expressive for a flat-file CMS — plugins can extend HTTP routing, add middleware, inject Twig globals, modify CSP headers, and listen to dozens of named content lifecycle events, approaching the extensibility of larger CMS platforms without the database dependency. The integrated Kixote AI editor, built as a native Vue.js component in the admin panel rather than a third-party integration, and the local license validation system (cryptographic signature check against a YAML file) together create a self-contained commercial CMS ecosystem that monetizes premium plugins and themes without requiring cloud connectivity.

Self-Hosting

Typemill is released under the MIT License, which is one of the most permissive open-source licenses available. You can use it freely for commercial projects, modify the source code, redistribute it, and incorporate it into proprietary products without any obligation to open-source your own changes. There are no copyleft requirements — running Typemill on a client’s server or bundling it into a commercial product is fully permitted. The MIT core covers the main application; individual plugins and themes may carry their own licenses (MIT or commercial), which you should verify before using them.

Running Typemill yourself requires a Linux server with Apache or Nginx, PHP 8.1 or higher, and standard PHP extensions (GD, mbstring, mod_rewrite, session, iconv, fileinfo). The easiest self-hosted path is Docker using the official kixote/typemill image, which bundles Apache and all PHP dependencies — you bind volumes for content, media, settings, plugins, and themes to persist data between container restarts. For traditional PHP hosting, a ZIP upload via FTP is straightforward. There is no database to manage, which significantly reduces operational overhead. You are responsible for backups (the entire site state lives in files), web server configuration, SSL termination, and keeping the PHP environment updated. Plugin and theme updates must be applied manually — there is no auto-update mechanism in the MIT core.

The self-hosted MIT version gives you the full CMS engine, but premium plugins (eBook/PDF generation, advanced search, SEO tools, revisions, and others) and premium themes are sold separately with commercial licenses that require a paid subscription — Maker or Business tier — validated per domain. Without a license, premium plugins deactivate automatically at boot. There is no managed SaaS offering from the Typemill project itself, so you do not gain cloud backups, managed upgrades, or SLAs by paying for a license — the license only unlocks premium plugin functionality. Support is community-driven via GitHub Issues for the open-source core, with documentation at docs.typemill.net.