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

Oshine Li — Thu, 24 Sep 2026 03:41:55 +0000

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:

Define an Agent in Agent Manager (system prompt + bound tools + optional MCP server)
The model autonomously decides whether to call a tool during the conversation
The console displays the tool call content
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

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

The build is driven by a Node script:

node ooor-utils/desktop-app/build-all.js

The script automatically:

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

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

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)
Self-signed certificate: First launch requires manually bypassing the Windows SmartScreen warning
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
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

DEV Community: Oshine Li