Charter

1. Rust that builds keeps building+

Every crate that builds with rustc 1.99.0 builds with ra-jit and means the same thing: editions 2015 to 2024, std, crates.io as it is. ra-jit is a superset; it does not remove or change anything in stable Rust.+

When a change would break existing code, it does not ship in the existing editions. That is what editions are for.+

2. New things live in a new edition+

Everything ra-jit adds to the language sits behind a new edition that a crate opts into. Crates on the new edition and crates on old ones build together in one program, as editions do today.+

The new edition is unstable. Anything in it may change shape or be removed between releases. The old editions are the stable part; the new one is where designs are tried on real code.+

Its name and how a crate opts in are open; see the RFCs.+

3. Checkable over short+

More and more code is written by language models. Typing is cheap for them and reading their output is not, so a few more words that let the compiler prove something are a good trade.+

Prefer designs where the compiler can check the claim: a function's signature says what it may touch (capabilities), a value that must be used cannot be dropped, a pure function can be cached because the compiler knows it is pure. Prefer that to conventions, lints and documentation that have to be trusted.+

This is not a licence for ceremony. Every annotation has to buy a guarantee someone relies on.+

4. Fast to build, fast to run, easy to change+

Compile speed is a feature. An edit should rebuild what it changed and nothing else, in milliseconds. A language feature that makes every build slower has to pay for it with something users want more.+

Generated code should be as fast as what rustc and LLVM produce for the same program. Safety and checks do not excuse a slower program where the compiler could do better.+

Code should stay easy to change: small pieces, explicit dependencies, nothing global that a reader has to discover.+

5. Decided in the open+

Additions start as an RFC on this site. Anyone signed in with GitHub can comment on any paragraph. An RFC says what it adds, what it breaks (nothing, in old editions), what it costs at build time and at run time, and what is still open.+

Where Rust itself is working on the same problem, an RFC follows upstream's design and names, so what works here can go back to Rust.+