WindieOS

WindieOS is a hackable desktop runtime for personal AI agents. It turns your desktop session into an AI workspace: screen state, windows, browser sessions, local files, apps, shell, memory, permissions, and the user's current workflow become first-class runtime context for the agent.

Most AI agents begin inside a chat box. They receive messages, call tools, use memory, run commands, browse the web, and reply. That model is useful, but it still treats the computer as something outside the agent. WindieOS starts from a different assumption: if AI is going to help with real personal work, it needs to live inside the user's computing environment.

WindieOS is built around the live desktop session, not the chat window. The minimal chat pill matters because it makes the agent feel present on the machine, not trapped inside a web app. The agent can observe the workspace, act through the same apps the user uses, ask permission before sensitive actions, and work beside the user in a visible way.

Download Windie on its official website: WindieOS

Latest releases: Releases

---

Why Windie

Desktop session as runtime	WindieOS treats the user's live desktop session as the agent workspace: screen, windows, browser state, files, apps, shell, memory, permissions, and current workflow.
Visible desktop presence	The minimal chat pill stays on top of the operating system, so the agent feels present on the machine instead of trapped inside a browser tab or separate app.
Shared-workspace collaboration	WindieOS can work from the same screen you are looking at. It does not need you to describe every button, page, or app state before it can help.
Voice-first by design	Say "Hey Jarvis", speak your request, and WindieOS transcribes it into the agent loop. The goal is a keyboard-free agent you can call while your hands are busy.
Model-provider flexible	WindieOS is designed for multimodal model providers instead of one native computer-use stack. The backend owns provider policy while the desktop sidecar owns local execution.
Hackable agent runtime	Change the instructions, add skills, register local tools, wire MCP servers, or build your own desktop agent on top of the SDK and sidecar runtime.

---

Just Talk To It

WindieOS is meant to be usable without reaching for the keyboard.

You say "Hey Jarvis". WindieOS records your voice, transcribes it, attaches the screen context when useful, and sends the request into the agent loop. The agent can answer, browse, click through forms, inspect files, run terminal commands, remember local context, and show its progress without pulling you into a separate app.

That is the core product bet: the agent should be present wherever you are on the computer.

Desktop Experience

The first state is the minimal chat pill. It floats on your screen, stays out of the way, and can automatically attach the current screen when you send a message. This is the state you should live in most of the time.

The second state is the fullscreen dashboard. It shows the longer conversation, live tool logs, memory surfaces, settings, and everything else you need when you want to inspect the agent loop closely.

Windie is designed to feel present without taking over the computer. It gives the agent a place to react while it clicks, types, browses, runs commands, or waits for you to redirect it.

Build Your Own Windie

WindieOS is fully open source because the agent's operating environment should be shaped by the person using it.

If the default instructions are wrong, replace them. If the UI does not fit your workflow, change the frontend. If the agent needs a new capability, add a local tool, skill, plugin, or MCP server. If you want to build a different desktop agent entirely, use the Windie SDK, sidecar daemon, and hosted-agent contracts as the starting point.

The repo is structured so the desktop app, local sidecar, SDKs, extension roots, and backend contracts can be developed directly instead of treated as a closed product shell.

Architecture

WindieOS is a local desktop environment built around an agent working inside the user's computer session. The TypeScript Windie SDK runtime is the canonical client runtime for conversations, model selection, backend transport, local tool routing, replay, projections, and pluggable conversation stores.

CLI / custom UI / Electron desktop / tests
        |
        v
Windie SDK runtime
        |-- hosted backend HTTP/WebSocket
        |-- local sidecar daemon
        |-- conversation store adapters

The hosted backend owns inference, model/provider policy, prompts, provider history, compaction decisions, OCR/vision/prediction policy, and backend-visible tool schemas. The local sidecar owns filesystem, shell, browser, computer-use, MCP, plugin, extension, local memory, and permission-checked desktop execution.

The Electron desktop is the flagship reference client built on that SDK runtime. It should render SDK display projections, collect user input, expose settings, and host desktop-specific permissions and windows. UI rows are not the storage truth; backend rehydrate history is generated from normalized SDK conversation events or complete compacted replay snapshots.

Quick Start

Download

Download Windie on its official website: WindieOS

Latest releases: Releases

Windie is designed for macOS, Windows, and Linux.

Run From Source

git clone https://github.com/buiilding/WindieOS.git
cd WindieOS

Install backend dependencies:

pip install -r backend/requirements.txt

Install frontend dependencies:

cd frontend
npm install

Install sidecar dependencies:

cd ..
./scripts/python-in-env sidecar python -m pip install -r frontend/src/main/python/requirements.txt

Start the backend:

bin/windie start backend

In another terminal, start the desktop dev loop. This starts the Vite renderer dev server and Electron dev app together; Ctrl-C stops both.

bin/windie start dev

By default, the Electron client talks to the configured WindieOS backend. Use BACKEND_* or WINDIE_BACKEND_* overrides when pointing the client at another compatible backend instance.

Docs

Start with the Documentation Hub, or jump directly into a topic:

Section	What it covers
Quick Start	Install dependencies and run WindieOS from source.
Installation	Source install, endpoint overrides, sidecar Python resolution, and verification.
User Guide	Chat pill, dashboard, browser-use, memory, and stop/redirect behavior.
Frontend Architecture	Electron main, React renderer, preload boundary, and sidecar ownership.
Communication Flow	IPC, JSON-RPC, WebSocket, HTTP, query, memory, and tool event paths.
Tool System	Hosted orchestration boundary, sidecar tool execution, and renderer visibility.
Windie SDK Runtime	Canonical client runtime, model switching, conversation stores, projections, and local tool routing.
Computer-Use	Mouse, keyboard, screenshots, scrolling, window actions, and coordinate grounding.
Browser-Use	Windie browser profile, browser automation actions, and runtime behavior.
Frontend Docs	Deep frontend maps across main, renderer, preload, contracts, runtime, and inventory.
Sidecar Docs	Python sidecar runtime, memory, browser automation, services, and tools.
Operations	Configuration, packaging, release, security, performance, and sidecar runtime packaging.
Development	Contribution workflow, environment setup, tests, and tool development.
API Reference	Backend API and transport surfaces consumed by the client, sidecar, and SDKs.

The docs describe the Electron frontend, Python sidecar, browser-use runtime, local memory, backend agent loop, model providers, SDK/API surfaces, packaging, and operations.

License

See LICENSE.