Cellar

A Claude Desktop-style app for local models. Chat with models running on your own GPU through Cellar's built-in llama.cpp engine, or through Ollama, LM Studio, Unsloth Studio, or any OpenAI-compatible server. Find and download GGUFs from Hugging Face with LM Studio-style control over how they load.

This build: Milestone 1 (app shell, Chat, Projects, Artifacts, incognito chats, the Model Hub and all backends), Milestone 2 (Cowork agents), Milestone 3 (Code), Milestone 4 (Customize, Scheduled, voice), Milestone 5 (Design), Milestone 6 (Math) and the Playground. Follow-ups and known gaps are in docs/ROADMAP.md.

Features

• Claude-style shell: sidebar (New, Projects, Artifacts, Scheduled, Customize, chats and tasks, Design, Math, Playground), custom title bar with back/forward, search (Ctrl+K), Chat/Code switch and the incognito ghost.
• Chat:
  • Streaming Markdown (code highlighting, math, Mermaid), collapsible thinking blocks and thinking-level control.
  • Retry and edit with switchable branches, stop, and auto-generated titles.
  • Attachments: images for vision models, shown as thumbnails; PDFs, text and code.
  • Generation stats (tok/s, tokens, time to first token) and a context meter.
  • With tool-capable models: web search, connector tools, skills, memory and past-chat search, with the steps shown inline.
• Customize:
  • Skills: SKILL.md folders; create them, import .skill/.zip files or Claude Code skills.
  • Connectors: MCP servers over stdio, Streamable HTTP or SSE, with per-tool Allow / Ask / Off and import from Claude Desktop.
  • Plugins: the Claude Code layout (skills, commands, .mcp.json), installed from a folder, a zip or a git URL.
  • Slash commands: /tools, /remember and your own Markdown commands.
  • Memory: facts models keep across conversations.
• Design: a canvas where a local model builds slides, pages, posters, web pages and app screens, and you refine them by hand.
• Math: a study board where a local model teaches. It never does the arithmetic itself — Cellar works it out:
  • Exact calculator: fractions and square roots stay exact (12/13 + 5/13 = 17/13, cos 30° = √3/2), with the decimal alongside. Models get it as the calculate tool, in Math, Chat and Cowork.
  • Step-by-step derivations written the way a notebook does: a² + (√3)² = 2² → a² + 3 = 4 → a² = 4 - 3 → a = 1, for expressions, linear and quadratic equations, the Pythagorean theorem and the trigonometric ratios of a right triangle.
  • Figures: labelled triangles (a missing side is worked out and the right angle marked), squares, rectangles, circles, polygons and angles, with lengths as numbers, roots or letters. Function graphs on labelled axes.
  • Practice tests generated by Cellar with correct answers and worked solutions; answer them on the board and check yourself.
  • Whiteboard blocks with pen, line, arrow, shapes and eraser on squared paper.
  • Export a study sheet as PDF, PNG or Markdown, or a test paper with the answer key on its own page.
  • Describe what you want; the model picks a theme and creates artboards from layouts (cover, bullets, columns, chart, stats, cards, quote, hero, app screen, poster…) or places elements itself. It sees the canvas and your selection, so "make this bigger" works.
  • Visual editing: select, move with snapping guides, resize, edit text in place, arrow-key nudging, align and order, layers, undo/redo, copy/paste, image drop and paste, pan and zoom.
  • Properties: position, typography (font, size, weight, line height, tracking, alignment, lists), colors from the theme or custom, fills, borders, radius, shadows, chart type and data.
  • Themes (10 presets or your own colors and fonts) restyle every artboard at once; elements refer to theme colors by name.
  • Export to PDF (one page per artboard), PowerPoint with editable text and native charts, and PNG; present full screen.
• Playground: two models, one prompt, side by side. The left model answers first and the right one starts the moment it finishes, so neither is slowed down by the other sharing the GPU — then you read both answers, with tok/s, tokens and time to first token under each.
  • Tools work as they do in Chat (web search, connectors, skills, the browser), so you can compare how two models handle the same tool use.
  • Follow up with one model on its own: Follow up under an answer aims the next prompt at that side, and a turn the agent loop paused has a Continue button that picks it up where it stopped. The other side sits the round out.
  • Both sides are incognito and nothing is saved.
