Elements makes you and your agents insanely better at building apps. Apps that work the first time and keep working, for one predictable monthly bill.
Come build the next generation of software with us.
Build apps with AI that are robust enough to run your business.
Agents write code at superhuman speed. But ask one to build an app and it starts with no building blocks. The popular frameworks are patchworks of packages never designed together, so the agent often writes raw code instead. The result may not work, and it's hard to extend or deploy. Elements gives your agent every building block an app needs, engineered to work together. An always-on project server keeps the app's build state in memory and checks it as you and your agent work.
I've been building Elements for more than a decade. The plan was better tooling for people, to make building web apps dramatically simpler. It turns out that same tooling is the linchpin that lets agents build apps that actually work and stay maintainable.
Our business is simple. You own the output. We get paid by creating the best tooling in the world so that you can focus on building.
Chris Mather
We get paid for the tooling. You own the output, and the Elements runtime packages are MIT licensed.
You pay for the tooling, not for the runtime packages. The project server, build, test runner and deploy are the tooling. @elements/app is MIT licensed, and it includes the runtime your Elements HTML runs on, which is where you write most of your app. @elements/style is MIT licensed too. A built app runs on plain Node.js.
Elements was built with painstaking care to stay on standards. Elements HTML is standard HTML with a lightweight extension: TypeScript expressions and a few attributes. Logic is TypeScript, queries and migrations are SQL on Postgres, and styles are CSS. Agents have read more of these languages than any framework's own, so they write them well.
Elements works with any agent and model. Use the agent you have today and switch when a better one comes out.
When a free framework is paid for by hosting, the bill grows as your app does. Elements is one subscription for the tooling, not based on traffic, requests or revenue, and you deploy to servers you control.
We value the people building on Elements. We do not value gatekeepers. In the age of AI, what matters is standard languages and concepts, not framework abstractions only insiders can read. What you learn building on Elements is HTML, TypeScript, SQL and CSS, and it goes wherever you go.
A project server, app framework and build tooling, engineered from the ground up to work together.
You bring the agent. It works with any agent and model. Elements brings the project server, build tooling, app framework and deployment. It works in the background, doing the right thing as you and your agent write the code. The result is correct code the first time, and still correct a hundred agent sessions later. Keep building on your own machine, then deploy to commodity hardware in seconds.
Here are some of the technologies that make that possible.
An agent can build a complex app extremely quickly, because everything it needs is already here. Features like realtime pubsub, database migrations, sessions and background jobs all ship with Elements.
The build has already run by the time you or your agent asks: type check, program analysis, migrations and tests. Your agent reads the diagnostics and corrects the code before reporting the work finished.
One server per project. The first command starts it and everything after connects to the same one: elements build, elements test, elements install, and your editor over LSP. It holds the build state in memory, so checking costs microseconds instead of seconds, and you and your agent can check after every change rather than at the end.
Save a file and the rebuild and the full type check are already done, because the build state never left memory. Your editor shows the result as you type, and your agent asks the same question with -json and reads the answer without parsing a screen.
Your agent reads the manual with elements man, and it is online too. Read the manual
Read the config, install packages, crawl, type check, run program analysis, emit, migrate the test database, run the tests, collect diagnostics, migrate the app database, release atomically, hot reload connected browsers.
A build only does the work a change requires. It does more than the popular bundlers and dev servers, and it is faster than all of them. Nothing in it trades speed for convenience. After a save, a build takes a few milliseconds, and the browser usually shows the change within one frame of a 60Hz screen. By the time your agent asks how the build went, it is already done, so the answer takes a few microseconds. That is the result of ten years of engineering on one integrated system.
Packages install as part of the build, automatically. It is npm compatible. Install one at version local and it resolves from your package search path, gets watched like the rest of the project, and ships on deploy. No monorepo, no file links.
A migration is a .sql file. No ORM, no migration DSL, nothing to learn on top of sql you already know, which is also why an agent writes and edits them correctly, and why you can always run one directly against a database if you need to. Write one and it is applied on save, to the test database before the tests run and to the app database after. Nothing to remember, nothing to run.
The test server runs several processes at once, so tests execute in parallel against the freshly migrated test database. Those processes take part in hot module reload, and a test is rerun when its dependencies change, so a typical test takes a few milliseconds. Fast enough that they stop being the thing you write to be compliant and start being how you find out what you broke.
A database call reachable from the browser does not compile, so it never ships. The report carries the fix and the path that got there.
Any Ubuntu box you can ssh into. Elements builds the release, ships it, runs the migrations and hot reloads the app. No server restart, no dropped connections. A load balancer and TLS certificates come with every deploy machine.
A deploy is your project server talking directly to the one on each machine. Yours sends the source graph it already holds, theirs diffs it against the graph it already holds, and only what changed crosses the wire. Both ends are already hot. No queue behind a million other people's builds, no container image to assemble and push, and nothing rebuilt from scratch on the far side.
Every machine runs its own load balancer and they find each other automatically. To grow the cluster, add the IP address to config.jsoc and deploy. Whichever machine takes a request balances it across the cluster, with failover to the ones still answering.
Set a domain, point DNS at the machine, open 80 and 443. Elements issues the certificate through Let's Encrypt on the first request and renews it before it expires. Adding a domain or rotating a certificate takes effect without dropping connections.
Elements installs and manages Postgres on every machine, so a single-machine app has a database with nothing to set up. For a cluster of several machines, point them at one shared Postgres, on a server you run or with a managed provider.
Everything a real application needs, with no external packages. Your app is standard HTML, TypeScript, SQL and CSS. The HTML is the HTML you and your agent already know, made reactive and dynamic, not JSX with a tree diffing algorithm between you and the page.
The difference between an app that works the first time and an afternoon of telling your agent to try again.
It matters more the larger the app gets. Save any file in the project and it is checked against every page and every route, so you or your agent can change a schema in a codebase nobody remembers and find out immediately that it broke something three files away. Nothing regresses quietly, and an app you shipped six months ago is still one you can change with confidence.
A project server, build tools, app framework and deployment, as one carefully engineered system. Built from the ground up to work together, on your own machines.
Install Elements