DEV Community

Cover image for A 1.5MB Local LLM Manager That Turns llama.cpp Into a Complete Desktop AI Workstation
Oshine Li
Oshine Li

Posted on

A 1.5MB Local LLM Manager That Turns llama.cpp Into a Complete Desktop AI Workstation

#ai #opensource #software #llm

Open Source | Ooor: A 1.5MB Local LLM Manager That Turns llama.cpp Into a Complete Desktop AI Workstation

TL;DR: Ooor is a MIT-licensed, open-source Windows desktop app weighing just 1.5MB. It integrates llama.cpp engine management, a GGUF model library, a Hugging Face model marketplace, a resumable chunked downloader, a streaming chat console, and an Agent tool-calling layer. No Electron. No cloud services. No telemetry. No accounts. Pure local. Double-click and go.

I. Why Another Local LLM Tool?

Let's be honest — running LLMs locally in 2026 isn't novel anymore. But have you ever experienced this:

  • You want to use llama.cpp directly, but every time you have to scroll through llama-server --help to find the right flags, type out a long command line, and restart everything just to change the GPU layer count
  • You use Ollama, but model search is limited, and finding a specific quantized GGUF file means digging through HuggingFace manually
  • You use LM Studio, but the installer is 500MB+, Electron eats 800MB of RAM, and you keep getting popups nudging you to log in
  • You downloaded a model and want to connect it to Cursor / Continue, only to realize you have to manually construct an OpenAI-compatible API endpoint URL

If any of that resonates, Ooor (pronounced "O-or") is worth five minutes of your time.

GitHub: https://github.com/rhettli/Ooor-desktop
Website: https://ooor.cc
License: MIT
Author: oshine

II. What Is Ooor?

Ooor is a native Windows desktop application that wraps the llama.cpp command-line ecosystem into a "click-and-run" workstation. It's not an Electron app, not WPF, not MAUI — it's plain WinForms + .NET Framework 4.8, compiling to a 1.5MB binary that launches instantly and idles in single-digit megabytes of RAM.

Specifically, Ooor packs four roles into a single sub-1.5MB executable:

Role Description
Llama Engine Manager Discover, install, and switch between llama-server builds (CPU / CUDA / Vulkan / SYCL)
Model Library Manager Scans disk for all .gguf files, manages multimodal projection files, supports soft-delete
Downloader Chunked resumable downloads, HuggingFace mirror support, GitHub proxy acceleration
Chat Console & Agent Host Streaming chat, tool calling (read/write files, shell, web fetch), MCP protocol support

III. Core Features In Detail

1. Radically Lightweight: 1.5MB Complete Toolkit

Tool Installer Size Runtime Dependency Idle Memory
Ollama ~150MB Bundled runtime ~50MB
LM Studio ~500MB+ Electron + Chromium ~800MB
Ooor ~1.5MB .NET Framework 4.8 (built into Win10) single-digit MB

No Electron. No Node runtime. No 200MB framework download. A hand-written WinForms binary that talks directly to llama-server.exe via local HTTP API.

2. Privacy First: 127.0.0.1 Is Your Boundary

  • Model service binds to 127.0.0.1
  • No telemetry, no "anonymous usage statistics," no account system
  • Your prompts, your files, your conversation history — all stay on your machine
  • The only outbound traffic is when you explicitly instruct an Agent to fetch a URL

3. One-Click Launch + OpenAI-Compatible API

Select engine → Select model → Click Start Service → Get an OpenAI-compatible HTTP endpoint running at 127.0.0.1:6080.

Connect directly to:

  • Cursor: Settings → Models → Override OpenAI Base URL
  • Continue (VS Code extension): Configure apiBase
  • Cherry Studio: Add a custom OpenAI-compatible provider
  • Any tool that supports the OpenAI /v1/chat/completions format

4. Independent Engine Version Management

llama.cpp iterates rapidly. Ooor's approach: decouple the engine from the GUI.

  • One-click download of official llama.cpp releases (CPU / CUDA / Vulkan / SYCL)
  • Auto-extracts llama-b*-bin-win-*.zip to config\llama-bin\
  • Multiple versions coexist; one-click switching
  • Upgrading the engine doesn't require upgrading Ooor, and vice versa

