Skip to content
The Stacklumen platform is in private alphaSee the products

Design the site.
Ship the site.

The visual site builder inside Stacklumen: a real canvas over real HTML and CSS, breakpoints you author rather than preview, and one button that puts the site on a live address.

Open Terminal Create an account

Terminal, the Stacklumen site builder, in its light frame: one bar with the site and page, a centred tray of the four breakpoints, the Mode Selector and the zoom, then Search, Preview and Publish; the rail of panels with the Layers tree open beside it; a client page drawn as a window on a dotted stage, its heading selected with the format bar above it; the Inspector with its style tabs, class chips, state tray and property groups; and the insert dock and the selection path along the foot. A short demo plays: the cursor opens Typography, drags the heading from 46 to 58 pixels in the format bar, retypes its last words on the canvas, brings the size down in the Inspector, then walks the page through Tablet and Phone, the window gliding narrower, and back.

Status
Alpha
Lives at
stacklumen.com/terminal
Editor
Visual canvas · code in StackIDE
Breakpoints
4 authored layers
Publishes to
A staging link, then your domain
Custom domains
With Basic or Premium · TLS included
Agent door
MCP, 226 tools
Pricing
Staging free · Site plans from $15/mo

What you draw is what ships. One document, canvas to visitor.

The editor holds an ordinary document: tags, classes and a stylesheet. Publishing serialises exactly that and preview uses the same serialiser, so it cannot lie. No runtime and no framework sit between what you drew and what a visitor loads.

Selection

Element
h1
Class
.cs-split__title
Font size
46px
Weight
660
Line height
1.06

Stylesheet

.cs-split__title { font-size: 46px; font-weight: 660; line-height: 1.06; }

A screen in the hub, not a second app

One Stacklumen sign-in and one workspace with the dashboard, the CRM and your clients. Sites belong to clients, and the work lands on the same activity trail.

Everything autosaves

Closing the tab costs nothing, and the live site does not move until you publish again.

Build the page. Then style the class.

Start from a page and its tree. Drop in sections (Navbar, Hero, Feature grid, Pricing, Contact form, Footer) or single elements from Insert. Select anything and the inspector reads it back; styling writes to a class, so every element that carries it follows.

The Terminal designer, drawn as it ships: the top bar, the rail and the Insert panel, the stage with its rulers and the page in a window, the command dock, and the Inspector. A short demo plays: the cursor drags the Feature grid block from Insert onto a client page, selects the first card, retypes its title, gives the card class a brand border on its Hover state, sets the class to slide up when scrolled into view, and previews it. The Inspector is real: its tabs, state, border colour, trigger, animation and duration controls change the drawing.
  • Colour

Nine keys, three rows

Where you are and what goes in it (Insert, Pages, Layers), the content (Collections, Assets, Components, Stacklumen Base), and how it looks (Styles, Apps). Clicking an open panel's key gives the stage its width back.

Style, Interact, Settings

Hover, focus and active are layers over the base. Interactions fire on click, hover, load or scroll into view: animate, show, hide, toggle, toggle a class, scroll to, or go to a URL. Settings holds attributes, the tag and bindings.

Breakpoints are layers. Not previews.

Desktop is the base. Laptop, Tablet and Phone are layers you author on, and each stores only the fields you changed, so a later desktop edit still reaches everything a narrower layer has not pinned. The cascade runs downward, the way a max-width media query does.

The Terminal designer's breakpoint layers, working. Choose Desktop, Laptop, Tablet or Phone in the top bar to see the page's window at that width and the page reflow, and change the heading size on any layer: narrower layers inherit a wider layer's size until you change it there.
  • 46px

    Set on .cs-split__title

    Desktop: the 1200px base. Every other width inherits from it.

Find the width, then fix it there

Switch layers from the toolbar or the number keys, or sweep the width in the View menu to find the width something breaks at. An edit at a narrow layer never travels back up. Phone is authored at 390 and published to 480.

The site keeps taking input. Collections, forms and assets.

All three read and write the same document the canvas edits. Bind the parts of one card to a collection, repeat it, and the content takes the shape you drew.

