Skip to main content
Capell home
My account

We use cookies for essential features and optional analytics.

Manage cookie preferences

Choose which optional cookies Capell may use.

Essential
Always on

Required for Capell to work — login, security, page rendering.

Analytics

Anonymous usage telemetry to improve editor performance.

Marketing

Personalization for the Capell marketing site.

Cookie policy

Build a Laravel CMS your team can keep extending

Developers should not have to rebuild pages, URLs, layouts, previews, publishing workflow, search, SEO, cache invalidation, media, package screens, and operational checks from scratch for every content-rich Laravel project.

Capell gives that work a standard shape. Core owns the content model, Admin gives editors a Filament workspace, Frontend connects clean data to public output, and packages add capability without patching the CMS foundation.

Composer packages Filament workspace Public-safe frontend
Capell developer workspace showing page records, Filament screens, LayoutBuilder, routes, tests, and public output.
Read package docs Browse extensions

Developers should not have to choose between a maintainable Laravel app and a CMS editors can actually use. Capell keeps the CMS inside Laravel, with Filament for the admin and the application team owning the public frontend.

The useful part is the boundary. Editors get pages, layouts, widgets, media, previews, and publishing tools. Developers keep code, tests, routes, packages, render hooks, policies, and deployment under familiar Laravel control.

Where Capell helps

  • You stop rebuilding the same CMS foundation for every project.
  • Repeated page structures become page types instead of copied templates.
  • Editor-composed pages use widgets you define, render, and test.
  • Optional features arrive as Composer packages, not patches in the app.

If a few Filament resources solve the job, use them. Capell is for the point where the CMS has become a real product surface and needs the same maintainability standards as the rest of the application.

Video overview

Watch the developer overview

For developers, the test is whether Capell behaves like Laravel work: packages, Filament boundaries, render hooks, tests, and frontend ownership.

Hyperreal editorial illustration: A developer at a desk.

Developers

Capell gives Laravel teams package-based CMS architecture for content structure, Filament editing, frontend delivery, workflow, operations, and extensions.

Start with the practical question: what does the visitor or editor need to do next? Capell keeps that answer tied to the Laravel app, with shared structures for repeated pages and enough room for custom work when the project genuinely needs it.

A CMS architecture that still looks like Laravel

The value is not one extension point. It is the way repeated CMS work keeps landing in the same places: content structure in Core, editor workflow in Admin, public delivery in Frontend, and optional capability in packages.

That gives backend developers, frontend developers, and package authors a shared vocabulary before the site grows beyond a few editable pages.

Put repeated structure in Core Page types, URLs, layouts, themes, media, translations, settings, linkable records, content graph edges, and cache dependencies have a shared CMS home. See content model
Use Filament where editors work Resources, pages, widgets, dashboard cards, settings screens, validation gates, table changes, header actions, and package control pages extend the Admin surface. Compare Filament
Keep the public site yours Themes, LayoutBuilder widgets, frontend components, render hooks, runtime assets, route middleware, and response renderers feed project-owned Blade, Livewire, Inertia, or custom output. See frontend
Move optional capability out of core Publishing tools, forms, SEO, search, analytics, themes, imports, AI, commerce, diagnostics, and workflow can ship as focused Composer packages. Explore extensions
Review the impact before adoption Manifests, compatibility metadata, install actions, migrations, health checks, screenshots, support terms, advisories, and public output tests make package adoption visible. Review trust

Build packages that feel native to Capell

Package authors are not asked to learn a parallel plugin language. A useful Capell package is a Laravel package with service providers, Actions, data objects, Filament surfaces, views, migrations, queues, policies, tests, docs, and a manifest that explains what the package changes.

That is why the marketplace can grow while core stays focused. Repeated CMS work gets packaged once, reviewed once, improved over time, and reused across sites.

Read extension docs Review platform fit
Say what the package adds The manifest carries product group, surfaces, dependencies, providers, contributions, migrations, commands, capabilities, performance impact, commercial metadata, and marketplace proof. Read manifests
Use the right Capell surface Package providers and registrars wire content, admin, frontend, assets, cache, lifecycle, health, and workflow behavior through known Capell patterns. Review patterns
Give editors useful building blocks A package can ship page types, sections, widgets, assignable assets, settings, and Filament screens so editors gain capability without taking over the frontend. See page building
Ship the evidence with the package Tests, screenshots, support terms, compatibility, install receipts, health checks, and public output safety make the package easier to trust. Browse extensions

