TL;DR: Kivarro is a Rust/Tauri desktop workbench that wraps llama.cpp and mistral.rs with live hardware telemetry, repeatable benchmarks, and an OpenAI-compatible local API. It is promising but very early alpha — and despite how it gets described, it is not open source: the license is PolyForm Noncommercial 1.0.0. Hobbyists can try it; anyone with commercial use in mind should look elsewhere.

	Kivarro (alpha)	LM Studio	Open WebUI
Best for	Tinkerers who want telemetry + benchmarks in one native app	Polished desktop UX, Mac MLX	Multi-user self-hosted chat + RAG
License	PolyForm Noncommercial 1.0.0 (source-available, no commercial use)	Proprietary freeware (MIT CLI)	BSD-3 with branding clause
The catch	Alpha, unsigned builds, tiny community, non-commercial only	Engine is closed source	Needs a browser + server, no hardware profiler

Honest take: Kivarro is an interesting instrument panel for llama.cpp that one developer is building in public — worth a weekend test drive, but the noncommercial license and alpha status mean LM Studio or Open WebUI remain the sane defaults for daily use.

What Kivarro actually is

Kivarro (github.com/AKMessi/kivarro) is a desktop “workstation for private local model inference.” The developer posted it to r/LocalLLaMA in July 2026 looking for testers, and the pitch stands out in a crowded category: instead of being another chat wrapper, it aims to be instrumentation software — think of what a DAW or an IDE does for its domain, applied to local inference.

The stack is Tauri v2 with a Rust backend and a SvelteKit/TypeScript frontend, so you get a native app rather than an Electron shell. It does not ship its own inference engine. Instead it launches and manages one of two backends you install separately:

• llama.cpp via llama-server, with Kivarro exposing the flags that matter: context length, CPU threads, batch and micro-batch size, GPU layers, tensor split, KV cache precision, mmap/mlock, Flash Attention, and RoPE overrides.
• mistral.rs via mistralrs serve -m <model> --host 127.0.0.1 -p <port> --no-ui.

That design choice is the right one. The engines move fast; a workbench that orchestrates them inherits their progress instead of chasing it. It is the same reason Open WebUI sits on top of Ollama rather than reimplementing inference.

The license: source-available, not open source

This site is FOSS-first, so let’s deal with the headline issue. Kivarro’s repository states it plainly: the project is source-available for non-commercial use under the PolyForm Noncommercial License 1.0.0, and the README itself acknowledges “this is not an OSI open-source license because commercial use is restricted.”

Credit where due — the project is honest about it, which is more than some “open” AI projects manage. But be clear about what it means for you:

• Personal home lab use: fine. Noncommercial covers hobby and personal evaluation.
• Using it at work, or in anything that touches revenue: not permitted without a separate license from the author.
• Forking and shipping a modified version commercially: not permitted.

Compare that with the tools it competes against. LM Studio’s engine is proprietary freeware but explicitly free for work use; Open WebUI is BSD-3 (with a branding clause); Jan.ai is Apache 2.0. If open-source licensing is why you self-host, Kivarro currently fails that test, and we’d treat any future relicensing as the biggest possible upgrade the project could ship. For a refresher on why these distinctions matter, see our open-source LLM license shootout.

Setup: build from source or grab an alpha build

Alpha builds are published unsigned on GitHub Releases as .exe/.msi (Windows x64 and ARM64), .dmg/.app.tar.gz (macOS Intel and Apple Silicon), and .AppImage/.deb/.rpm (Linux x64 and ARM64). Unsigned means Windows SmartScreen and macOS Gatekeeper will complain; you’ll have to explicitly allow the app.

Building from source needs Node.js 20+, stable Rust, and the Tauri v2 system prerequisites:

git clone https://github.com/AKMessi/kivarro
cd kivarro
npm install
npm run tauri dev

You also need at least one backend on your PATH — llama-server from llama.cpp or mistralrs. Because the project is in an active “looking for testers” phase with the API and UI changing quickly, pin to a specific commit hash if you want a reproducible setup.

The views: what works and what’s a draft

Kivarro’s shell is a nav rail with ten views. Based on the project’s own status notes, here’s the honest breakdown.

Working today:

