Compiler and runtime architecture

source → lexer/parser → name and alias resolution → signatures → checking
                                                                  ↓
                                                        typed operation IR
                                                                  ↓
                                                     Cranelift → object → linker
                                                                           ↑
                                                           embedded Rust runtime

• Frontend and checking: types, ownership, access CFGs, and IR.
• Native emission: specialization, batching, and performance evidence.
• Value representations: inline storage, standard sums, and relocation.
• Memory and destruction: owners, reference counts, and allocator provenance.
• Collections: storage, hash order, and current costs.
• Generators and closure environments: frames and captures.
• Tail-call ABI: approved transfers and hidden result storage.
• Inspecting generated code: --dump text for each function’s IR and machine code.
• Runtime packaging: archives, platform checks, stack overflow, and Rust panics.
• Concurrent mechanisms: pinned storage, locks, and waiters.
• Native interfaces: adapters, metadata, and resident code.
• Support index: links to implemented contracts and major restrictions.

The opt-in compiler phase profiler reports lowering setup/body/finalization, ownership analysis subphases, and native compilation/code collection/context cleanup. Benchmark workloads can be selected independently; profiling is never activated by the feature alone.

These pages describe mechanisms. Source rules live in the language contract, and operation guarantees live beside the built-in APIs.