The Terminal designer with a Projects collection, drawn as it ships. A short demo plays: the Projects collection is opened in the CMS editor, an item is added and named Harbor Station, and back on the client's Work page it is already in the list of projects; then the list is selected, sorted by year, newest first, limited to two, and given a Load more button, then page links. The Collections panel beside the drawing is real: its sort, direction, limit and pagination controls change the list.

Showing 3 of 3 matching · 3 items in Projects. The canvas shows items as edited; the live site shows them as of the last publish. Drafts are never shown.

Sort by
Direction
6
Pagination

Everything the CMS does, headless included →

A page per item

Mark a page as a collection's detail template and, on Premium, publishing renders one page per item at its own slug, sitemapped and rollable.

Forms that answer

Submissions land on the site's Form submissions screen, paginated and exportable. Contact and Newsletter blocks ship with a honeypot; the endpoint authenticates by site.

Assets per site

Uploads belong to the site, not the workspace, so one client's images never appear in another client's designer.

Publish a snapshot. Roll it back whenever.

Publishing renders every page to a standalone document and keeps the set as one deployment. The live site serves those bytes and nothing else, so the draft can change all afternoon and the site does not move until you publish again.

Live on a staging link

Every publish is live on a staging address at once, with internal links kept inside it, so a staged site behaves like the real one. When it is ready, connect its own domain with a Basic or Premium site plan: one TXT record proves it is yours, the DNS points it here, and the certificate is issued for you.

Nothing is one-way

A rollback republishes an older snapshot as a new deployment, so it can itself be rolled back. Unpublish takes a site offline without deleting it; Restore brings it back.

In every page, and after

  • Titles, meta descriptions and share images per page.
  • Canonical URLs for the address that serves the page.
  • A frozen sitemap, robots.txt, redirects and a 404 with a real 404 status.
  • First-party page views on every site, and Advanced analytics for a site that holds it: visitors, sources, goals and funnels, without cookies.

The editor, addressed over MCP.

An external agent works on a site through the same validated actions the canvas dispatches, with every write in the same activity trail, and an open designer takes its changes in as they land. It is the editor, addressed differently, not a second API that drifts from the first.

The Terminal designer beside an agent working on the same site over MCP (226 tools). The designer has no agent of its own: its command dock's Ask Claude copies a prompt naming the site, the page and the selected heading. A short demo plays: the prompt is copied, the agent reads the page, retypes the heading and recolours the button, and the open designer takes the changes; its request to publish is refused because its API key lacks the publish scope; with a full-access key the publish succeeds, and a key limited to one site cannot read another client's site. The key's reach and scopes beside the drawing are real controls.
Reach
Scopes

design:read · design:write · collections:read

Tokens you can account for

Minted by the workspace owner, optionally limited to one site, and scoped by function. Every write is attributed to its token, and the designer tells you when a token changes a document you have open.

Framework code, by your agent

Your agent reads the project you already have and builds its pages here over MCP. Writes the canvas could not produce are refused, not approximated.

The designer, on your desktop. Next to its files.

StackIDE, the Stacklumen desktop app for Mac and Windows, opens this designer in a tab and keeps each site in two-way sync with a folder on your computer. Edit the page on the canvas or its file in the editor, run an agent in that folder, and publish from the status bar.

Download StackIDE Explore StackIDE

StackIDE, the Stacklumen desktop app, drawn on a Mac. A short demo plays: the site Northgate open on the Designer tab; index.html opened from its files; Terminal here opening a shell in the site's folder and printing the .mcp.json that connects agents to Stacklumen; then, after Claude Code has edited the page in that folder, its heading rewritten in the editor and saved, the status bar reading Synced just now and the Designer tab taking the new words; then the status bar's Publish counting through its steps until the site is live.

StackIDE on a Mac: the Designer tab beside the page's file, a shell in the site's folder with its .mcp.json, an agent's edit and then yours saved straight to the site, and the status bar's Publish putting it live.

The designer, in a tab

Unfold a site in the sidebar and Designer opens this editor in a tab of the window. Overview, Terminal here and Publish sit on the rows below it, and the site’s files under them.

A folder that keeps in step

Sync to folder writes the site out as files: its pages, the stylesheet and the page code. Save a file and the site has it; change the page here and the file follows. If you both changed the same lines, the site keeps its own and your copy waits in .stacklumen/conflicts.

A real terminal, agents connected

