Carla

Carla is a Loom TUI and Character Lab for developing new AI characters from base models. Supply seed documents, explore alternative continuations, curate an anthology, simulate conversations from it, and evaluate the results to decide what belongs in a training set.

Local Qwen3-30B-A3B Base · four-conversation Loom · playback at 1.5× speed.

A Loom lets you explore branching model-generated text: continue a passage, compare alternatives, edit or fork a version, and follow the paths worth keeping. Carla brings that workflow into the terminal with local inference and inspectable prompts, model settings, ancestry and judge results.

Seed documents → Continuations → Anthology → Conversations → Evaluation → Training data
   Library          Branches      Anthology     Simulator     Evaluate       Export
                       ↳ loom                      ↳ loom

Carla currently implements data generation, curation, evaluation and export. An anthology conditions the conversation model through its prompt; it does not change model weights. Training support is a future stage. The project is inspired by Computer's document-grown character work, without claiming to reproduce its training protocol or results.

Quick start

Requirements: Python 3.11+, uv, Go 1.26+, and a UTF-8 terminal of at least 60 × 18 cells. Development is on macOS; Linux is included in CI but has not had equivalent interactive validation. Native Windows is unsupported (Unix workspace locking and process replacement).

Clone the repository, enter its directory, and launch Carla:

git clone https://github.com/k3nnethfrancis/carla.git
cd carla
make install
carla

make install prepares the Python environment, builds the terminal interface, and installs a launcher in ~/.local/bin. If that directory is not on your PATH, the installer prints the line to add to your shell profile.

After that, run carla from any directory to resume your last workspace. Use carla --workspace first-experiment to create or open a named workspace.

On first launch, Carla opens a setup dialog if no configured GGUF is available. Use ↑/↓ and Enter to choose, or Escape to go back:

• Download a tested Qwen3 8B, 14B, or 30B-A3B Base GGUF (Q4_K_M).
• Paste a Hugging Face repository or GGUF file URL and choose a file to download.
• Point to a local GGUF without copying it.
• Skip setup to browse the bundled Meditations and Tractatus starters offline.

Downloads show their size, license and pinned revision before confirmation. Use /config → models → + Add model, or run carla --setup-model, to add another model. Generation also requires llama-server on PATH; see generation setup.

Once inside Carla, select a passage with Space, open it with Enter, and explore the panes with Tab / Shift+Tab. Type /help for commands or /config for editable bindings. / focuses the command bar, including from the document editor. The Keys dialog covers listed actions and navigation; its own capture, reset, save and cancel controls stay fixed so you can always recover a binding.

From a seed to evaluated conversations

With a base model configured, one small experiment takes six steps:

1. Library: select seed passages with Space, then Enter to open them in Branches.
2. Branches: run /loom 3 --tokens 512 to explore three continuations.
3. Keep a favorite: select a result and use /add to keep it in Anthology.
4. Anthology: select that document and run /loom 4 --turns 2 to open four conversations in Simulator. Select a conversation or its parent set and use /continue to take it further.
5. Judge: configure an Evals policy in /policy → Evals, including its model and behaviors. Select conversations and run /eval using the active policy.
6. Curate and export: review results in Evaluate, mark useful items for training, then /export the selected data and metadata. Training itself is not implemented yet.

You only need Loom → Add → Loom → Eval → Export for this first pass. /config sets defaults, /policy sets judging rules, /inspect explains a saved result, and /stop stops active work. Monitoring, automatic selection and multiple loops can wait until this basic flow feels familiar.

Commands at a glance

Type / anywhere to open the command bar. Start typing, use ↑/↓ to select a suggestion, and press Enter. Commands relevant to the current page appear first. The highlighted suggestion shows its available arguments below it—even while typing a prefix such as /lo. /help explains each option; press Enter on a command for scrollable details.

Command	What it does
/add · /remove	Add or remove material from the current collection.
/branch	Copy selected material without generating, preserving ancestry.
/continue --tokens 512	Advance the existing item or set; preserve earlier revisions.
/loom 3 --tokens 512	Generate three alternative futures of the selected item or set.
/loom 3 --turns 2 --visitor "What matters to you?"	Explore three conversational alternatives from your supplied message.
/eval "Voice" --train-on-pass true	Judge selected content and optionally mark passes for training.
/export	Save selected content or the current collection with provenance.
/config · /policy	Configure execution defaults and judging policies.
/stop · /help	Stop active work or browse command help.
/library · /branches · /anthology · /simulator · /evaluate	Open a stage.

