Locara

Apps that run only on your Mac.
No cloud. No tracking. Just yours.

Locara is a framework, runtime, and distribution layer for fully-local & secure LLM applications. Models, database, and tools run on the device. Capabilities are kernel-enforced. Telemetry is zero by construction.

transcribe — locara dev
locara.json
"name": "transcribe",
"modalities": [
  "speech-to-text",
  "text-to-text"
],
"capabilities": {
  "device.microphone": true,
  "models": [
    "whisper-base.en@sha256:…",
    "qwen2.5-1.5b@sha256:…"
  ]
}
Transcribe · ready
Listening — say something. whisper-base.en · qwen2.5-1.5b · all on-device

Built for developers who treat privacy and security as architecture, not policy.

v0.0.1 · alpha Apache-2.0 macOS · Apple Silicon 2 reference apps shipping 40+ modalities catalogued Zero telemetry
Manifest-first

Declare what your app does. The runtime enforces it.

Capabilities, models, and modalities live in a single locara.json. The runtime kernel-enforces every declaration: an app can't open the microphone unless it asked for it, can't load a model that wasn't pinned, can't reach the network unless the manifest says so.

Manifest schema
"capabilities": {
  "net": false,
  "fs": {
    "user-selected": true,
    "app-data": "read-write"
  },
  "device": {
    "microphone": true
  },
  "models": [
    "whisper-base.en@sha256:…"
  ]
}
Strongly-typed SDK

One API for chat, transcription, voice, embeddings, and OCR.

The SDK gives apps typed access to the local model registry, a vector store, transcription, and voice-to-voice — all mediated by the manifest's capability grants. The same surface works for hand-written and agent-generated apps.

SDK reference
// streams tokens, respects capability check
const reply = await llm.chatStream({
  messages,
  model: 'qwen2.5-1.5b-instruct-q4_k_m',
})
for await (const tok of reply) {
  ui.append(tok)
}
Local-first by architecture

Privacy here isn't a policy. It's a structural property.

Models live in a content-addressed cache. The database is a per-app SQLite file with a vector extension. Tools run inside a Wasmtime sandbox. There is no online — so there is no data leak.

Read the manifesto
Models content-addressed
Database SQLite + vec
Tools WASM sandbox
Network opt-in only
Telemetry none, by design
Updates re-consent on grant change
Verifiably secure

Security isn't a promise. It's a verifiable property.

Every capability is declared in the manifest. Every model is pinned by SHA-256. Every tool runs in a Wasmtime sandbox. Every .locapp is signed by Locara CI with a provenance attestation. The threat model is published, the spec is open, and the runtime refuses anything that isn't on the list.

Security model
$ locara verify transcribe.locapp
  • Manifest schema v1.0, well-formed
  • Capabilities 4 grants, kernel-enforced
  • Model integrity whisper-base.en@sha256:9b3a…
  • Tool sandbox WASM, sealed
  • Network access denied (not declared)
  • Binary signature locara-ci · 2026-05-03
Built for AI coding agents

The whole framework assumes you pair with an LLM.

Closed-catalog modalities. Strongly-typed SDK. Copy-in components. Manifests are the agent's primary surface — declare what you want, and the framework expands the rest.

Docs for agents
PROMPT

"Build a Locara app that transcribes meetings, finds the 5 most-discussed topics, and shows them as a tag cloud."

+ speech-to-text + text-to-embedding + text-to-text
The primitives

Six composable primitives. Each batteries-included.

A Locara app is composed from six independent primitives — models, inference, a local database, the toolkit, the interface, and the OS bridges. Each ships with batteries included. The manifest above declares which to wire in; the capability kernel enforces it at runtime; the signed .locapp is what they package into when you ship.

