loom
Luce Engineering LuciaOS

Where loom is going

Every other page on this site describes the current tool. This page explains the direction. An ahead item is an ordered plan, not something the installed release can use.

What loom is today

loom is a deliberately small native runner and host. It opens a compiled .lc library, validates its tag, supplies the published host table, calls the program once, and reports the result. When asked to run source, it uses the separate luce compiler and caches the library. It contains no interpreter and no code generator.

That boundary is the part of the older LuciaOS idea that survived every rewrite: a program has no ambient machine access. Files, terminals, clocks, workers, windows, and drawing surfaces arrive through explicit host services. A missing service fails closed instead of guessing.

The language is the priority

The repository spent enough time building layers above an unfinished language to learn the dependency clearly: Luce must become a complete, pleasant language before persistence, synchronization, or a larger operating-system model can be useful. The current north star is therefore language-first.

The memory rule everything else must fit is:

Values copy. References share identity. ARC keeps references alive. Weak references break cycles. Resources close at the last strong release. Workers never share object identity.

The source language has removed its manual ownership operations. Ordinary references share, last release reclaims containers and resources, bound receivers retain their graphs, and worker snapshots preserve aliases without sharing identity. Both execution paths prove that ARC foundation before new type-system work begins.

The ordered language work

  1. ARC foundation — complete. Exact leak censuses, deterministic file and task lifecycles, retained bound receivers, ownership-safe worker transfer, and damaged-module hardening are release gates now.
  2. aheadAdopt explicit type names. Move atomically to u8…u64, i8…i64, f16/f32/f64, char, str, and bytes, with bracketed container applications.
  3. aheadAdd safe weak references. Built-in ARC objects need them too: recursive struct/container graphs can form cycles before classes exist.
  4. aheadComplete final classes. Shared identity, ordinary mutation, memberwise construction, identity tests, and deterministic teardown—without inheritance.
  5. aheadReplace interface storage. One owned payload, metadata, and witness table, supporting struct and class values, mutable dispatch, and heterogeneous collections.
  6. aheadAdd capturing closures. ARC environments, value snapshots, shared mutable cells, strong and weak captures, and block bodies.
  7. aheadProve it in userland. Build a higher-level UI layer over the existing low-level UI, GPU, and terminal surfaces, then move the editor onto it.
  8. aheadAdd generics later. Use them for a small set of library data structures rather than turning collection synonyms into language primitives.

What this means for loom

Most of the work above should not make loom larger. ARC, classes, interfaces, closures, and type checking belong in the compiler and shared runtime. loom continues to supply effects through the same versioned host boundary. If a new platform service is genuinely needed, it is appended to that table and the ABI version changes visibly.

The UI proving work may extend the host's low-level window or GPU channel, but widgets, application state, callbacks, and layout stay in Luce libraries. The editor remains an ordinary program rather than a loom command.

What remains later

Persistent identity, connected data, synchronization, capabilities as values, and multi-user work remain deferred. The repository keeps the old v1 records as history, not as an implementation schedule. They return for review only after the local language, toolchain, editor, installer, and documentation have passed their release gate.

The walls stay visible

  • loom does not acquire an interpreter or LLVM.
  • Luce does not acquire class inheritance, interface default methods, unsafe unowned references, or shared mutable worker heaps in this roadmap.
  • The shell does not grow into a stateful operating environment; programs do the work.
  • No host capability is added without an explicit ABI change and tests.

Reading further

  • docs/ROADMAP.md — the step-by-step plan and acceptance matrix.
  • docs/MEMORY.md — the current ARC contract and its cycle boundary.
  • docs/V2.md — the product north star.
  • docs/ENGINE.md and docs/CODEGEN.md — why loom stays small and how artifacts meet the host.
  • Luce Status — the public current-versus-planned boundary.