• Scheduled: prompts and Cowork tasks on cron schedules with local models, run history and notifications. A notification-area icon keeps them running when the window is closed.
• Voice dictation: the mic button transcribes speech on your computer with whisper.cpp (Cellar installs the build and a model).
• Quick entry: a global shortcut (Alt+Shift+Space) opens a small window for a quick question.
• Cowork: describe a task and a local model works through it inside a folder you choose.
  • Tools: list, read (including PDF, Word, PowerPoint and Excel), write and edit files, glob and grep, PowerShell commands, web search (DuckDuckGo or SearXNG) and page reading, a live plan, and Word, Excel, PowerPoint and PDF creation.
  • Designed documents: PDF, Word and PowerPoint files use a theme (palette and font pairing), draw charts from ```chart blocks, embed images from the folder, and slides use the Design layouts with absolutely positioned extras.
  • Permissions: ask before changes, auto-accept edits, or plan only. Approvals appear inline with the file content, a diff or the command.
  • Tools cannot reach outside the folder (junctions and links included); commands and unknown web pages always ask first.
  • A task view with steps, thinking, files created or changed, and sources. Tasks keep running in the background and notify you when they finish or need you.
  • Works with native tool calling (llama.cpp, Ollama, LM Studio, OpenAI-compatible servers) and falls back to a text protocol for other models; long tasks are summarized to fit the context window.
• Code: a coding agent for your repositories.
  • Each session works on its own cellar/… branch in a git worktree (or in the checkout or a plain folder), grouped by repository in the sidebar.
  • Modes: Ask, Plan, Code with approvals, or Code with auto-accepted edits (Shift+Tab cycles them).
  • Side panel: Changes (Monaco diff, discard, commit, merge into the base branch), Files (tree + Monaco editor), Preview (localhost dev servers and HTML files) and Terminal (PowerShell via node-pty).
  • Transcript views (normal, verbose, summary), live command output, a side chat that stays out of the session, and CELLAR.md project memory (/init, /memory).
  • Diagnostics: syntax problems in a file the agent just changed come back with the tool result (Python, JavaScript, TypeScript, JSON, PowerShell), and get_diagnostics runs tsc, pyright/ruff, cargo check or go vet.
• Computer use (Windows, off by default): the model sees your screen and works the mouse and keyboard in your own apps, in Chat, Cowork and Code.
  • Built for small local models: Cellar finds the buttons, fields and links with Windows UI Automation and numbers them on each screenshot, so the model says "click 12" instead of guessing pixels; models without vision work from the numbered list, the text on screen and the keyboard.
  • Every step comes back with a fresh look at the screen. Tools: look (and zoom), click, type, keys, scroll, drag, hover, open an app by name (Turkish and other localized Start-menu names too), windows, read the text in a window, and hand the mouse to you.
  • Safety: the first step asks once for the task; anything that sends, buys, deletes, publishes or closes a window asks every time. It never types into a password field (sign-ins are handed to you), never touches Cellar's own windows or apps you block (password managers by default), and a real mouse movement pauses it. A glow around the screen and a bar at the top show what it is doing, with Stop (or Ctrl+Alt+Esc).
  • Settings → Computer use has a "Take a look" button that shows exactly what the model would see.
• Incognito chats live only in memory and disappear when you leave them.
• Projects: per-project instructions and knowledge files. Files are included whole when they fit, otherwise the best-matching excerpts: SQLite FTS5, fused with embedding search when an embedding model is set (llama.cpp, Ollama or OpenAI-compatible).
• Artifacts: HTML, SVG and React output opens in a sandboxed side panel served from an offline cellar-artifact:// protocol (bundled React, lucide-react, Tailwind). Artifacts keep versions and are collected on the Artifacts page.
• Built-in llama.cpp engine:
  • One llama-server process per loaded model, loaded on demand.
  • Idle unload and least-recently-used eviction.
  • Load progress parsed from the server logs, plus a log viewer.
  • Cellar detects existing builds (PATH/winget, Unsloth Studio) and installs official ggml-org releases matched to your GPU, including CUDA 13 for RTX 50-series cards.
• Load settings like LM Studio:
  • Memory: context length, GPU offload, fit-to-memory margin, KV cache offload.
  • Performance: flash attention, K/V cache quantization, threads, batch sizes, parallel slots, load mode.
  • MoE: experts on the CPU (all, or the first N layers).
  • Model extras: vision projector, reasoning budget, RoPE scaling, speculative draft model, chat template override, extra arguments.
  • Inference: sampling parameters, stop strings, JSON-schema output, and the context overflow policy.
  • A live VRAM/RAM estimate computed from the GGUF header.
• Discover:
  • Hugging Face search with publisher filters (unsloth, ggml-org, bartowski, …).
  • A quant table with Unsloth Dynamic labels and per-quant fit badges, read from remote GGUF headers.
  • Downloads to Cellar (resumable, SHA-256 verified, projector included), to Ollama (hf.co/… pull) or to LM Studio.
• Connections: Ollama (native API, num_ctx/think/keep-alive), LM Studio (REST v1 load/unload/download), Unsloth Studio (API key), custom OpenAI-compatible servers. API keys and the HF token are encrypted with Windows credentials (safeStorage).

Getting started

Requirements: Windows 10/11 x64 and Node 22.12+ (Node 24 recommended).

npm install
npm run dev          # run with hot reload
npm run build:win    # build release/<version>/Cellar-Setup-<version>.exe

On first launch:

1. Engine: open Settings → Engines & runtimes and install the recommended llama.cpp build (CUDA 13 for recent NVIDIA drivers).
2. Models: open Discover to download a GGUF, or start Ollama / LM Studio / Unsloth Studio. Cellar also finds GGUFs in your Hugging Face cache and LM Studio folder.
3. Unsloth Studio: create an API key in Studio → Settings → API and paste it into Settings → Connections.

Where data lives

What	Location
Chats, projects, settings (SQLite)	%APPDATA%\Cellar (override with CELLAR_USER_DATA)
Downloaded models	~/.cellar/models/<publisher>/<repo>/ (configurable)
llama.cpp runtimes	~/.cellar/runtimes/llama.cpp/ (override the home with CELLAR_HOME)
Files from Cowork tasks without a chosen folder	~/.cellar/tasks/<date>-<id>/
Code session worktrees	~/.cellar/worktrees/<repo>-<id>/ (branches cellar/…)
Your notes for every repository	~/.cellar/CELLAR.md
Skills, plugins and slash commands	~/.cellar/skills/, ~/.cellar/plugins/, ~/.cellar/commands/
whisper.cpp builds and voice models	~/.cellar/whisper/
Designs (artboards and themes)	in the SQLite database; each design session also has ~/.cellar/designs/<id>/
Math boards (blocks, figures, tests, sketches)	in the SQLite database; each Math session also has ~/.cellar/boards/<id>/

Development

Script	Purpose
npm test	Unit tests (Vitest): stream parsers, llama.cpp args/log parsing, memory estimator, quant grouping, context fitting, branching, artifacts, downloader resume, SQLite/FTS5, the Cowork agent (path containment, tools, documents, text protocol, compaction, the agent loop), Code (worktrees, modes, changes, terminal, preview, side chat), M4 (skills, plugins, commands, memory, a real MCP server, chat tools, diagnostics, scheduler, embeddings), Design (element normalization, layouts, layout checks, charts, SVG cleaning, PowerPoint export, design sessions through the agent loop, themed documents) and Math (exact arithmetic, the expression parser, solvers, figures, graphs, typesetting, test generation, board blocks and Math sessions through the agent loop)
npm run test:e2e	Playwright end-to-end tests against a deterministic mock OpenAI server, including a scripted tool-calling agent (build first)
npm run typecheck	TypeScript for main/preload and renderer
node scripts/screenshots.mjs "/,/models"	Screenshot routes of the built app
node scripts/chat-smoke.mjs <provider> <model or name=…> "<prompt>"	Real-model chat through the UI
node scripts/cowork-smoke.mjs <provider> <model or name=…> ["<task>"]	Real-model Cowork task in a sample folder, approving each request (SMOKE_MODE=plan for plan mode)
node scripts/code-smoke.mjs <provider> <model or name=…> ["<task>"]	Real-model Code session on a sample git repository, then the Changes, Files, Terminal and Preview tabs (SMOKE_MODE, SMOKE_WORKTREE=0)
node scripts/m4-smoke.mjs <provider> <chat model> [embedding model]	Real-model M4 check: connector and web search in a chat, memory, project embeddings, whisper.cpp install and transcription (SMOKE_SKIP=chat,rag,voice)
node scripts/design-smoke.mjs <provider> <model or name=…> ["<prompt>"]	Real-model Design session: builds a design, edits the selected title in a follow-up, exports PDF, PowerPoint and PNG, and takes screenshots (SMOKE_FORMAT, SMOKE_THEME, SMOKE_FOLLOWUP)
node scripts/math-smoke.mjs <provider> <model or name=…> ["<prompt>"]	Real-model Math session: builds a board, checks the derivations against Cellar's own solvers, answers a test question, exports a PDF and a study sheet, and takes screenshots (SMOKE_FOLLOWUP)
node scripts/study-smoke.mjs [provider] [model]	Real-model Study session on a generated Turkish science chapter with the student's answers already on it: checks them in Tutor mode, answers from the whole book, fills in a blank in Solve mode, exports the PDF with the notes, and prints every annotation it placed
node scripts/computer-smoke.mjs [provider] [model] ["<prompt>"]	Real-model computer use in a throwaway profile: by default opens Calculator, works out 1234 × 5678 and reads the result. It drives the real mouse and keyboard, so keep your hands off; SMOKE_CLOSE lists executables to close afterwards (default CalculatorApp.exe)
node scripts/verify-downloads.mjs [repo]	Hub download, pause/resume, checksum, rescan and Ollama pull
node scripts/ipc-run.mjs '[["runtimes:list", true]]'	Call backend IPC handlers directly
node scripts/verify-packaged.mjs	Smoke-test the packaged build

Architecture

src/main        Electron main process
  agent/        Cowork: agent loop, tools, folder containment, documents, text tool protocol, compaction
  code/         Code: sessions and worktrees, prompt, changes (git/snapshots), terminal (node-pty), preview scheme, side chat, diagnostics
  customize/    skills, plugins, slash commands, memory, tool listing
  connectors/   MCP servers (SDK client manager, encrypted settings)
  scheduled/    cron schedules and the scheduler
  voice/        whisper.cpp install and transcription
  rag/          embedding index and hybrid project search
  app/          notification-area icon, background mode, quick entry
  design/       Design sessions: store, model tools and prompt, PowerPoint exporter, PNG/PDF rendering
  math/         Math sessions: board store, model tools and prompt, PDF/PNG/Markdown export
  providers/    llama.cpp engine, Ollama, LM Studio, OpenAI-compatible (Unsloth, custom), registry
  runtimes/     llama.cpp build detection and installation
  models/       local GGUF index, header summaries, memory estimator, presets
  hub/          Hugging Face API, quant grouping, download manager
  chat/         orchestrator, context fitting, prompts, attachments
  services/     settings, projects, artifacts, model operations
  db/           node:sqlite schema, migrations, chat stores (SQLite + in-memory incognito)
  protocol/     sandboxed cellar-artifact:// protocol
src/preload     typed, allow-listed IPC bridge
src/shared      IPC contract, types, message tree, artifact parser
  design/       design model shared by main and renderer: themes, layouts, charts, HTML rendering, layout checks
  math/         maths engine shared by main and renderer: exact arithmetic, parser, solvers, figures, graphs, typesetting, tests
src/renderer    React 19 + Tailwind 4 UI (TanStack Router/Query, Radix, streamdown)
src/artifact-runtime  offline React runtime for artifacts