01 ─ Models Curated open-weight catalogue, by modality. Chat, vision, speech-to-text, text-to-speech, embeddings, OCR. Content-addressed weights pinned by SHA-256 and shared from one cache across every app on the device. Out of the box Qwen 2.5 · Whisper · BGE-M3 · Apple Vision · 40+ modality catalogue
02 ─ Inference Metal-accelerated, streaming, cancellable. The compute substrate that turns weights into tokens, audio into transcripts, pixels into text. Sub-second first-byte latency on Apple Silicon; cancellation at every step. Out of the box llama.cpp · whisper.cpp · Wasmtime · Apple Vision · Candle (next)
03 ─ Local Database SQLite + sqlite-vec + FTS5, per app. One per-app file with general SQL, vector kNN search, and full-text search built in. The OS treats it like any other document — backed up, encrypted at rest, owned by you. Out of the box SQL · kNN vector · FTS5 · migrations · WAL · transactions
04 ─ Toolkit WASM-sandboxed tools, batteries included. Wasmtime + WASI guests. Each tool sees only what the manifest grants — no fs/net escape, fuel-bounded CPU, sealed memory. Pick from the catalogue or bring your own WASM. Out of the box OCR · filesystem.search · document parsers · custom WASM tools
05 ─ Interface Copy-in UI components, themable. Linear/Anthropic-grade design system. Components copy into your repo so you can customize freely; accessibility, keyboard handling, and streaming UI patterns are already wired in. Out of the box Chat · ChatInput · AudioInput · DocDropzone · DocPreview · TranscriptStream · ResultsList · MessageBubble
06 ─ Device & Files Capability-gated OS bridges. Microphone, camera, screen-recording, user-selected files, user-folders, opt-in network. Each access is gated by the manifest's declarations and audited by the kernel. Out of the box audio.openMicrophone · fs.pickFile · fs.user-folders · device.camera · device.screen-recording
Composing apps from primitives

The same six primitives. Three different apps.

Picking primitives is the work — Locara handles the wiring. Below: three reference apps, side by side, with the exact primitive choices each one makes.

Reference app · shipping

Transcribe

Local-only audio transcription with semantic search across recordings.

  • Models
    • whisper-base.en
    • qwen2.5-1.5b-instruct
    • bge-m3
  • Inference
    • whisper.cpp · llama.cpp
  • Local Database
    • SQLite + FTS5 + vec
  • Toolkit
  • Interface
    • AudioInput · TranscriptStream
    • ChatInput · ResultsList
  • Device & Files
    • microphone
    • user-selected files
Reference app · shipping

DocVault

Local OCR + semantic search across your documents and images.

  • Models
    • qwen2.5-1.5b-instruct
    • bge-m3
    • Apple Vision OCR
  • Inference
    • llama.cpp · Apple Vision
  • Local Database
    • SQLite + vec + FTS5
  • Toolkit
    • ocr-tool
    • filesystem.search
  • Interface
    • DocDropzone · DocPreview
    • ResultsList · ChatInput
  • Device & Files
    • user-selected files
    • Documents folder
Reference app · in flight

Voice

Live, full-duplex voice agent. Speak; the model speaks back.

  • Models
    • moshiko-7b (voice-to-voice)
    • or whisper + qwen + kokoro-tts
  • Inference
    • candle-moshi (subprocess)
    • or whisper.cpp + llama.cpp + system TTS
  • Local Database
  • Toolkit
  • Interface
    • AudioInput
    • MessageBubble
  • Device & Files
    • microphone
    • speaker

Same primitives. Different recipe. The shipped .locapp is just the assembled output — what changes between apps is the composition above the contract.

The catalogue

40+ modalities. Open-weight models. Honest status per pillar.

Every input/output transformation a foundation model can perform — mapped to representative open-weight models, the infrastructure Locara needs around them, and what's shipped vs. missing.

Browse all
Reference apps

Two apps shipping today. Built with the framework, by us.

Build with Locara

From zero to a working local app in four steps.

  1. 1

    Install the CLI and scaffold an app

    locara init transcribe my-app — gives you a working manifest, an empty SDK consumer, and a Tauri shell. Editable with any editor.

    Quickstart
  2. 2

    Pick a modality and a model

    Browse the catalogue. Pick a modality (e.g. speech-to-text). The CLI fetches the content-addressed model and pins it in the manifest.

    Modality catalogue
  3. 3

    Wire it up with the SDK

    Call llm.chat, transcribe.fromMic, embed.embed. Every call is capability-checked against your manifest at runtime.

    SDK reference
  4. 4

    Build, sign, ship

    locara build produces a signed .locapp. Sideload, distribute, or publish to the registry when it opens.

    Distribution model
Why we're building this

The most personal computing of all is the kind that stays on the device.

Locara exists because privacy needs to be architectural, not legal. We're building the framework, the runtime, and the catalogue so that a local-first app is the default path, not the heroic one.

Read the manifesto
Recent highlights All docs

Build a Locara app.

Get started