Patr is an incredibly simplified cloud platform that can deploy
static sites, web apps, databases, containers and more in seconds. In
fact, You can build, deploy and host ANYTHING with a Dockerfile. You
also get instant support from our dev team.
Patr is a self-hosted, production-grade DevOps automation platform built for fast-moving teams.
It lets developers deploy and manage services without
needing to understand or operate traditional DevOps infrastructure. No
Kubernetes expertise required. No bespoke CI/CD glue. No hand-rolled
observability stacks.
Patr is designed to feel closer to a control plane than a hosting provider.
⚠️ Early Beta
Patr is still in the early stages of development. APIs and resource models may change.
Not recommended for mission-critical production workloads yet.
We would LOVE to have contributors onboard, but please be aware that the project is not yet ready for production use.
Using the CLI
To manage Patr resources from your terminal, install the CLI:
curl -fsSL https://raw.githubusercontent.com/patr-cloud/patr/develop/assets/cli/install.sh | sh
See cli/README.md for channels, upgrade, and uninstall instructions.
Running the project
Nobody reads large text anyway (other than LLMs), so here's a skimmed down version:
Dependencies needed
Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Node.js (>=22) and pnpm (the frontend is a SolidJS app)
Postgres
Redis
Create a config file
Copy ./config/api.sample.json to ./config/api.json and fill in the required fields. You'll primarily need to fill in database and redis fields.
Run the project
cargo api
???
Profit!
You can now access the project at http://localhost:3001.
Features
Patr is built with Rust, Axum, and Postgres. It is
designed to be fast, secure, and scalable. Your code can be deployed to
any environment from a single dashboard. For example, you can manage
your deployments that are running on a VM (say, EC2 instance) as well as
your deployments that are running on a Kubernetes cluster, all from a
simple, easy-to-use, unified dashboard. Where your code runs is up to
you, Patr just helps you manage it. This means that you can also use
Patr to manage your deployments on your local machine, if you so desire.
A common use-case of having a home-box on a Raspberry Pi, for example,
and managing your deployments on it with Patr is supported.
Start interacting with the chatbot and experimenting with LLMs!
Checkout this youtube video to follow installation steps
Command line arguments
Argument Command
Default
Description
--host
127.0.0.1
Host or IP address on which the server will listen for incoming connections
--port
7860
Launch gradio with given server port
--share
False
This generates a public shareable link that you can send to anybody
Connect to WebSocket for generation
Connect to ws://localhost:7861/ for real-time text
generation. Submit prompts and receive responses through the websocket
connection.
Integration with Frontends:
The provided example/index.html demonstrates
basic usage of text generation through websocket connection. You can
integrate it with any frontend framework like React.js
Installation and Development Tips
Python Version
Compatible Versions: This project is compatible
with Python versions 3.8+ to 3.11. Ensure you have one of these versions
installed on your system. You can check your Python version by running python --version or python3 --version in your terminal.
Cmake and C Compiler
Cmake Dependency: If you plan to build the project using Cmake, make sure you have Cmake installed.
C Compiler: Additionally, you'll need a C compiler
such as GCC. These are typically included with most Linux distributions.
You can check this by running gcc --version in your terminal. Installation instructions for your specific operating system can be found online.
Visual Studio Code
Visual Studio Installer: If you're using Visual
Studio Code for development, you'll need the C++ development workload
installed. You can achieve this through the Visual Studio Installer
GPU Acceleration (CUDA):
CUDA Installation: To leverage GPU acceleration, you'll need CUDA installed on your system. Download instructions are available on the NVIDIA website.
Torch Compatibility: After installing CUDA, confirm CUDA availability with torch.cuda.is_available(). When using a GPU, ensure you follow the project's specific llama-cpp-python installation configuration for CUDA support.
PI-Desktop puts an AI coding agent in a native desktop
app. Point it at a project, describe what you want — explore and
understand code, build a feature, review changes, fix a failing test —
and watch it work, with every file edit and shell command surfaced for
your approval.
There is no account, no subscription, and no cloud in the
middle: you connect the model provider you already use, and everything
else — sessions, settings, API keys — stays local.
Highlights
Any model, your keys. Anthropic, OpenAI, or
anything that speaks an OpenAI-compatible API — hosted relays as well as
local gateways like Ollama or LM Studio. Model IDs are free-form (no
hardcoded allowlist), with per-model context window, output limit,
temperature, and thinking-mode controls.
Agent, Plan, and Goal modes. Agent mode reads,
edits, and runs commands to get things done. Plan has the same agent
inspect the project and submit an immutable implementation checkpoint
for approval. Goal lets the agent agree on an outcome and acceptance
criteria, then continue autonomously after approval.
You approve every change. File writes and shell
commands ask first, with session-scoped grants and a configurable
default policy. Unanswered prompts deny by default.
A real workbench. Review the agent's edits as
message-scoped diffs with guarded rollback, inspect command output in
the transcript, preview a local app in a browser, and browse project
files — all in a side panel, without leaving the conversation.
Projects and sessions. Sessions are grouped by
project in a multi-project sidebar, with pinning, archiving, sorting,
branching, notifications, and throwaway scratch sessions.
Local-first and private. Transcripts live on disk
as plain JSONL with a SQLite index — easy to back up, grep, or delete.
API keys go into the OS keychain. Logs stay local; there is no
telemetry.
Agent capabilities beyond plugins. Manage
standalone MCP servers, Skills, and global Subagents from Settings →
Agent, with project-scoped Skills and MCP overrides. The Extensions page
is reserved for installed plugins and the marketplace. Plugins can add
commands, panels, agent tools, skills, themes, MCP servers, resident
services, and a message bus; the local/official marketplace and .piplug package workflow are available today.
A fast daily workflow. Use slash commands and @
file references, paste files into session scratch, stage the next turn
while an answer streams, search plugins globally with Option/Alt+Space,
and create manual or recurring task prompts.
Comfortable to live in. English and 简体中文,
light/dark/system and plugin themes, command palette, onboarding
checklist, local notifications, context checkpoints, and update
notifications for packaged builds.
Plugin APIs and panels are permission-gated and run
out-of-process. Plugin code is still user-trusted code rather than a
complete OS sandbox, so review permissions and only install plugins you
trust.
Every turn in one transcript, with a minimap rail for long conversations
Install from the official catalog, a mirror, or a custom URL you configure
Switch the model per session — any provider you have configured, keys in the OS keychain
Language, theme, and appearance, including themes plugins contribute
✅ Published with each release; AppImage auto-updates in-app
macOS note: builds are not yet code-signed or notarized. If macOS refuses to open the app, right-click it and choose Open, or clear the quarantine flag:
xattr -cr /Applications/PI-Desktop.app
Packaged builds check GitHub Releases for new versions and show an in-app update banner.
Getting started
Add a model provider. Open Settings → Model configuration → Add provider:
pick the API style, paste the base URL and your API key, then choose or
type a model ID. The key is stored in your OS keychain and never shown
again.
Open a project. Add a project folder from the sidebar — sessions, tools, and permissions are scoped to it.
Describe the task. Start in Agent mode to make
changes, switch to Plan for an approval checkpoint, or use Goal when you
want to approve an outcome rather than prescribe the steps. Review work
in the Review diff panel before you commit anything.
Extend the workspace when needed. Open Settings → Agent to manage Skills, MCP servers, and global Subagents; open Extensions for installed plugins and the marketplace. Use Settings → Import to bring in local sessions from Claude Code, OpenCode, Codex, or Pi.
How it works
PI-Desktop keeps renderer privileges narrow and separates the agent loop from the desktop UI:
Electron shell — a sandboxed React renderer plus
the main/preload bridge for desktop-only services such as panels,
browser preview, updates, and supervision.
Rust host core — owns SQLite, transcript persistence, secrets, permissions, and workspace access over stdio JSON-RPC.
pi agent sidecar — a Node process running the pi agent engine (pi-ai + pi-agent-core) for the actual agent loop.
PI-Desktop is an early preview under active development.
The current 0.5.x line ships the app shell, streaming agent runtime,
Agent/Plan/Goal contracts, workspace tools with permissions, the
workbench, projects and sessions, imports, agent capability management
(MCP/Skills/Subagents), extensions (plugins), context checkpoints,
notifications, and cross-platform packaging with update checks.
Still in progress: signed and notarized macOS builds,
native Windows/Linux qualification, a stronger plugin sandbox and
publisher-signature path, and full UI-driven E2E coverage. See the milestones and the project board.
Development
Prerequisites: Node.js >=22.19, pnpm >=10 (the repository uses pnpm 11), and a stable Rust toolchain.
# build the Rust host core
cargo build -p host-core
# install JS dependencies and build packages + app
pnpm install
pnpm build:js
# run in dev mode
pnpm dev
# protocol e2e smoke test
PI_DESKTOP_TEST_API_KEY=... pnpm test:e2e
# Plan host acceptance (includes the real 60-second default timeout)
PI_DESKTOP_E2E_LONG_TIMEOUT=1 pnpm test:e2e:plan
# rendered English / Simplified Chinese Plan acceptance through Electron CDP
pnpm test:e2e:plan-ui
# focused desktop probes
pnpm test:e2e:boot
pnpm test:e2e:supervision
pnpm test:e2e:subagents
CI runs JS build / typecheck / lint / unit tests plus cargo test for
code-related pull requests and pushes to main; documentation-only changes are
skipped. Releases are cut by tag:
Behavioral and visual references:OpenAI Codex informs parts of the shell
and context-management UX. OpenCode DCP
was studied as a behavioral reference for context compaction; it is not a
PI-Desktop dependency, and no code is copied from it.