• Model Registry — discovers and imports .gguf, .safetensors, .bin, and .mlx files with metadata parsing. GGUF indexing is implemented, so your existing llama.cpp model folder just shows up.
• Command Center — the chat surface, with streaming completions and runtime state visible while you generate.
• Hardware Fit — CPU/RAM/GPU inventory with load simulation. On NVIDIA cards it reads live utilization and VRAM telemetry from NVIDIA SMI, with OS-level fallbacks on Windows, macOS, and Linux. This is the feature that distinguishes Kivarro: seeing VRAM headroom next to your quant choice, in the same window, before you load the model. If you’d rather do that math by hand, our GGUF quantization guide covers it.
• Expert Tuning + Inference Profiles — sampling and runtime controls saved as named profiles. Four ship seeded: Balanced Engineer, JSON Extractor, Code Reviewer, and Long Context Analyst.
• Benchmarks — runs against the loaded model with sampling normalized for repeatable tokens/sec numbers, reporting backend, generated tokens, duration, throughput, and model load time. Getting consistent before/after numbers when you change GPU layers or KV cache precision usually means fiddling with llama-bench in a terminal; having it built in is genuinely useful.
• Local API — an OpenAI-compatible endpoint at http://127.0.0.1:8080/v1, deliberately restricted to loopback addresses. That’s a sound security default given how many exposed local-AI instances end up on Shodan (see our Ollama security guide). It also means you can point Continue.dev or Cline at Kivarro like any other OpenAI-compatible server — our sister site aicoderscope.com covers wiring local endpoints into coding tools.

Early-stage, by the project’s own admission:

• RAG Knowledge Bases — you can create knowledge bases from local .txt, .md, and source files, inspect the generated ~1,200-character chunks, and run retrieval test queries with ranked scores. But it is “a workbench, not automatic prompt injection” — retrieved chunks don’t yet flow into chat automatically. AnythingLLM or Open WebUI remain far ahead here.
• Agents — “a draft control-plane UI, not a full autonomous agent runner.” Treat it as a preview of intent, not a feature.

Hardware reality check

Kivarro adds no inference overhead of its own — performance is whatever llama.cpp or mistral.rs deliver on your silicon. The Hardware Fit view is most valuable on cards where quant choice is genuinely tight: on a 24GB RTX 3090 the interesting question is which 30B-class quant fits alongside your context window, while on a 16GB RTX 4060 Ti it’s whether a 13B Q5 beats a 20B Q3. A tool that simulates the load before you wait through it is solving a real problem. For picking the card in the first place, runaihome.com’s GPU buying guides for local AI are the deeper resource. And if your experiments outgrow your desktop, renting a pod on RunPod is the cheaper way to test big quants before buying hardware.

Kivarro vs LM Studio vs Open WebUI

Against LM Studio: LM Studio wins on polish, Mac MLX performance, and years of maturity — and since 0.4 it also runs headless. Kivarro wins on transparency: the source is readable, the runtime state is visible, and the benchmark tooling is better than LM Studio’s perf tab. Neither is OSI open source.

Against Open WebUI: different animals. Open WebUI is a multi-user web server with mature RAG; Kivarro is a single-user native instrument panel. If you want family members or teammates chatting with your models, Open WebUI. If you want to understand what your GPU is doing, Kivarro.

When NOT to use Kivarro

• Any commercial context. The license forbids it, full stop.
• You want stable daily-driver software. Alpha, unsigned builds, single-digit GitHub stars, roughly forty commits, and one developer. Expect breakage and no guarantees the project exists in a year.
• RAG or agents are your use case. Both are explicitly drafts here.
• Mac-first performance. mistral.rs helps, but LM Studio’s MLX engine is the benchmark on Apple Silicon.

Verdict

Kivarro is what an experienced developer’s itch-scratching project looks like in public: opinionated, technically sound, honest about its gaps. The hardware-telemetry-plus-benchmarks combination fills a real hole between terminal tools and consumer chat apps. But a PolyForm Noncommercial license on a 7-star alpha means it’s a project to watch and test, not one to adopt. If the author ever relicenses under Apache or MIT, this becomes one of the more interesting entries in the category overnight.

FAQ

Is Kivarro open source? No. It is source-available under PolyForm Noncommercial 1.0.0, which forbids commercial use. The code is public on GitHub and free for personal use, but it does not meet the OSI definition of open source, and the README says so directly.

Does Kivarro replace llama.cpp or Ollama? No — it requires a separate engine. Kivarro launches and manages llama-server (llama.cpp) or mistralrs serve, adding a management UI, telemetry, profiles, and benchmarks on top. It does not currently drive Ollama.

Can other machines on my network use Kivarro’s API? Not out of the box. The OpenAI-compatible endpoint at 127.0.0.1:8080/v1 intentionally binds only to loopback addresses. That’s a deliberate security decision; you’d need your own reverse proxy to expose it, and you should think hard before doing so.

Sources

• Kivarro GitHub repository — license statement, feature status, build instructions
• PolyForm Noncommercial License 1.0.0 — full license text
• llama.cpp llama-server docs — the primary backend Kivarro manages
• mistral.rs — the second supported backend
• Open Source Initiative: The Open Source Definition — why noncommercial restrictions disqualify a license

Recommended Gear

• RTX 3090 — 24GB VRAM, still the used-market sweet spot for 30B-class local models
• RTX 4060 Ti 16GB — budget 16GB option where Hardware Fit’s quant math earns its keep

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe