Somebody gave you a compiler
It is a real one: built for their code, measured on real hardware, and it runs on your machine offline once it is installed. Here is what it will and will not do for you, and the one thing you need before you can use it.
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.
You will need an account to import it
Bringing somebody else's compiler onto your machine requires signing up. Saying so here rather than at the moment you try is deliberate — nobody should meet that halfway through.
After that it is yours to run: offline, on your own machine, with no lookup and nothing reporting back. The account is what compilers are made and kept against, not a meter on using one.
- 01 proposed 12 marks
- 02 proved 7 marks
- 03 faster 4 marks
- 04 admitted 2 marks
- 05 one compiler one
What it will do for your code
Some of what it does will apply to your program and some will not. A compiler is tuned to one program on one kind of machine — that is where the advantage comes from, and it is exactly why it does not transfer whole. Their compiler carries the transformations that were worth it for their code, with parameters measured on their hardware.
None of that can happen yet. The step that takes a compiler somebody else made and works out which parts of it fit your code is not implemented, so today the answer is not “some of it applies” but “nothing does, because the matching cannot run at all”. What is written above is what it is for, not what it currently does for you.
It is meant never to be worse than your default compiler: where nothing it knows applies, you get your ordinary build. Nothing enforces that yet — it is one rule shared by every tier, and it is still unimplemented, so treat it as the intended floor rather than a promise anything currently keeps.
How much of that survives the trip to your program is a real question with a real answer, and nobody can tell you what it is without measuring. Not us, and not the person who sent it to you.
If you want it tuned for your code
You point your own coding agent at a C program you already have, and it designs a compiler for what you actually wrote — starting from what is already in this one rather than from nothing. What you get back is another binary like the one you are holding: yours, runnable offline, and shareable in exactly the same way.
- Make an account. It is what a compiler gets saved against.
- Connect evolve — the product this compiler came out of — to the agent you already code with. What that involves.
- Point it at a C program and let it tune.
Everything you build stays yours to run without us afterwards. The account is for making compilers, not for using them.