loom

loom is the small host and runner for Luce library artifacts. It validates a compiled program, hands it the machine through one explicit boundary, calls it, and gets out of the way.

Luce is the language and luce is its compiler. A normal first program does not need loom: luce build hello.luc produces a standalone hello executable by default. loom is useful when you deliberately build a .lc library artifact or want a compile-cache-run loop for source.

Install the complete toolchain

The one-command macOS ARM64 installer on luce.luciaos.com installs luce, loom, the terminal editor, runtime libraries, and local VS Code/Cursor highlighting. It also adds the install's bin directory to the shell profile. The repository is private; the public installation path is the checked release, not a source build.

Run an artifact or run source

Command	Meaning
`loom run app.lc [ARGS]`	Validate, load, and call an already compiled library artifact. No compiler is needed.
`loom app.lc [ARGS]`	Shorthand for the same run.
`loom luce app.luc [ARGS]`	Compile when the cached artifact is absent or stale, then run it.
`loom app.luc [ARGS]`	Shorthand for the source form.
`loom`	Open the small interactive command shell.

A .lc is native machine code in a tagged shared library. The direct run is one validation, one dlopen, one symbol lookup, and one call. The interpreter remains a test-only differential oracle and ships in nothing.

What belongs here

Running programsArtifact tags, source compilation, project caches, compiler discovery, and exit statuses. The shellA deliberately small interactive or piped command loop, with failures scripts can observe. The hostThe single versioned boundary for files, terminals, workers, clocks, windows, GPU surfaces, and other effects. The editorAn ordinary Luce program using termui, installed as its own command rather than built into loom.

What loom deliberately does not contain

No language engine. It does not interpret bytecode or implement Luce semantics.
No code generator. It links no LLVM. A cold source run calls the separate luce binary; a warm run and a direct artifact run do not.
No application framework. The editor, terminal UI package, and future GUI packages are userland Luce.
No private persistent world. The current system uses normal OS files. Larger persistence ideas remain deferred until the language release gate is complete.
No ambient capability. A platform service exists only when the supplied host table contains it.

One program, one behavior

A library artifact under loom and a standalone executable use the same runtime and host semantics. Debug artifacts report source locations and call traces; release artifacts omit locations but keep the same safety rules. A trap, uncaught error, explicit exit, or host refusal reaches the invoking shell with a defined status.

The language itself—types, ARC status, errors, packages, tests, and the standard library—is documented at luce.luciaos.com. The Direction page explains what the ordered language roadmap means for this deliberately small tool.