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.

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 assignment, argument pass, and field store does to a value. The receiver gets its own; the original is untouched. The memory model.

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.

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 few names available without imports: the primitive types, List, void. Everything else is imported explicitly. Spec §4.

resource — a value with a single owner that moves instead of copying and is destroyed deterministically at scope end — 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.

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.

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.

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.

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.