Files
Your NameandClaude Opus 5.5 15da1e2379 Add a package manager: rex init/add/remove/get/update/deps
Packages come from git (a registry can be added later; a bare version in
rex.toml is reserved for it). rex.toml [deps] names them, rex.lock pins exact
commits, and run/build/check/test download what is missing. `import json`
reads the package's json.rex; package files get `@json...` module keys so they
never mix with the project's own files. Newest tag of the same major version
wins when packages disagree. The language server reads downloaded packages.
Docs: docs/14-packages.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:30:11 +01:00
..

Rex: learn the language

Rex is a small, fast, modern language. It looks like Go, runs like C, and has no garbage collector, no pointers, and nothing low-level to write. You write plain code; the compiler works out the memory.

These notes teach it from zero. Read them in order, or jump to the cheatsheet when you just need to look something up.

# Note What you learn
1 First steps Running a program, print, main
2 Values and types var, const, numbers, strings
3 Control flow if, for, match
4 Functions Parameters, results, closures, defer
5 Lists and maps Collections
6 Structs and enums Your own types, methods
7 Errors and nil error, ?, T?
8 Memory Copies, shared, weak
9 Generics and interfaces Code that works for many types
10 Files and the standard library import, os, math, time, rand, tests
11 Cheatsheet Everything on one page
12 A real program A calculator, split over five files
13 C and C++ libraries import "raylib.h", your own C code
14 Packages rex add, using code from other projects

How to read the examples

Every rex block that has a func main is a complete program you can save and run. The block right after it (marked text) shows what it prints.

```rex
func main() {
    print("hello")
}
```
```text
hello
```

The four ideas behind Rex

  1. Values. var b = a makes a real copy. Change b and a stays the same. There are no hidden aliases, which makes programs easy to reason about.
  2. The compiler infers. You don't write mut, lifetimes or &. A method that changes its struct is detected automatically; a parameter that is only read is passed without a copy.
  3. Errors are values. Functions return (value, error) and you pass problems up with ?. Missing values are T? and the compiler makes you check for nil.
  4. Sharing is explicit. When you really want one value with several owners, you write shared. Everything else has exactly one owner and is freed at the end of its block.