Documentation

Download and set up the tape compiler.

Your first tape program — from source to executable.

Real tape code examples — from hello world to components and error handling.

Tape's three strictness profiles: t0 (kernel), t1 (application), t2 (scripting).

Run tape programs via the VM interpreter or compile to native executables.

Quick reference for all tape syntax, types, and features.

Line comments, block comments, and nesting behavior.

Integer, float, boolean, string, void, and color types.

UTF-8 strings, interpolation, escape sequences, and the string/[]u8 boundary.

Compile-time constant declarations evaluated before runtime.

Bindings, mutability, and the tape type system.

Function declarations, default parameters, methods, and extern/export.

If/else, while, for loops, match, break, continue, and return.

Composite types with named fields, methods, and swizzle access.

Named integer constants with optional description strings.

How tape handles errors with T or Error — no exceptions, no hidden control flow.

Discriminated unions with pattern matching — safe sum types.

Nullable values with ?T — safe absence without null pointer bugs.

Raw pointers, const pointers, non-null pointers, slices, and arrays.

Arithmetic, comparison, logical, pipe, cast, and string interpolation.

Scope-exit cleanup — run code when leaving a scope, regardless of how.

Create named aliases for complex types.

Platform abstraction via runtime libraries and @link directives.

User-defined and built-in attributes for metadata and compiler directives.

Virtual module boundaries for safe, compiler-validated code extraction.

Component declaration syntax and keywords.

Tape's first-class component model — props, state, events, dispatch, and views.

Component inputs (props), reactive state (var), and interaction flags (state).

Typed single-handler events — no closures, no listener lists.

Declarative view trees, conditional rendering, list rendering, and slots.

Component mount hooks, paint dispatch, and the rendering pipeline.

Polymorphic component types via dispatch-based structural constraints.

Tape's memory model — scope-based cleanup for strings, manual allocation, and defer.

Who owns a value, how copies work, and how parameters borrow.

Stack vs heap allocation, the mem module, and where values live.

Module system, import syntax, visibility, and resolution.

Native library interop, extern functions, @export, @link, and output formats.

Which profiles can import which — and what happens at the boundary.

Tape's actor-based concurrency model — threads, pools, and message passing.

Thread declarations, pool sizing, thread-local state, and nested threads.

Streaming progress updates, emitter channels, and cooperative cancellation.

@tape blocks replace generics — execute arbitrary code at compile time.

Inject declarations and bindings at compile time using @emit.

@typeof, @sizeof, @has_field, @has_method — inspect types at compile time.

Embed files and compute constants at compile time.

Compiler-validated code extraction using refactor() blocks and tape refactor.

Sub-languages within .tape files — #code, #view, #style, #test, and more.

The default region — standard tape logic, functions, variables, imports.

Visual component declarations — tree syntax, props, slots, and events.

CSS-like component styling with variables, transitions, and animations.

Inline test cases — compiled only during tape test.

Inline x86-64 assembly for t0 kernel code.

Translatable strings with compile-time verification.

Embedded assets — icons, images, fonts, sounds, and binary data.

Compiler pipeline from source to binary — scanner, parser, TAC IR, backends.

Three-address code intermediate representation — opcodes, registers, and basic blocks.

TAC interpreter — direct execution without bytecode encoding.

x86-64 and ARM64 code generation — register strategy, instruction encoding, binary emission.

Compile tape source to a native executable or library.

Execute tape source via the VM interpreter.

Interactive read-eval-print loop for exploring the language.

Compile and run test cases from a file's #test region via the VM.

Type-check source without compiling or running.

tape tokens, tape ast, tape deps, tape disasm — inspect compiler internals.

Materialize refactor() virtual module blocks into actual files.