5. Local Model Library Management

The Model Manager is a spreadsheet-like GGUF file management interface:

Column Description
Model Name Filename
Projection File Multimodal (vision) model's mmproj-*.gguf projection file
Folder Disk location
Type Built-in (internal directory) or External (referenced directory)
Size Disk usage
Note Free-form annotation (e.g., "good at code", "fast inference")
D Soft-delete marker

Right-click menu: edit notes, locate file, hard-delete / soft-delete, add external model folders.

Soft-delete is particularly useful: removes from the list but keeps the disk file, so you can switch back and forth during experiments without re-downloading 7GB.

6. Built-In Hugging Face Model Marketplace

Not just a search box — a full HF browser:

  • Supports hf-mirror mirror source (friendly for users in regions with restricted access)
  • Sortable table: downloads, likes, task category, Gated flag, last updated
  • Click a repo to view all GGUF files, each quantization variant annotated with estimated hardware requirements (e.g., "16 GB GPU", "high-end GPU + large RAM")
  • Right-click to open the HF model page in your browser

7. A Real Download Manager

Not a progress bar — a real download manager:

  • Multi-chunk parallel downloads
  • Independent status indicator per chunk
  • Automatic retry
  • Resumable: close the app, reopen, click Start, and it continues from where it left off
  • GitHub proxy mirror list (extremely friendly for users behind the GFW)
  • Auto-detects llama-b*-bin-win-*.zip and extracts to the engine directory

Status bar summary: task count, active count, current speed, total bytes.

8. Streaming Chat Console

Built-in chat interface with streaming output. Each response includes:

  • Token sparkline (a mini chart of tokens-per-second)
  • Chunk timing visualization

This means you can visually compare inference speed across engine versions or quantization levels without running a separate benchmark.

9. Agent Tool-Calling Layer (Key Feature!)

This is Ooor's most interesting capability — it's not just a chat box, it's a local Agent host.

Built-in tool set:

Tool Function Safety Mechanism
Fetch URL HTTP GET to fetch a web page, returns cleaned text/Markdown Auto-uses GitHub proxy
Read File Reads text files within allowed root directories Path restriction
Write File Writes text to allowed root directories Requires manual confirmation
List Directory Lists directory contents Path restriction
Shell Executes shell commands Requires manual confirmation, streaming output
Memory Key-value store across conversation turns —

Workflow:

  1. Define an Agent in Agent Manager (system prompt + bound tools + optional MCP server)
  2. The model autonomously decides whether to call a tool during the conversation
  3. The console displays the tool call content
  4. Destructive operations (write file, shell) must be manually confirmed before execution

MCP Protocol Support: You can bind Model Context Protocol servers that enjoy the same status as built-in tools. The repository includes a sample MCP server ooor-sqlite-mcp.

What does this mean? Your local model can: fetch web content → read local files → analyze → write results to a file. A fully offline local research assistant.

10. Profile Configuration System

A Profile = engine + model + runtime parameters + Agent binding, as a complete snapshot.

Typical usage:

  • Profile A: Qwen2.5-Coder-1.5B + CPU engine → quick Q&A
  • Profile B: DeepSeek-Coder-33B-Q4 + CUDA engine + Agent tools → deep code refactoring

One-click switching. No need to reconfigure each time.

11. Multilingual UI

Supports English and Simplified Chinese, switchable at runtime.

IV. Architecture & Source Structure

Tech Stack

Layer Technology
Client C# + WinForms (.NET Framework 4.8)
Inference backend llama.cpp (official Release builds)
Chat frontend Embedded HTML (Vue.js)
Gateway (optional) Go (chi router / SQLite / singleflight)

Project Structure 

csharp-desktop-app/
├── OOOR/                       # Desktop app main project
│   ├── Core/                   # Domain logic: engine runtime, model storage, Agent, tools
│   ├── Controls/               # Custom WinForms controls (sparkline, etc.)
│   ├── Properties/             # AssemblyInfo, Resources
│   ├── html/                   # Embedded web assets for chat console (index.html, vue.js)
│   ├── Lang/                   # i18n strings (en.json, zh.json)
│   ├── Ooor.csproj
│   └── Program.cs
├── Ooor-cli/                   # Optional CLI frontend
├── OoorFunc/                   # Shared Agent/tool function library
├── ooor-sqlite-mcp/            # Sample SQLite MCP server
├── doc/img/                    # README screenshots
└── Ooor.slnx                   # Solution file
Enter fullscreen mode Exit fullscreen mode