What a Capell package can extend

The extension model is broader than hooks. A Capell package can own a real slice of CMS capability: the records it needs, the editor screens it exposes, the public output it contributes, the jobs it runs, the cache it invalidates, and the proof a buyer needs before installing it.

That is the pattern developers should recognise: package capability by responsibility, not one-off changes scattered through the host app.

Content structures Page types, page variations, sections, models, settings, linkable content, renderable definitions, ownership maps, content graph extractors, and migrations let packages define real CMS structure. Read content docs
Editor workspace Filament resources, pages, widgets, dashboard stats, settings pages, schema extenders, table extenders, header actions, user menu items, and extension pages add editor-facing workflow. See Admin
Public delivery Frontend components, LayoutBuilder widgets, render hooks, themes, Tailwind sources, runtime assets, route middleware, reserved paths, and response renderers let packages contribute without owning the site's DOM. See frontend
Publishing depth Drafts, previews, approvals, schedules, versions, rollback, field comments, validation gates, workflow attention, and activity handlers can arrive as packages when the team needs them. See workflow
Performance and cache HTML cache, frontend optimization, cache invalidation dependencies, cached fragments, static export files, asset manifests, and stale regeneration keep public delivery fast and inspectable. Review delivery
Site operations and security Permissions, policies, health checks, diagnostics, install and upgrade steps, scheduled jobs, access gates, login audit, password policy, advisories, and support state help teams run the CMS. Review operations
Growth, search, AI, and commerce Search, SEO, forms, campaigns, newsletters, analytics, public actions, webhooks, importers, AI tooling, commerce sync, and external APIs can sit beside the CMS instead of inside bespoke page code. Browse packages
Proof before install Screenshots, compatibility, certification, commercial tier, support policy, private docs, install receipts, and release metadata make each package easier to evaluate. Review marketplace

Strict coding standards

Capell treats coding standards as product infrastructure: strict typing, PHPStan, Pest, Actions, data objects, and package-level checks keep CMS features clear to inspect before they reach editors or public pages.

Capell packages

141

First-party package directories currently tracked in the Capell package library.

Total themes

76

Theme packages including Foundation Theme and premium theme packages.

PHPStan level

9

Static analysis runs through the shared PHPStan configuration before release work is trusted.

Test coverage

91%

Test coverage across the full Pest suite.

Pest tests

7,570+

Combined test count reported by Capell and Capell package workflows.

Assertions

42,114+

Combined assertion count reported by Capell and Capell package workflows.

Render budget

142ms

Public render budget, cached output.

Questions

New to Capell?

What is Capell?
Capell is a Laravel CMS built on Filament for websites with serious content needs: structured pages, reusable layouts, widgets you approve, publishing flow editors can use safely, public delivery, and features added one Composer package at a time.
Is Capell meant for designers?
Designers can work with Capell through themes, approved layouts, visual direction, and frontend systems while the CMS keeps content structure stable.
Is Capell made for developers only?
No. Developers get the Laravel architecture, but site owners and editors get the practical value: manageable pages, safer publishing, and visible site operations.
How can Capell help me out?
Capell gives repeated CMS work a proper home so teams are not rebuilding pages, URLs, layouts, publishing, redirects, cache, SEO, and package logic from scratch.
Can I use Capell with my existing website?
Yes, when the project is a Laravel app or can move into one. Start with a verified install path, then migrate content and packages deliberately.
What happens when I install Capell?
You install Core, Admin, and Frontend first, verify the Filament workspace and public output path, then add LayoutBuilder, themes, and other extensions only when the site needs them.
How can we reach you?
Use the contact path when you need help deciding fit, discussing a project, reporting a concern, or talking through package and marketplace work.
How can I work with Capell?
You can install Capell, build a site on it, author packages, create themes, or use it as the CMS foundation for long-running Laravel projects.
How can I help Capell?
Use Core, share feedback, donate, buy first-party packages, purchase marketplace extensions, or author trusted packages for other Capell teams.

Capell learning journey

Step 3 of 4: Solutions

Role and job-based Capell paths.

Keep moving through Roles

Paths for owners, editors, developers, and agencies.

Loading footer