Everything Brood does today, grouped, with a status next to each line. Brood is in beta — some of this is finished and used daily, some works with rough edges, and some is still being built. The badge says which.
The canvas, the styling system, and everything else you touch while building a page.
Pull a block from the palette onto the page, drag it somewhere else, drop it inside another. What you arrange is what ships.
Click a heading and type. No side panel, no modal, no separate content mode.
Every edit is reversible, deletes included. A failed undo surfaces and retries instead of quietly losing the step.
The block operations you reach for constantly, on keyboard shortcuts. Reaching a deeply nested block still takes more clicks than it should.
The page as a tree: find a block, jump to a nested node, drag a whole branch somewhere else.
Switch viewport and lay out for it. The cascade runs one way, so narrowing a screen never leaks back into the wide one.
Style once, reuse everywhere — plus combo classes for base-and-modifier. The panel tells you whether a value came from a class or from this block.
Hover, focus, active, visited, pressed and three more, styled like any other state.
Family, size, leading, weight, style, case, decoration, tracking, alignment.
Upload your own font files. They serve from your Host, not from someone else's CDN.
Full parent and child controls, with a nine-cell grid for alignment.
Draw tracks and named areas directly on the page. Works; the edges are still rough.
Width and height with min and max, margin, padding, borders and radii, offsets, z-index.
Colors, background images with size, position and repeat, linear and radial gradients with stops, inset and outer shadows, filters, 2D transforms.
Per-property transitions with duration and easing, set where you set the property.
Turn any subtree into a component with typed properties, variants and slots. Change the definition, every instance follows.
Layout, typography, media, links and buttons, forms, collection lists, embeds, inline SVG.
Show or hide a block by record field, signed-in user, locale or page context. Decided on the server, so a hidden block never reaches the HTML.
Edits save themselves and say so. Preview opens the page exactly as a visitor gets it, without publishing.
Click, hover and scroll triggers driving a small graph of actions. Class toggling — the mechanism behind accordions and menus — is being rebuilt, so treat this area as unfinished.
Content modelling on real tables, and everything that reads or writes it.
A collection is a table with typed columns — not rows in a key-value blob. Indexes, constraints and queries behave the way you already expect them to.
Text and rich text, numbers, currency, dates, booleans, images and galleries, files, selects, colors, emails, URLs, and more.
One-to-many and many-to-many between collections. Junction tables are created and maintained for you; lists read through a relation with dotted tokens.
Formulas over a record's own fields, lookups through a relation, rollups and counts over child records. Materialized by the Host, never hand-maintained.
UNIQUE and CHECK enforced by Postgres on every write path — the API, the form, the workflow and the agent all hit the same wall.
List, search, filter and edit rows. Soft delete with a trash you can restore from.
Bind a list to a collection, sort and filter and page it, and design one item as the template for all of them.
Faceted filters, search and sorting that live in the URL — so a filtered view is a link someone can send.
Upload once, use anywhere. Resized derivatives and srcset are generated for you, and the bytes sit in your own object storage.
Build a form visually, read the submissions, validate with per-state messages, and get an email when one arrives. Spam screening is on by default, with no third-party captcha.
Visitors attach files; the files land in your media library alongside everything else.
Accounts for the people who use your site, with roles, groups, per-collection read policies and per-row ownership. Social sign-in providers are wired.
Per-locale overlays on text fields and on whole page trees, locale-prefixed URLs, and a per-locale slug when a language wants its own address.
Server-side logic, running on your Host rather than in somebody else's cloud.
Server-side logic as a graph: triggers, data steps, transforms, branches, loops. It runs on your Host, not in someone's cloud.
Cron triggers running on your Host's background worker. Nightly rollups, reminders, cleanups.
Transactional mail from a workflow step, sent by your server with your credentials. Every message the platform itself sends — password resets included — goes through the same engine, so there is no second, hidden mail path.
Inbound endpoints with delivery receipts, outbound HTTP from any workflow step.
Run one node on its own, re-run an execution from the step that failed, and read the payload at every hop.
A workflow's data writes land as one transaction. A run that dies halfway does not leave half a record behind.
An inline action on a published page that mutates a record — with an escalating confirmation and an audit trail behind it.
Connect Claude, Cursor or any MCP client to your project and let it author pages, collections and workflows against the real stack. Your agent, your key, your server — Brood does not resell inference.
Getting a project onto a machine you own, and keeping it running there.
The runtime is a single container on a box you control. No phone-home, no licence check, no kill switch. It keeps serving when we are offline.
Mother runs on your machine, for macOS, Linux and Windows. A local project needs no account and costs nothing.
Every edit lands in draft. Publishing promotes the whole project at once and snapshots the previous state first.
Two separate schemas on the same Host, and the interface always says which one you are about to publish to.
Publishing captures a snapshot automatically, and you can take one by hand. Roll the project back to any of them.
Point a domain at a server Host and the certificate is issued for you. This site is served that way. A project running only on your laptop has no public address yet — moving one to a server is still manual.
301s you write yourself, plus automatic ones when you rename a page that was already live.
Per-page title, description, canonical URL and Open Graph, generated sitemap and robots.txt, optional IndexNow pings.
A production Host installs with one command on any box with Docker, and the CLI operates it from there.
Pair a Host with Mother over an end-to-end encrypted channel and see machine status from the dashboard. Your data never has to sit on our disks.
Letting a freelancer into one project without handing over your login, and giving a client an editor that cannot break the layout. Roles and permissions exist underneath; the way into them from the desktop app is still being built.
Subscription billing is wired end to end and passes in test mode. Live keys are not switched on, and nothing is charged while Brood is in beta.
Leaving — on purpose, at any time, without a penalty.
One command turns the project into a plain Next.js and Drizzle repository — pages, styles, schema, migrations, data. No Brood packages in it, nothing to phone home to.
Install and build on a freshly exported project is checked on every push to Brood itself, so "it exports" cannot quietly stop meaning "it runs". A few surfaces still need a pass.
The exported site aims to behave the way it did on the Host. Forms, collections and pages carry over; some interactions are still catching up.
No plan gates it, no notice period, no export fee, no degraded copy. It has been used for real: a production site left Brood in 2026 and took its data and its design with it.