Data Directory Structure

All user data is centralized under one config tree, making backup and migration straightforward:

Path Purpose
<install_dir>\bin\Ooor.exe Application executable
<install_dir>\config\llama-bin\ Extracted llama-server builds
<install_dir>\config\models\ Built-in model folder (auto-scanned)
<install_dir>\config\github-proxy.txt GitHub acceleration mirror list
<install_dir>\config\ref_models.conf External model folder references (e.g., LM Studio library)
<install_dir>\config\ (chat/temp/remark) Chat logs, temp files, annotations

Default install directory: D:\Ooor if drive D exists, otherwise %LOCALAPPDATA%\Ooor.

V. Five-Minute Quick Start

Step 1: Install

Download Ooor-Setup-x64-v*.exe from ooor.cc and run the installer. On first launch, Windows may show an "unknown publisher" warning — this is because the app currently uses a self-signed certificate (a commercial code signing certificate is on the Roadmap). Click Run anyway.

No admin privileges required for daily use (the installer requests admin only for writing to the install directory). No reboot. No runtime installation.

Step 2: Get the Llama Engine

Open Llama → Downloads and choose based on your hardware:

  • llama-bXXXX-bin-win-cpu-x64.zip → CPU inference
  • llama-bXXXX-bin-win-cuda-x64.zip → NVIDIA GPU
  • llama-bXXXX-bin-win-vulkan-x64.zip → Generic GPU (best cross-vendor compatibility)

After download, it auto-extracts to config\llama-bin\ and auto-selects.

Step 3: Download a Model

Open Models → Download Models, search for a small model to start with, e.g., Qwen2.5-Coder-1.5B-Instruct-Q4_K_M, and click Download.

Step 4: Start the Service

Return to the main window — the engine and model are auto-selected. Click Start Service. The console log shows llama-server starting up, and the status bar displays llama-server detected.

Step 5: Start Chatting

Click Open Console AI Assistant, type a message, and the model streams back a response.

Step 6: Enable Agent Mode (Advanced)

Open Agent Manager, bind a few tools (e.g., Fetch URL, Read File), and save as a Profile. Then give the model a task that requires tools, for example:

"Fetch the README from https://github.com/rhettli/Ooor-desktop and summarize it"

The model will autonomously call the Fetch URL tool, retrieve the content, and return a summary.

VI. Building From Source

If you want to compile or contribute:

Prerequisites:

  • Windows + Visual Studio 2022 (or Build Tools) with the .NET desktop workload
  • NSIS 3.x in %PATH% (for packaging the installer)
  • Optional: signtool (Windows SDK) for code signing

Steps:

git clone https://github.com/rhettli/Ooor-desktop.git
cd Ooor-desktop
Enter fullscreen mode Exit fullscreen mode

The build is driven by a Node script:

node ooor-utils/desktop-app/build-all.js
Enter fullscreen mode Exit fullscreen mode

The script automatically:

  1. Reads the version number from Core/DEF.cs and auto-increments by 0.0001
  2. Syncs the version to AssemblyInfo.cs and installer.nsi
  3. Cleans bin/Release/ and runs MSBuild (Release configuration)
  4. Copies github-proxy.txt to the config directory
  5. Signs with signtool (auto-generates a self-signed cert if no .pfx is provided)
  6. Runs makensis to generate the installer
  7. Signs the installer

One-click publish (build + upload + version manifest + update check):

node ooor-utils/desktop-app/publish.js build_and_upload --notes "your release notes"
Enter fullscreen mode Exit fullscreen mode

VII. Comparison With Mainstream Tools

