orangu is a local workspace-aware tool-driven coding environment for OpenAI-compatible servers - especially llama.cpp.
orangu does not require an Internet connection after llama.cpp and models have been downloaded.
orangu is named after the Orangutan - the smartest ape.
- Why orangu?
- Features
- orangu vs. a cloud coding assistant
- Installation
- Configuration and first run
- Documentation
- Tested platforms
- Sponsors
- Contributing
- Community
- License
orangu is the lean, private, Git-centric coding companion for the terminal — built for developers who run their own models and want a tightly integrated review workflow without sending a single line of code to the cloud.
- 100% local and private — zero telemetry; after the model is downloaded no Internet connection is needed, so it runs happily in privacy-sensitive or air-gapped environments. Your code and conversations stay on your machine.
- Built-in code review — an interactive two-pane reviewer (
/review) and a category-by-category LLM auto-reviewer (/auto_review). This review story is orangu's standout feature; few tools its size match it. - A single fast native binary — written entirely in Rust, with quick startup, no runtime to install, no garbage-collector pauses, and a small download.
- The whole Git loop lives in the prompt — branch, commit, rebase, squash, cherry-pick, stash, bisect, push, and GitHub/GitLab pull requests, comments, and issues, all without leaving the terminal.
- Tuned for llama.cpp — live tokens/second in the footer, and an interactive
--initwizard that auto-detects the model your server is serving. - Natural to drive — dozens of slash commands, each with plain-English aliases (
review,auto review,commit "...",merge feature/foo,pull 58).
Fully local and private. orangu talks to any OpenAI-compatible server — and is tuned for llama.cpp — so once the server and models are downloaded, nothing leaves your machine and no Internet connection is required. Your code is never sent to a third-party cloud.
Code review built in. orangu's standout feature is a pair of in-terminal review workflows — an interactive reviewer and a fully automated, LLM-driven one — covered in Code review and auto review below.
Workspace-aware tooling. Local tools read, edit, list, search (/grep), and fetch files, and run shell commands — all scoped to your workspace. A full set of Git commands (/status, /diff, /log, /commit, /amend, /squash, /rebase, /merge, /cherry_pick, /branch, /stash, /bisect, /push, /pull, …) and forge integration (/pull_request, /comment, /close, /get_comments on GitHub and GitLab) keep the whole change-and-review loop in one place.
Comfortable terminal experience.
- Persistent terminal UI with workspace, server, and model status in the header, refreshed every minute while idle
- Shell-style prompt editing, history, scrolling, and context-sensitive Tab completion, with grey inline command hints (Tab accepts, Shift+Tab cycles between matches)
- Natural-language aliases for nearly every command — e.g.
review,auto review,open README.md,list models,pull 58,commit "[#42] My feature",rebase,merge feature/foo,get comments for issue 51,export review - Streaming responses with live footer status such as
Thinking (...)and llama.cpp-nativeWorking @ X.Y t/s (...) - Queued local commands while a response is in flight, plus double-
Escrequest cancellation - Markdown rendering in the console (bold, italic, headings, lists, links, code) with syntax highlighting for fenced code blocks
Share what you produce. Export the output window or the last review report to a PDF in the workspace root (/export console, /export review), or post a review straight onto an issue or pull request with /comment <number> with review / with auto review.
Works offline, end to end. Even the built-in user manual (/manual) — a two-pane viewer with full-text search (Alt+S) — is embedded in the binary at compile time, so the docs are there with no network.
orangu turns the terminal into a code-review workstation for the changes on your current branch (committed plus local uncommitted work), measured against the merge base with the default branch. Both reviewers require the branch to be rebased up to date, so you never review against stale code.
/review — interactive review. A full-screen, two-pane view (file checklist on the right, the selected file's diff on the left, your prompt at the bottom) for reading a branch before you share it. You can:
- Mark each file approved (green) or rejected (red)
- Comment on any diff line under a chosen category (Overall, Code, Security, Memory, Performance, Test Suite, Documentation), plus whole-patch notes
- Ask the connected model about the selected file on demand (
focus on error handling,is this thread-safe?) — the exchange joins your chat session for follow-up - Open any workspace file in your
$EDITORwithout leaving the view
On exit it writes a category-grouped report with an approve/reject Conclusion, copies the Markdown to the clipboard, and keeps it for /export review and /comment ... with review. No gh/glab needed.
/auto_review — LLM-driven review. The model reviews the whole change and each file on its own, sorting findings into the same seven categories and marking every file approved or rejected — then summarizes the change as a whole under Overall and renders a final Conclusion verdict (orangu approves/rejects this patch). It is smart about effort:
- File type decides what's scanned — lock files and binary assets are auto-approved with no requests, documentation is reviewed only for the Documentation category, and source files get the full set of checks
- A live status bar shows the current file, category, overall progress, elapsed time, and an updating time estimate; the terminal title blinks and the bell rings on completion (when
feedbackis on) - Each finding is pinned to its
file:line, and requests are length-capped and tool-free so reviews stay fast and bounded even on slow local models - After the run you can browse the report, override any verdict (approve/reject with your own comment), and remove findings before exporting
Run /auto_review <file> to review a single file (the whole file on main/master, or just its changes on a branch). Like /review, the report is copied to the clipboard and reusable with /export review and /comment ... with auto review.
Tip: the per-request length cap is
review_max_tokens(default512;0disables it). If you review with a model that thinks before answering, raise it (e.g.2048) so the reasoning tokens don't crowd out the answer — see the Configuration chapter (Response-token caps). Setfeedback = onto get the blinking terminal title and completion bell during a run.
See Core tools in the manual for the full reference and key bindings.
orangu makes a deliberate trade: a focused, offline-first, Git-centric terminal experience instead of a broad cloud platform. If you run your own models and care about privacy, that trade is the whole point.
| orangu | Typical cloud coding assistant | |
|---|---|---|
| Where your code goes | Stays on your machine — zero telemetry | Sent to a third-party provider |
| Offline use | First-class; only the initial model download needs a network | Generally requires connectivity |
| Models | Any OpenAI-compatible server — tuned for local llama.cpp (Ollama, LM Studio, …) | Vendor-hosted models, usually behind API keys |
| Cost | Free to run against models you host | Per-token / subscription billing |
| Footprint | One native Rust binary, fast start, no runtime | Editor/cloud service + account |
| Code review | Built-in interactive and LLM auto review in the terminal | Usually delegated to the hosting platform |
| Git workflow | Full Git + GitHub/GitLab loop from the prompt | Varies; often browser-based |
| Privacy posture | Suited to regulated / air-gapped environments | Depends on the provider's data policy |
orangu trades breadth and extensibility for simplicity, predictability, and a small attack surface. If you need a multi-front-end platform with a large plugin/MCP ecosystem, a cloud-first agent will fit better — orangu is the lean, private alternative for local models.
Linux / macOS (requires curl or wget, and tar):
curl -fsSL https://raw.githubusercontent.com/mnemosyne-systems/orangu/main/install.sh | shWindows (requires PowerShell, included with Windows 10 and later):
curl -fsSL https://raw.githubusercontent.com/mnemosyne-systems/orangu/main/install.cmd -o install.cmd && install.cmdBoth scripts download the latest release binary, install it to ~/.local/bin (Linux/macOS) or %USERPROFILE%\.local\bin (Windows), and warn if the directory is not in your PATH.
Custom install directory: set INSTALL_DIR before running the script:
# Linux / macOS
curl -fsSL https://raw.githubusercontent.com/mnemosyne-systems/orangu/main/install.sh | INSTALL_DIR=/usr/local/bin sh:: Windows
set "INSTALL_DIR=C:\Tools" && install.cmdShell completions: after installing, run orangu -s to print the completion script for your shell:
# bash
orangu -s >> ~/.bashrc && source ~/.bashrc
# zsh
orangu -s >> ~/.zshrc && source ~/.zshrc
# fish
orangu -s | sourceOn Windows, add Invoke-Expression (orangu -s) to your PowerShell $PROFILE.
Fedora / RHEL:
dnf install -y git rust cargoDebian / Ubuntu:
apt-get install -y git curl
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shmacOS:
brew install rustThe following commands build an optimized release binary:
git clone https://github.com/mnemosyne-systems/orangu.git
cd orangu
cargo build --releaseThe binary will be available at:
target/release/orangu
To install it system-wide:
sudo install -Dm755 target/release/orangu /usr/local/bin/oranguThe following commands build a debug binary:
git clone https://github.com/mnemosyne-systems/orangu.git
cd orangu
cargo buildThe binary will be available at:
target/debug/orangu
The quickest way to get a working configuration is the interactive wizard:
orangu --initIt asks for the LLM URL, auto-detects a model the server advertises (and
pre-fills it as the Model), then walks every option showing its default.
Anything left at its default is omitted from the file, and the result is shown
for confirmation before being written to ~/.orangu/orangu.conf (creating the
directory if needed, and overwriting any existing file). The provider is
assumed to be llama.cpp.
Alternatively, start from the sample configuration:
cp doc/etc/orangu.conf ./orangu.confDefault configuration lookup order:
./orangu.conf~/.orangu/orangu.conf
Run the client:
orangu --config ./orangu.confOr run it directly from the build tree:
./target/release/orangu --config ./orangu.confBy default, local tools operate on the current working directory. Use --workspace /path/to/project (-w) to point orangu at another tree.
The startup flags also have short forms: -c for --config, -w for --workspace, -r for --resume, and -i for --init.
Shell completion scripts (bash, zsh, fish) for these flags live in contrib/shell/.
Useful first commands:
/help
/tools
/list_files
/open_file README.md
/show_file README.md
/amend "[#42] My feature"
/cherry_pick abc1234
/commit "[#42] My feature"
/delete feature/foo
/log
/log 5
/squash
/status
- Latest manual
- Getting Started
- Quick start
- Configuration
- Terminal interface
- Core tools
- Git tools
- Usage tools
- Tools
- Fedora 44
Contributions to orangu are managed on GitHub:
Contributions are most welcome.
Please consult the Code of Conduct before contributing.
- GitHub: mnemosyne-systems/orangu
- Discussions: GitHub Discussions