Terminal here opens a shell in the site’s folder, and the Agents panel starts Claude Code, Codex, Gemini CLI and six more there. The folder’s .mcp.json names this editor’s MCP endpoint, so an agent that reads it finds the site and asks you to sign in once.

Publish from the status bar

The blue Publish, or Publish on the site’s row, asks once, then counts the publish through its steps as it runs and names the address the site went live at, the same publish the browser makes.

Bring work in

Stacklumen Base components import as ordinary elements, free templates and section libraries install from the marketplace today (paid checkout is coming), and Terminal Cloud mounts an app on a path.

Browse the marketplace

Where it fits

The screen in the Stacklumen Hub where sites get made, beside the clients, CRM and billing they belong to, and a tab in StackIDE on the desktop.

See the products

Get started

Sign in, create a site from the dashboard, design it and publish to the staging link. Share it with whoever needs to see it.

Open Terminal

Questions. The ones people actually ask.

Do I need to know how to code?

No. The canvas, the Blocks and the inspector are the whole workflow. If you do know CSS, a Custom CSS field is there, and StackIDE opens the site’s code on your computer.

What does it cost?

Terminal is on your agency's Stacklumen plan, the same one that covers the Hub and StackIDE: Free, or Agency at $99.99/mo with 5 editor seats. The full Stacklumen Base library inside Terminal comes with Stacklumen Base, $29.99/mo, sold on its own on either plan. Every site has its free staging address on every plan. Every site holds up to 10,000 CMS items and 200 collections, on any plan or none. A site on its own domain takes a site plan: Basic at $18/mo, or Premium at $30/mo, which adds pages that show CMS content and Content API keys. A site whose CMS your own code reads, a Code site or any front end, takes the CMS site plan at $15/mo for its Content API keys, with no custom domain. App routes add $15/mo to a site, and Advanced analytics $10/mo: cookieless visitors, sources, goals and funnels, beside the free page counts every site has. Yearly billing is two months free. The pricing page has the detail.

Can another app read a site's content?

Yes. The Content API serves a site's CMS content with keys bound to that one site, so a key handed to a front end can read nothing else. A key needs the site on the CMS or Premium site plan.

What does "alpha" mean here?

That there are rough edges and unfinished surface area, not that it is a demo. The designer, autosave, publishing, the CMS, form submissions and the agent door all run today, and our own engineering team ships client sites with it.

Can Stacklumen build the site for us?

Yes. Our engineering team builds client sites in Terminal today, and enterprise builds are delivered by our enterprise team until Terminal reaches general availability. At general availability, Terminal opens a marketplace of creators: choose an independent creator, or work with our internal development team.

Can I bring an existing site in?

Through your agent. The agent you already use, connected over MCP, reads the real project and builds it here through validated writes. The old Astro importer is gone; markup pasted on a page in Terminal’s designer lands as native elements. The Stacklumen Base library, marketplace libraries and templates still install.

Can an AI agent edit my site?

If you give it a token. The MCP endpoint offers 226 tools covering sites, pages, text, attributes, the stylesheet, components, collections, revisions, form submissions and publishing. Tokens are minted by the workspace owner, can be scoped to a single site, and every write is attributed to the token that made it. In a folder StackIDE, the Stacklumen desktop app, keeps in sync with a site, the folder's .mcp.json already names this endpoint, so an agent that reads it, Claude Code among them, finds it there and asks you to sign in once.

Is there a desktop app?

Yes: StackIDE, the Stacklumen desktop app for Mac and Windows, comes with your Stacklumen account. It opens this designer in a tab, keeps each site in two-way sync with a folder on your computer, runs your terminals and coding agents in that folder, and publishes from its status bar. Sign in at stacklumen.com/ide to get it. The Mac builds are notarised by Apple; the Windows installers are not code-signed yet, so Windows may ask you to confirm. For now the app installs as "Stacklumen" and takes the StackIDE name in an update.

Can I edit on a phone or a tablet?

No, deliberately. The designer needs at least 1100px of viewport rather than reflowing into a layout where a drag lands on the wrong element. Narrow layouts are designed on a wide screen, which is what the breakpoint layers are for.

Open it and draw something.

The fastest way to understand a builder is to put a section on a canvas and publish it. Terminal comes with your Stacklumen account, and every site stages free.

Open Terminal See pricing
Powered byTerminal