Feature Ollama LM Studio Ooor
Installer size ~150MB ~500MB+ ~1.5MB
Open source license MIT Closed MIT
UI framework CLI + basic GUI Electron WinForms (native)
Idle memory ~50MB ~800MB single-digit MB
Login required No Nudges login No
Telemetry None Unclear None
Inference engine Custom (based on llama.cpp) Bundled llama.cpp Uses llama.cpp official builds directly
Engine version management Tied to app version Tied to app version Independent, multi-version coexistence
Model format Ollama's own format GGUF GGUF (native)
Model search Official library (limited) Built-in HF search Built-in HF search + mirror acceleration + hardware requirement annotations
Download acceleration None None hf-mirror + GitHub proxy + NVMe cache
Resumable downloads No Yes Yes (chunk-level)
Built-in chat Yes Yes Yes (streaming + token sparkline)
Agent tool calling No No Yes (6 built-in tools + MCP support)
Profile system No No Yes
OpenAI-compatible API ✅ ✅ ✅
Multilingual UI Partial Partial EN/CN, runtime switch
Cross-platform Win/Mac/Linux Win/Mac/Linux Windows only
Security Reported unauthorized access risk Closed, opaque Pure local 127.0.0.1, no remote access

VIII. Use Cases & Limitations

✅ Use Cases

  • Individual developers: Run models locally for coding, token freedom, connect to Cursor / Continue
  • Privacy-sensitive scenarios: Enterprise intranets, sensitive code, confidential documents — never go to the cloud
  • Offline environments: Business trips, air-gapped networks, no-internet scenarios — always works
  • Poor network conditions: hf-mirror + GitHub proxy + chunked resumable downloads — triple acceleration
  • Users who don't want to mess with CLI: GUI + preset parameters + Profile one-click switching
  • Agent experimenters: Built-in tool calling + MCP support — set up local Agent workflows

⚠️ Limitations

  1. Windows only: Mac / Linux users are out of luck for now (the author states no short-term plans to port, since the GUI is WinForms)
  2. Self-signed certificate: First launch requires manually bypassing the Windows SmartScreen warning
  3. Gated repos can't be downloaded: Due to HuggingFace licensing restrictions, models requiring authorization (e.g., Meta's official Llama) are grayed out — use community GGUF releases instead
  4. No Web UI: The chat interface is embedded in the desktop app and can't be accessed via a browser (Remote mode is on the Roadmap)

IX. Roadmap

Completed ✅

  • [x] Llama engine manager
  • [x] Local model library
  • [x] Hugging Face marketplace browser
  • [x] Resumable download manager
  • [x] Streaming chat console
  • [x] Built-in tool catalog + Agent host
  • [x] MCP server binding

In Progress 🚧

  • [ ] Commercial code signing certificate
  • [ ] Cross-engine support (beyond llama.cpp)
  • [ ] RAG / local knowledge base
  • [ ] Plugin SDK (custom tools)
  • [ ] Remote (non-localhost) mode + authentication

X. Final Thoughts

I've browsed through many local LLM tool projects on GitHub. Most are either Electron GUI shells over CLI tools, or feature-stuffed but rough-around-the-edges half-finished products.

Ooor feels different. It has a quality of deliberate subtraction:

  • No Electron → WinForms, 1.5MB is enough
  • No cloud → bound to 127.0.0.1, data never leaves
  • Not trying to do everything → only engine management + model management + downloads + chat + Agent
  • Not exposing all parameters → sensible defaults, advanced options hidden behind a "More" button
  • Not building a general-purpose Agent framework → 6 practical built-in tools + MCP extension

But it also adds in the right places:

  • The Agent tool-calling layer makes local models more than just "Q&A machines"
  • MCP support allows integration into a broader tool ecosystem
  • The Profile system makes multi-scenario switching elegant
  • Token sparkline makes inference performance visible

If you're on Windows and looking for a lightweight, open-source, purely local, Agent-capable LLM management tool, Ooor is the best option I've found so far.

Project: https://github.com/rhettli/Ooor-desktop
Website: https://ooor.cc
License: MIT
Author: oshine

This article is based on the Ooor official website and the GitHub repository README. If you spot any inaccuracies, please let me know in the comments.

Tags: #LocalLLM #llama.cpp #GGUF #Ooor #OpenSource #MIT #OpenAI-compatible #Agent #MCP #Windows #AITools #TokenFreedom #WinForms

Top comments (0)