🐪 Camelid

Local AI, powered by Rust.

Chat, work with files, and code with supported GGUF models on your own hardware. Use the desktop app, a desktop or mobile browser, the terminal, or an OpenAI-compatible API.

Download · Quick start · Features · Screenshots · Models · Documentation

_{The current Camelid UI with illustrative demo conversations. Screenshots show interface features, not model-quality or performance results.}

Why Camelid?

• Private local inference. Run language, vision, and embedding models on your own hardware, offline after downloading the model files.
• One Rust engine. The engine and web UI ship as a single binary, with no Python, Node.js, or Docker required at runtime.
• Hardware acceleration. Use Metal on Apple Silicon, CUDA on supported NVIDIA paths, or CPU fallback on Windows, macOS, and Linux.
• Tested compatibility. Supported model files and quantizations are validated against a pinned llama.cpp reference, with explicit limits for each tested configuration.

Features

Feature	What you can do
Everyday chat	Stream replies with Markdown, code highlighting, math, and diagrams. Edit and resend, regenerate replies, continue unfinished answers, and pin, tag, archive, or export conversations.
Projects and context	Group chats with shared instructions and reference files. Choose what each conversation inherits and inspect the sources included in the next request. Guide · Screenshot
Files and previews	Browse generated files beside the conversation, switch between Preview and Source, and download outputs. On the local engine, review a proposed file change before applying it, with conflict checks and Undo. Guide
Code in Chat	Work in a local project with a live plan, read-only helper agents, file reviews, individually approved commands, checks, and project previews, including a managed local preview server for Chrome. Pause, steer, queue a follow-up, or return to a saved session. Guide
Web and connected tools	Use Web Auto for web research with reply sources. Connect local or remote MCP servers, choose tools per conversation, and approve each tool call. MCP is a preview feature. MCP guide
Mobile browser chat	Chat from your phone with a compact model selector, project context, and file previews. Inference stays on your computer; browser history and context stay separate on each device. Remote setup
Models and developer tools	Browse the model catalog, inspect local GGUF metadata, check compatibility evidence, explore API examples, and inspect request telemetry. Model and tool availability follow the active engine's capabilities.

Local chat works offline once model files are downloaded. Web research and remote MCP services need network access; Code requires an exact certified tool-capable model and a local engine connection.

Quick start

Model downloads are typically 1–8 GB. For the simplest setup, install the desktop app and download a model from its Models page.

Desktop app

Windows 10 or 11 (x86_64):

irm https://raw.githubusercontent.com/timtoole02/Camelid/main/scripts/get-desktop-windows.ps1 | iex

This installs the signed app per user and bundles the CUDA runtime. A compatible NVIDIA driver is still required for CUDA; otherwise Camelid uses the CPU.

macOS 12 or newer (Apple Silicon):

curl -fsSL https://raw.githubusercontent.com/timtoole02/Camelid/main/scripts/get-desktop-macos.sh | bash

This installs Camelid Desktop in /Applications. Run the same command again to update without removing models or settings.

Portable downloads and engine archives for Windows, macOS, and Linux are available from the latest release. See the desktop documentation for manual installation and packaging details.

Command line

After downloading and unpacking an engine archive, start a browser chat with:

camelid pull 3b_instruct_q8
camelid serve --model models/Llama-3.2-3B-Instruct-Q8_0.gguf

Camelid opens http://127.0.0.1:8181. Use camelid chat for the terminal UI, or add --no-open to run the server without opening a browser.

Run camelid pull without an argument to list the curated model catalog.

Note

To chat from another device, see the remote browser chat guide. Non-loopback listeners require authentication and either TLS or an explicit cleartext acknowledgement.

Screenshots

Desktop

Preview and download generated files without leaving the conversation. Code adds project activity, helper assignments, and explicit file reviews.

Conversation files	Code and agent activity

Projects: shared instructions and reference files

Mobile

The responsive browser UI keeps chat, project context, and downloadable file previews close at hand. These captures show the restricted remote-chat surface; local coding and engine administration are not exposed there.

Chat	File preview	Conversation context

Use a trusted private LAN or private Tailscale HTTPS access with authentication. See remote browser chat for setup. Screenshots were captured from the current frontend with isolated demo data; capture details and reproduction commands are included.

Supported models