Commands covers flags, selection, editing and exports; the generated reference shares its source with /help; interaction model explains object identity and grouping. Models, workspace selection and keybindings are available through /config.

Continue, Loom and Branch

/continue and bare /loom advance what you selected. /loom N with N≥2 creates N alternative futures of it. /branch copies it without generation. The same meanings apply to a single item or a set: selecting four conversations and running /loom 3 produces three sets of four; /continue advances the original four. Prior revisions and ancestry remain saved, while evaluations refer to the exact content they judged.

Library opens seeds in Branches. Anthology Branch/Continue returns to Branches; Anthology Loom starts Simulator. Simulator uses conversations. With no Simulator selection, /loom 4 starts four fresh conversations. Space/Enter selects a target; arrows only preview. Clear selection to start fresh again. New document versions must be kept explicitly with /add.

/loom 3 --tokens 512 --visitor "What does a path remember?" --turns 2 --eval "Voice" --loops 4

--tokens caps each generation; --turns counts new character replies. --visitor supplies a message once per selected conversation. --model and --visitor-model override configured models for this operation. --eval judges completed outputs. --loops repeats continuation from each output. Selection is Off by default; enabling it in /policy lets a judge choose whole alternatives between split loops.

Set up generation

To generate, install llama.cpp with llama-server on PATH and supply a base-model GGUF you are licensed to use. The server must support unified KV cache and continuous batching; see model setup. The first-run setup writes model configuration for you. To add a model later:

carla --setup-model

GGUF is a file format; quantization is optional. Model weights are never bundled or downloaded automatically. A missing model does not prevent source browsing.

Policies and evaluations

These use criteria to judge text, but serve different purposes:

Mechanism	When it runs	What the result does
Monitoring	During generation and/or after replies	Flags conditions such as looping; warns or stops only as configured. Off by default.
Selection	Split Loom runs with explicit --loops	Reviews candidates and chooses one path to develop. Does not automatically keep or mark it for training.
Evaluation	On saved items, or after /loom --eval "name"	Records whole-item judgments and frozen inputs in a saved run. Dataset membership is explicit.

Plain document /loom, /loom N and /continue generate without judging. Use --monitoring on, --selection on (with 2+ alternatives and explicit --loops) or --eval "policy" to opt in. Simulator uses its saved monitoring/selection settings.

Use /policy to configure monitoring, selection and evaluation policies. Selection uses a local instruct model. Monitoring can use local DiffusionGemma through OpenJev, or optional Jev through OpenRouter. Each evaluation policy uses one registered local instruct model as its judge. After one-time setup, Carla starts and stops the Apple Silicon classifier automatically on an available local port. Hosted classification sends the assessed text to an external service and can incur charges. Local generation itself uses llama.cpp.

/policy always opens Monitoring, Selection and Evals. Each category holds named policies with behaviors, judge settings and role-specific result handling. Monitoring and Selection use On/Off: enabling one switches the previous policy in that category Off. /behaviors is a reusable workspace library of specs; adding a spec to a policy keeps its settings local.

Evaluate separates Data, Policies and Runs. Data is the saved documents and conversation traces. Policies contain behaviors and judge settings as separate sections. Each policy has one judge that assesses its enabled behaviors. The Policies view edits the same policies as /policy → Evals. + New run configures a dataset, policy, data scope and On pass setting for one execution; Runs preserves its assessments. In Evaluate, /eval opens that setup for the focused dataset or selected items. Outside Evaluate, it runs the active policy on selected material. /eval "Voice" chooses a named policy. Adding data does not invoke a model. You can mark training items manually or use /eval --train-on-pass true to mark items that pass every behavior in that run.

Selection and Evals separate observed behavior from Pass when · Present/Absent. Selection assesses each candidate before choosing among those that pass; Evals records whole-trace results and can mark passing data for training with On pass. Imported specs start Off for review.

Changing a prompt, model or setting can be evaluated with the same collection and criteria; evaluation is not limited to training decisions. Saved source snapshots and judgment histories remain intact. Attached monitoring or selection evidence keeps its original scope rather than becoming a whole-item pass. Read the policy and evaluation guide for the complete flow.

