Glossary

One line per term, with a link to where it’s actually taught. Terms are alphabetical. If you meet a word in the docs that isn’t here, that’s a bug in the docs; please add it.

adopt: folding a remote value into a draft without re-sending it. Echoes are ignored, clean fields update, dirty fields win. Reactive state.

arena: a container that owns many values and hands out handles to them. The tool for graphs and cycles. The memory model.

backed enum: an enum whose payload-free variants carry an explicit string or integer — enum Align { Start = "flex-start" }. The variant is that value at run time (no tag, no wrapper), which is why value() costs nothing, parse is offered, and it keys a Map with no derive. Its runtime domain is the host’s, so an exhaustive match traps on a value outside the set. Data and traits, spec §5.2.

binding: a name introduced by let (immutable) or mut (mutable). Values and types.

bound: a requirement on a generic parameter, like T: PartialEq: “any T that can be compared”. Data and traits.

boundary (disposal boundary): a place where a UI subtree can die: a mounted root, a list row, a when/swap body. Each boundary has an owner. Building UI.

claim: any alias into an owner: a view, an arena handle, a loan of a resource. Valid only while the owner’s epoch is unchanged. The memory model.

codec: the wire format both ends of a connection agree on: json_codec() (readable) or binary_codec() (compact). Services & RPC.

context (ambient value): a value carried invisibly to the code that needs it, like the current owner or turn. Established with run, read with get. Functions & closures.

contract check: at connect time, client and server compare a hash of the service’s shape. A stale client fails cleanly instead of corrupting calls. Services & RPC.

copy: what every binding, assignment, argument pass, field store, and return does to a value. The receiver gets its own; the original is untouched. The signature decides: a function returning Inner returns a value even where its body names the receiver’s storage; one returning &mut Inner returns the projection. The memory model, spec §6.1.

derive: an attribute like [derive(PartialEq, Debug)] that generates a trait implementation from a type’s shape. Data and traits.

dirty: a draft whose local value has edits the server hasn’t confirmed yet. Dirty fields ignore adoption; the user’s text wins. Reactive state.

draft: a local-first cell for editing server state: typing updates locally at once, commits in the background, and keeps your text on failure. Reactive state.

drop: destruction. The Drop hook runs at an owner’s scope end; drop(x) moves a value in to destroy it early. Only resources have one. Resources.

echo: your own change arriving back through a mirror. A draft recognizes it and does nothing, so your caret never jumps. Reactive state.

effect: code that runs now and again on every change of a signal, cleaned up automatically by its owner. Reactive state.

entrypoint: fun main in the entry module. It runs automatically; on Node the process exits when it finishes. Async.

epoch: an owner’s abstract version counter. It advances when the owner is rebound, resized, moved, or dropped; a claim is valid only while it has not. The memory model.

extern: a declaration binding a host (JavaScript) function, object, or property so Vilan code can call it. Platforms.

frame: one encoded message on the wire. You only meet it when building custom transports. rpc reference.

handle: a small copyable id into an arena. Storable anywhere a value is, which views are not. The memory model.

lang item: a std declaration the language itself depends on, like Option for ?. or Add for +. Spec appendix.

layer: the platform-specific part of the standard library. Base is everywhere; the browser layer is browser-only; the process layer is server-only. Platforms.

local-first: updating local state immediately and syncing in the background, instead of waiting on the network. What drafts implement. Reactive state.

mirror: an [expose]d server signal that every connected client receives a live copy of. The server writes; every client updates. Services & RPC.

monomorphization: how generics compile: each concrete use gets its own specialized code, so generic dispatch has no runtime cost. Data and traits.

nursery: the structured way to spawn: nursery(body) joins every task spawned in the body’s dynamic extent before returning the body’s value, applies the first-observed error rule, and owns the cancellation signal std IO listens on. Async.

owner: the object that collects subscriptions and disposes them when its subtree dies. Created by the framework at boundaries; you rarely touch one directly. Reactive state.

panic: aborting the program with a message, for states that should be impossible. Expected failures are Results instead. Control flow.

pattern: the shape on the left of a match arm: a variant to match, payloads to bind (Some(let x)), a literal, or _. Control flow.

platform: what a package builds for: Node, Deno, Bun, or the browser. Decides which std layers are importable. Platforms.

prelude: the names available without imports. Two layers: the built-in set the language always has (the primitive types, List, void), and a per-package set named by [package] prelude — std’s base one (print, Option/Some/None, Result/Ok/Err) by default, "std::web" for applications, any module for a custom one, or false for none. A prelude is the weakest scope: declaring or importing one of its names shadows it silently. Spec §4.7.

resource: a value with a single owner that moves instead of copying and is destroyed deterministically after its last use (a Database, an OwnedNursery). Resources.

safe integer: an integer JavaScript’s 64-bit floats represent exactly: anything within ±2^53. Vilan’s i53/u53 are named for this window. Values and types.

service: a server struct whose [rpc] methods clients call and whose [expose]d signals clients mirror. Services & RPC.

signal: a value cell that code can subscribe to. The unit of reactive state. Reactive state.

spawn: starting async work without waiting for it: async expr. Gives you a Task<T>. Async.

subscription: one live “call me on change” registration on a signal. Effects manage theirs through owners; manual sub hands you the object to dispose. Reactive state.

suspension: a point where a function pauses and other code runs: a call to something async, or an explicit await. Views may not be held across one. Async.

task: the handle a spawn yields: eager, opaque, copy-refers-to-the- same-task. A task’s failure is absorbed at the spawn: a later await receives it; an unobserved failure is reported, not crashed on. Async.

trait: a named capability a type can implement, used as a bound on generics. Like an interface, but explicit and compile-time only. Data and traits.

transport: the thing that carries rpc calls: the reconnecting WebSocket in production, http or in-process variants for special cases. rpc reference.

turn: a batch of signal writes that becomes visible at once. Event handlers and rpc handlers each run in one automatically. Reactive state.

value semantics: the rule that data is copied, not shared, unless you use an explicit sharing tool. The memory model.

variant: one case of an enum, possibly carrying data: Shape::Circle(2.0). Data and traits.

view: a short-lived borrow of a place (&x, &mut x) that aliases instead of copying. Can’t be stored, returned into long-lived state, or held across a suspension. The memory model.

wave: one settling of a turn: every affected watcher runs once with the final values. Reactive state.

Wire: the “can travel over the network” capability: scalars, lists and options of Wire types, and anything with [derive(Wire)]. Services & RPC.