The right-click
An operating system asks which app should open a file. FabricLoom asks what you want the file to become.
Right-click anything in Finder (on macOS) and pick Transmute. The menu lists destinations: verbs that describe what is possible with this file, given the cartridges you have installed. A PDF can become text, page thumbnails, an audiobook, or an answer to a question. A video can become a transcript or a scene-by-scene summary. A folder of receipts can become a spreadsheet.
You choose the destination, not the steps. The system composes the route from the parts you have installed.
The menu lists what the file could become, not the apps that can open it. If you install a new cartridge, the same right-click on the same file shows new destinations without re-indexing or rebuilding anything, because the menu reads the capability graph live.
Planned pipelines
Drop a video and pick “transcribe.” FabricLoom finds the path on its own (extract the audio, decode it, run speech-to-text) and shows you the route before it runs.
For multi-step destinations, the planner draws the graph. Before any data moves you can see the route from input to result: which cartridge handles which stage, which media type flows between stages, and what each step is expected to output. If a step cannot be satisfied, for example because a cartridge is missing or a model has not been downloaded, the planner names it and the menu offers to install it.
This is pathfinding through a capability graph, not general AI planning. The graph is bounded by the cartridges you have installed, the same input always resolves to the same path, and the path can be inspected. No hidden agent chooses tools.
The planner is described in the CapDAG planner and executor documents. The dispatch rule that decides which candidate serves each step is CapDAG dispatch, and the selection of the most specific match when more than one applies is CapDAG ranking. The protocol is open and inspectable.
The library
The library holds every file you have added, every run that produced something from it, and every result indexed for search. The application opens to the library.
A run is a typed pipeline: an input file, a destination, a route through the cartridge graph, and the outputs each step produced. Runs are reproducible, since the same input, cap selection, and installed cartridges trace the same path. Runs are also inspectable: you can open one to see every step, its progress events, its memory and time use, and its output payload.
Outputs are typed too. A summary is text. A transcript is text with optional timestamps. A thumbnail is a PNG. A “make decision” output is a JSON record with a discriminated value. Because the library knows what each output is, the search index can read it, and the next Transmute on it knows which destinations are reachable.
Live progress
Every step shows what it is doing at that moment: the page being rendered, the frame being decoded, the token being generated. Memory, throughput, and elapsed time are shown alongside.
Live progress is part of the protocol. Cartridges emit LOG and progress frames over the Bifaci wire as they work, and the host translates those frames into UI events for the running task. Tokens per second, frames per second, and percent complete are real readings, not animations. See CapDAG progress and logging and progress mapping for the wire-level details.
A stalled step shows why it stalled, and a failed step shows where it failed. Heartbeats prevent a stuck cartridge from hiding behind a spinner: a missed heartbeat tears the cartridge down and reports the failure on the task.
Tasks under memory pressure
Local AI runs on whatever computer you have. Some pipelines are large, some files are larger, and some models use a lot of memory as soon as they load. FabricLoom monitors process and host memory continuously and applies graduated responses:
- Normal (under ~70% pressure): full performance.
- Warning (70–80%): logging tightens and monitoring frequency increases.
- Pressure (80–90%): light throttling on non-essential operations and smaller queue limits.
- Critical (90–95%): running tasks can be cancelled, and the scheduler stops starting new ones from
PENDING. - Emergency (>95%): heavy throttling everywhere, unused models unloaded, and non-critical requests rejected.
Under critical memory pressure, running tasks are cancelled and pending tasks are not started until pressure returns to normal. Tasks never wait in a throttled state.
LLM-specific memory is tracked separately so FabricLoom can decide which models to keep loaded and which to evict when pressure rises. Models that have not been used recently are unloaded first, and models actively serving a request are unloaded last.
Local operation
FabricLoom runs on your own computer, on macOS, Windows, and Linux. There is no account to create, no key to paste, and no subscription. Files stay on your disk and inference runs on your computer. Without a network connection the only thing that changes is which models you can download; the ones already installed keep working.
On macOS the application is sandboxed by default, signed and notarized, and native on Apple Silicon.
On macOS the cartridges that do the work run in a separate XPC service with no default network access. A cartridge that proxies to a cloud service must declare that and be reviewed before it is accepted, so nothing communicates outward without your knowledge. See Cartridges for the sandbox details and Contributing for the review criteria.
Where to read next
- Models: bring-your-own-model, including pasting a HuggingFace id, the MLX/llama.cpp/Candle backends, and model families.
- Capabilities: what the menu shows and how it gets there.
- Cartridges: install layout, sandboxing, and code signing.
- Build your first cartridge: scaffold, install, and run a development capability.