Set up

Two commands and one connection. evocc compiles, evolve manages what you have, and your agent designs the compilers over MCP. Making a compiler needs an account; running one you already have does not.

Somebody sent you a compiler? Bringing it onto your machine needs an account, and there is a shorter path for you — start here instead.

What you cannot do yet

Some of what this page describes is not available yet. None of it is a decision you need to make — saying so here is better than letting you find out one at a time.

You cannot connect an agent yet. There is nothing to point a client at.
Accounts are not open yet. What signing up will look like.
A compiler somebody else made cannot be matched to your code yet. Receiving one and running it is built; the step that works out which parts of it fit a different program is not. What that page describes is what it is for rather than what it does today.
Projects do not exist yet. Other pages describe compilers being saved as versions beside each other in a project; the server does not answer for projects today, so that page says so rather than showing you an empty one.

Everything else on this page describes how it works today. Where something is not built yet it is in this list — if you find a claim that is not, that is a bug in this block and not a feature we are being coy about.

1. Install

You get evocc, the compiler you call in place of gcc, and evolve, which manages your projects and the compilers installed on this machine.

Installing is a terminal command, and it is being finished. There is deliberately no browser download: macOS quarantines whatever a browser fetches and challenges it on launch, while a file fetched by a terminal command carries no quarantine flag at all. So the way in is a command where the problem does not arise. The exact line will be here when it runs.

Verifying it yourself

The installer checks the download against published checksums before it unpacks anything, so this is not a step you have to take. It is here because you can.

shasum -a 256 -c --ignore-missing SHA256SUMS

--ignore-missing matters: that file lists every published build and you have one, so without it the other 2 would be reported as failures. Version 0.1.9.

2. Sign in and connect your agent

A compiler is designed over MCP, by the agent you already code with, against your actual code. There is no path to a first compiler that skips this — installing alone gets you the commands and nothing tuned to run through them.

Your connection details are yours, so they live behind sign-in. The configuration carries a credential tied to your account, and a public page is the wrong place for one. Sign in and it will be on your account page.

3. Make a project, and design compilers in it

A project is a durable identity for a codebase, so what you tune survives changing machines. Every finished optimisation is saved as a version beside the last one, and they all show up on your projects page.

4. Use them offline, for as long as you like

A compiler you have saved runs on your own machine with no account, no lookup and no network. Designing needs us; using what you designed does not.

If somebody gave you a compiler

Install the commands and bring it in — that needs an account, and after it you run it offline like any other. You are starting from the useful end.

But it was tuned for their code, not yours. How much of its advantage survives depends on how close your program is to theirs, and the honest answer is that nobody can tell you without measuring. If it does not fit as well as you hoped, that is expected rather than a fault: sign in, point your agent at your own code, and tune it from where they left off instead of from nothing.

If you are going to tune on an embedded target, read this first.
Tuning builds many versions of your program and runs each one on the real part. The board must be completely disconnected from anything around it while that happens — nothing wired to its pins, nothing it can drive. What that means and why.