A tour of Seabiscuit.

One file, one policy. The signature names its inputs and outputs with their types; inputs may have defaults. Below it come header lines (optimiser, loss, metrics, import), then the body.

The body is bindings: name = expression. Rebinding a name shadows it, and each output is the last binding of its name. Indentation means nothing; a newline ends a statement unless the line obviously continues, inside brackets, after an operator, or on a line that starts with |>.

Every operation is a pure function from the prelude, so there's nothing to import to get started, and the compiler knows the type of every value.

x |> f(a, k: v) is exactly f(x, a, k: v), so a chain of operations on a cloud reads top to bottom. Arguments are positional first, then named; a literal argument is a frozen constant of that node.

Point selections take a predicate over per-point coordinates written with a leading dot: .x .y .z on a cloud, .u .v on a section. Comparisons chain, and and, or and not combine them.

Every number has a dimension. Lengths are written m, cm, mm, ft or in; angles rad, deg or °. A bare number is a Scalar, and there's no default unit, not even for zero.

+, - and comparisons need matching dimensions; * and / combine them, so Length² and 1/Length fall out naturally. sin takes an Angle, atan2 returns one, and a postfix ° turns a Scalar expression into an Angle.

Get it wrong and the compiler says where, and what you probably meant (see Diagnostics). Everything is stored in metres and radians; units are for reading and writing.

Gaussian, Mixture, Grid, Samples and Categorical are ordinary values. A Gaussian is a mean plus coefficients on named, independent noise sources, so sums, differences and scaling are exact, and two values that share a source stay correlated.

Anything nonlinear on a Gaussian is a compile error that points you to sample(x, n) or .mean. Every distribution has .mean, .sd, interval, cdf and log_prob.

bayes_update(prior, likelihood) is one node with two outputs, the posterior and the evidence; take either by name. The sensor fusion example (fuse.sb) uses both.

Every literal is frozen. Write tensor(...) where a number is unknown and it becomes trainable, with its unit, optional bounds and a typical step size. Bounds hold by reparameterisation, never by clipping. frozen: true makes a named, stored constant instead.

The optimisers are declared in the header: delegate lets nodes with a closed-form or convex fit (linear, stack, conditional_logit) solve their own tensors, and a built-in optimiser such as adam or cma_es trains the rest. loss says what good means against your labels; metrics are scored on held-out folds and never steer training.

Trained values are stored under stable keys named after the binding, so reordering lines never swaps them.

A fn is typed like a policy and inlined at every call site. In the graph, each call becomes a group labelled width_at → front: the callee and the name its result is bound to. A tensor declared inside a fn gets one copy per call site; one declared outside is shared.

Constants pass through, recursion is an error, and the compiler caps how much inlining a policy can do, so a graph never explodes silently.

Policies live in a git repository, one file each. import policy calls another policy as one node, using its current deployment; @sha pins a commit, and (frozen: false) inlines it so its tensors train as part of yours. import tensor brings in a stored value, frozen unless you say otherwise.

While you work, unpinned imports float. Deploying a policy writes a lock that pins every import, transitively, so production runs are reproducible, and rolling back restores code and trained values together.

Seabiscuit grew up on 3D scans, so point clouds, sections, planes, curves and paths are types, not plugins. The world frame is gravity-aligned with z up, and RANSAC and DBSCAN cleans are built in.

Nearly every operation is differentiable, geometry included, and extrema can come back as Gaussians with their error bars attached. The node reference lists them all.

Every diagnostic has a code, a span, a message and, where there is one, a concrete fix. They render rustc-style in the CLI and as JSON for the editor and the API.

Compilation tolerates errors: each top-level line compiles on its own, so one bad line never hides the rest of the graph. The error on the right is exactly what the compiler prints for box.sb, and the build checks it still is.

Next: see it all together in the examples, or start at the docs.