Start with one of these five options. Support applies to exact model files, quantizations, and tested execution paths; see the compatibility ledger for each model's limits.

Best for	Model	Pull ID
First chat	Llama 3.2 3B Instruct Q8_0	3b_instruct_q8
Small end-to-end test (~1.2 GB)	TinyLlama 1.1B Chat Q8_0	tinyllama
Compact Windows CPU or tested M4 Metal chat (~2.9 GB)	LFM2.5 2.6B Q8_0	lfm2_5_2_6b
Local embeddings (CPU)	Nomic Embed Text v1.5 Q8_0	nomic
Chat on a 16 GB Apple Silicon Mac	Mistral 7B Instruct v0.3 Q8_0	mistral

Llama 3.2 3B and LFM2.5 have support limited to the documented exact-file smoke tests; broader context, hardware, and behavior do not inherit that support.

Browse the full catalog and validation details, including coding, vision, and experimental models. Gemma 4 12B-It QAT Q4_0 is available for a tested 16 GB M4 Mac, with validation pending. Download availability does not imply verified support.

For image chat and embeddings and reranking, see the model guide for supported files and setup.

For voice input, use the microphone beside Send. A one-time 154 MB English speech-model download enables local Rust transcription into an editable prompt.

Ways to use Camelid

Interface	Start it with	Best for
Desktop app	Install from Quick start	Native app with bundled engine
Browser chat	camelid serve --model <gguf>	Everyday local chat
Phone or tablet	Open the authenticated remote chat URL	Browser chat with inference on your computer
Terminal UI	camelid chat	Shell and SSH workflows
HTTP API	Start camelid serve	Chat, image input, embeddings, and reranking
Code in Chat	Choose Code in the local web UI	Reviewed edits, approved commands, and a live agent sidebar
Agent mode	camelid chat --agent --model <gguf>	Approval-gated tools in a repository
Workspace (preview)	Open Workspace in the web UI	Read-only analysis of a local folder

The Code guide covers project folders, approvals, helper agents, checks, previews, saved workflows, follow-ups, and Undo. Code requires an exact certified tool-capable artifact and a loopback engine connection.

Agent mode confines file tools to a workspace root and keeps network access off unless enabled. Workspace is read-only and resumable. Both require a model marked tool_capable in the compatibility ledger. Review the agent documentation and every requested action before enabling additional tools or network access.

OpenAI-compatible API

camelid serve exposes the browser UI and API on the same port. Read the loaded model ID from GET /v1/models, then call the chat-completions endpoint:

curl http://127.0.0.1:8181/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Llama 3.2 3B Instruct",
    "messages": [{"role": "user", "content": "Why is local inference useful?"}],
    "max_tokens": 128,
    "temperature": 0
  }'

Camelid also supports /v1/responses, /v1/embeddings, /v1/rerank, streaming, local image input on supported VLM rows, function tools, structured text formats, conversations, and optional local SQLite storage. The machine-readable route and feature inventory is available from /api/capabilities.

Platform support

Platform	Distribution	Acceleration
Windows x86_64	Desktop installer, portable app, engine archive	Supported CUDA exact-row paths; CPU fallback
macOS Apple Silicon	Desktop DMG or engine archive	Metal and CPU
Linux x86_64	Engine archive	CUDA compiled in; CPU fallback

Hardware support is row- and configuration-specific. Consult COMPATIBILITY.md before relying on a particular GPU, model, or quantization combination.

Build from source

Camelid uses the toolchain pinned in rust-toolchain.toml. The React/Vite web UI in frontend/ is embedded in the engine binary.

(cd frontend && npm ci && npm run build)
cargo build --release --locked --bin camelid

See the contributor quick start for prerequisites and development setup.

Documentation

• Documentation index
• Model catalog and validation
• Remote browser chat
• Projects and conversation context
• Output previews and file review
• Code in Chat
• Connected tools (MCP preview)
• Configuration reference
• CUDA continuous batching and model residency
• Architecture
• Validation matrix
• Roadmap

Contributing

Contributions are welcome. Start with CONTRIBUTING.md, SECURITY.md, and the contributor quick start.

License

Camelid is released under the MIT License. llama.cpp (MIT, © the ggml authors) serves as the reference oracle for supported rows; see THIRD_PARTY_NOTICES.md for attribution.