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

> Source: <https://dev.to/oshine/a-15mb-local-llm-manager-that-turns-llamacpp-into-a-complete-desktop-ai-workstation-9a>
> Published: 2026-09-24 03:41:55+00:00

**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.

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

`llama-server --help` to find the right flags, type out a long command line, and restart everything just to change the GPU layer count
If any of that resonates, **Ooor** (pronounced "O-or") is worth five minutes of your time.

**GitHub**: [https://github.com/rhettli/Ooor-desktop](https://github.com/rhettli/Ooor-desktop)

**Website**: [https://ooor.cc](https://ooor.cc)

**License**: MIT

**Author**: oshine

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 | 

| 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.

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

Connect directly to:

`apiBase`
`/v1/chat/completions` format
llama.cpp iterates rapidly. Ooor's approach: **decouple the engine from the GUI**.

`llama-b*-bin-win-*.zip` to `config\llama-bin\`
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.

Not just a search box — a full HF browser:

`hf-mirror` mirror source (friendly for users in regions with restricted access)
Not a progress bar — a **real download manager**:

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

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

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

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:

**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.**

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

Typical usage:

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

Supports English and Simplified Chinese, switchable at runtime.

| 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) | 

```
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
```

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`.

Download `Ooor-Setup-x64-v*.exe` from [ooor.cc](https://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.

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.

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**.

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`.

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

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](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.

If you want to compile or contribute:

**Prerequisites**:

`%PATH%` (for packaging the installer)
**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:

`Core/DEF.cs` and auto-increments by `0.0001`
`AssemblyInfo.cs` and `installer.nsi`
`bin/Release/` and runs MSBuild (Release configuration)`github-proxy.txt` to the config directory
**One-click publish** (build + upload + version manifest + update check):

```
node ooor-utils/desktop-app/publish.js build_and_upload --notes "your release notes"
```

| 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** | 

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**:

But it also adds in the right places:

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](https://github.com/rhettli/Ooor-desktop)

**Website**: [https://ooor.cc](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`