Prompts and templates

You can inspect the actual inputs behind generated text with /inspect. Configuration exposes these authoring surfaces:

Input	Where to change it
Continuation input	Edit/fork the document and place the cursor; the exact prefix is sent to the base model.
Character and Visitor templates	Simulator → /config → Prompts → Character prompt / Visitor prompt
Visitor brief	Simulator → /config → Prompts → Visitor brief
Fixed or generated opening	Simulator → /config → Opening; generated mode has its own prompt, model and sampling.
Selection behaviors, assessment and choice templates	/policy → Selection
Monitoring behavior specs	/policy → Monitoring → a policy → Behaviors
Evaluation criteria	Evaluate → Policies → a policy → Behaviors
Evaluation judge prompt and Call mode	Evaluate → Policies → a policy → Judge

Document Loom has no separate system-message wrapper. Conversation templates are explicit raw-completion prompts with anthology/history placeholders; there are no hidden memory or reflection steps. Prompt configuration shows the defaults, allowed fields and inspection behavior.

Documentation

• User guide: first experiment, editing, comparison, data storage and recovery.
• Commands: all commands, flags, targeting and keyboard behavior.
• Configuration: models, sampling, prompts, source imports and credentials.
• Local DiffusionGemma judge: Apple Silicon setup, behavior specs and resource limits.
• Policies and evaluations: monitoring, selection, judging and training exports.
• Architecture, development and research references: implementation and contributor context.

Toward training

The next research stage is to connect curated data to training and evaluate the resulting models. Candidate features include dataset preparation with explicit splits and loss masks, supervised character/conversation fine-tuning, preference training from reviewed feedback, and loading trained checkpoints back into Carla for comparison. These are directions, not shipped features or a fixed schedule. A pass label alone is not a preference pair, and an exported trace is not yet a trainer-specific dataset. The immediate priority remains a dependable generation and evaluation workflow, developed with collaborator feedback.

What to expect

• Inference uses local llama.cpp raw completions. Base-model continuations have no hidden assistant prompt, RAG memories or reflection step. Simulator templates are explicit and inspectable; the selection judge uses a separate chat endpoint.
• Up to four requests share one resident model, subject to memory and full prompt/output context reservations. This is a conservative heuristic, not an optimal throughput scheduler. Large budgets can serialize requests. Same-model conversations advance independently; different model aliases require barriers for unloading/loading weights.
• --tokens is an output ceiling, not a required length. Max reserves the remaining context, often leaving room for only one request. EOS or an explicit speaker boundary can end a reply earlier. Token-limit observations do not end later conversation turns.
• Quality is an open research question. Base models can imitate source authors, drift, loop, or produce disturbing content. An anthology is context for the simulator, not evidence that a character has been learned in weights.
• Workspaces retain raw prompts and outputs. They can become large; streaming uses an incremental journal, but full checkpoints still occur at turn and operation boundaries. Recovery covers process crashes, not guaranteed survival of power loss. Back up valuable workspaces.
• The app has no training jobs, calibrated judge dashboard, multi-user service, remote deployment, or automatic research conclusions.

Develop and contribute

Track bugs and features in GitHub Issues and submit feature/fix PRs to dev. Reviewed changes reach main through promotion PRs. Our current focus is data-generation stabilization: UX, functional reliability and focused code review. Training work follows validation of this stage with collaborators. See development and releases and the Carla TUI design skill. Run carla --version when reporting a problem.

make test
make lint
make build

Tests use synthetic documents and fake inference; they need no weights, GPU or API keys. The optional monitoring eval compares System One probability distributions and latency outside the app; its results stay local and gitignored. See architecture for code boundaries and research references for method context.

Code is MIT licensed. Imported texts, model weights and generated artifacts retain their own applicable terms. The starter library includes third-party texts; see source attribution. For optional hosted monitoring and stored trace details, see configuration.

Releases

Carla uses versioned source releases, including v0.1.0, v0.1.1, and v0.2.0. Each reviewed promotion to main receives a new version and publishes a matching GitHub release after macOS/Linux checks pass. dev is ongoing work. See GitHub releases for pinned versions and release notes, and the release workflow for contributor instructions. Training is not yet implemented.