# OpenYoke – Branch AI conversations into a graph, with local or cloud models

> Source: <https://github.com/saicv8/OpenYoke>
> Published: 2026-07-14 14:07:41+00:00

### A private, local-first desktop app for chatting with open-source AI models — with branching conversations you explore as a visual graph.

OpenYoke is an open-source **Ollama desktop GUI** and **private ChatGPT alternative** that runs entirely on your machine. No cloud, no accounts, no data leaving your computer. Manage models, chat with streaming responses, and branch any conversation into a tree you can navigate like a canvas.

*Branch a conversation from any point and explore each direction as a graph — every branch keeps its own context.*

Most local-LLM tools give you a plain chat box. OpenYoke gives you a **thinking space**:

- 🌳
**Branching conversations, not a linear log.** Every exchange is a node in a tree. Ask a follow-up, or branch off in a new direction from*any*earlier point — then see the whole shape of your thinking as an interactive, n8n-style graph. - 🧠
**Context stays on the path.** When you branch, the model only sees the messages along that branch — sibling branches never bleed into each other. Explore competing ideas in parallel without cross-contamination. - 🔒
**100% local and private.** Your conversations and model weights live on your machine. Nothing is sent anywhere. Perfect for sensitive work and offline use. - 🖥️
**No terminal required.** Browse a curated model library, download models with a live progress bar, and delete them — all from inside the app. - ⚡
**Fast and lightweight.** A native[Tauri](https://tauri.app)shell with a Rust backend. No Electron bloat, no bundled Chromium.

- 🗂️
**Branching conversation graph**— a free-drag canvas of nodes (each node is one question + answer). Pan, zoom, drag to arrange; branch from any node. - ✍️
**Streaming responses**— tokens render live as the model generates, like the tools you already love. - 📚
**In-app model management**— browse open models (Llama, Qwen, Mistral, Gemma, Phi, DeepSeek, and more), pull them with progress, and remove them to reclaim disk. - 💾
**Your data, your folder**— pick where conversations and settings are saved; everything persists across restarts as plain JSON. - 🎨
**Minimal, Notion-inspired UI**— clean, compact, and out of your way. - 🧩
**Provider-ready architecture**— Ollama today, with a clean seam for embedded or cloud backends next.

A conversation is a **tree**. Each node holds one interaction — your question and the model's answer.

```
            ┌─ "Which frontend framework?" ─┐
"Build a    │                               ├─ "How do I deploy React?"
 web app?" ─┤                               └─ "Compare React vs Svelte"
            └─ "What about the backend?" ──── "Show me an Express example"
```

Ask a follow-up to extend a branch; branch again from any node to explore an alternative. When the model answers at a node, it sees **only the path from the root to that node** — so your alternate branches stay independent. This isolation is enforced in the Rust backend, not just the UI.

[Rust toolchain](https://www.rust-lang.org/tools/install)(stable)[Node.js](https://nodejs.org)(for the Tauri CLI)[Ollama](https://ollama.com)running locally (install below)

Install once; after that you manage models entirely from OpenYoke's **Models** tab.

```
# macOS
brew install ollama                                   # or the .dmg from ollama.com/download

# Windows
winget install Ollama.Ollama                          # or the installer from ollama.com/download

# Linux
curl -fsSL https://ollama.com/install.sh | sh
```

Make sure it's running (`ollama serve`

) — it listens on `http://127.0.0.1:11434`

, the address OpenYoke connects to by default. You do **not** need to pull models from the terminal; do it from the Models tab.

```
npm install
npx tauri dev
npx tauri build
cd src-tauri
cargo test
```

On first launch OpenYoke asks you to choose a **storage folder**. Your conversations (full history and branch structure) and settings are saved there as JSON, so nothing is lost between sessions.

**Your data**:`conversations.json`

and`settings.json`

in the folder you pick.**A tiny pointer**: a`config.json`

in the OS app-data dir remembers*where*your folder is — the only thing stored outside it.**Model weights** are managed by Ollama in`~/.ollama/`

, not by OpenYoke.

Nothing is transmitted off your machine. OpenYoke only talks to your local Ollama instance.

OpenYoke is a **pure Tauri** app — a Rust backend and a dependency-free web UI in one native binary. The frontend calls the backend over Tauri's `invoke`

bridge; the backend talks to Ollama over HTTP.

```
┌──────────────────────────────────────┐
│  OpenYoke (native desktop app)        │
│                                       │
│  WebView UI (static/)                 │
│      │  invoke() / Channel            │
│      ▼                                │
│  Rust backend (src-tauri/)            │──HTTP──▶  Ollama (:11434)
│   • tree.rs   branching + context     │
│   • ollama.rs model + streaming chat  │
│   • storage.rs your data folder       │
│   • catalog.rs model library          │
└──────────────────────────────────────┘
```

`static/`

— the graph + model-management UI (vanilla HTML/CSS/JS, no bundler).`src-tauri/src/tree.rs`

— pure branching-tree logic and the context-isolation walk.`src-tauri/src/ollama.rs`

— the single seam to Ollama (`list_models`

,`chat_stream`

,`pull_model`

,`delete_model`

).`src-tauri/src/storage.rs`

— resolves the user-chosen storage folder.`src-tauri/src/catalog.rs`

— the browsable model library (remote-refreshable, bundled fallback).

- Provider abstraction for multiple backends (the
`ollama`

module is the seam) - Optionally bundle Ollama so no separate install is needed
- Richer tool / function-calling integration
- Multi-model agent mode (different models per branch)
- Export a branch or the whole tree (Markdown / JSON)

Contributions are welcome — issues, ideas, and pull requests all help. See [CONTRIBUTING.md](/saicv8/OpenYoke/blob/main/CONTRIBUTING.md) to get started.

[MIT](/saicv8/OpenYoke/blob/main/LICENSE) © OpenYoke contributors.

**Keywords:** local-first AI · Ollama GUI · private ChatGPT alternative · offline LLM · open-source models · branching conversations · conversation tree · tree of thought · llama · mistral · qwen · Tauri · Rust · desktop AI app

If OpenYoke is useful to you, consider giving it a ⭐ — it genuinely helps.