Open-PC

Give AI Its Own Computer.

A complete Linux desktop environment, purpose-built for AI agents to see, control, and operate.

What is it? • Quick Start • Features • Use Cases • Architecture

Made and maintained by The A-Tech Corporation PTY LTD

🎯 What is Open-PC?

Open-PC is exactly what it sounds like: an open computer that AI can use.

No more guessing what your AI assistant sees. No more limited APIs. Open-PC gives artificial intelligence a complete, interactive Linux desktop—the same kind you use every day—complete with a graphical interface, web browser, applications, and full input control.

Imagine an AI that can:

🖱️ Click, type, scroll just like a human user
👁️ See the screen through real-time video streaming
🪟 Manage windows and applications
📝 Read text directly from the display using OCR
🌐 Browse the web and interact with any website
⚡ Execute commands in a real terminal

One purpose: Give AI its own computer.

🚀 Quick Start

Get Open-PC running in under 2 minutes:

# Clone and start
git clone https://github.com/hamishfromatech/open-pc.git
cd open-pc
cp .env.example .env
docker compose up -d

That's it. Open your browser to http://localhost:8092 and watch AI take control.

With GPU Support (NVIDIA)

For AI workloads that need GPU acceleration (PyTorch, Ollama, etc.):

# 1. Install the NVIDIA Container Toolkit on your host:
#    https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html

# 2. Set the flag in .env
echo "ENABLE_GPU=true" >> .env

# 3. Build with GPU support (adds CUDA + PyTorch, ~10 min extra)
docker compose -f docker-compose.yml -f docker-compose.gpu.yml up -d --build

This adds NVIDIA CUDA 12.6, cuDNN, PyTorch (CUDA 12.6), and common ML libraries (transformers, accelerate, huggingface_hub) to the container. The GPU device is passed through at runtime via the NVIDIA Container Toolkit.

That's it. Open your browser to http://localhost:8092 and watch AI take control.

Access Points

Service	URL	Purpose
Live Dashboard	http://localhost:8092	Watch AI control the desktop in real-time
noVNC Web	http://localhost:6080	Browser-based remote desktop view
REST API	http://localhost:8090	HTTP endpoints for automation
MCP Server	http://localhost:8091	Native AI assistant integration

Default password: openpc

`openpc` CLI

A noun-verb CLI wraps docker compose and the REST API so you don't have to remember service names, ports, and curl incantations (inspired by SmolVM's smolvm CLI):

python3 openpc.py start          # build + start all containers
python3 openpc.py status          # show running containers (alias: ps, list)
python3 openpc.py logs desktop -f # tail the desktop logs
python3 openpc.py shell           # shell into the desktop container
python3 openpc.py exec -- ls -la  # run a command in the desktop container
python3 openpc.py screenshot      # save screen.png from the REST API
python3 openpc.py open-url https://github.com
python3 openpc.py run -- echo hello
python3 openpc.py doctor          # diagnose docker / compose / REST health
python3 openpc.py stop

Set OPENPC_TOKEN (or REST_AUTH_TOKEN) in the environment if the REST API is token-protected, so screenshot / open-url / run authenticate.

✨ Features

🖥️ Complete Desktop Environment

Full XFCE4 Linux desktop with GUI applications
Google Chrome pre-installed and ready to browse
Terminal, file manager, and system tools
1920x1080 resolution (configurable)

🤖 AI-First Design

MCP (Model Context Protocol) native support
Connect Claude, ChatGPT, or any MCP-compatible AI
22+ built-in tools for complete desktop control
Real-time screen streaming at 30 FPS

🎮 Real-Time Dashboard

Live MJPEG video feed of the desktop
Click anywhere to interact directly
Execute terminal commands from the web
Monitor AI activity as it happens

🔧 Developer Friendly

REST API for simple HTTP integration
WebSocket for real-time bidirectional control
Comprehensive documentation
Docker-based for easy deployment

🔒 Safe Sandbox

Isolated Docker container—your real machine stays safe
Resource limits prevent runaway processes
Persistent storage for session data
Health monitoring and auto-restart
Optional REST API token authentication (REST_AUTH_TOKEN)
Shell command sanitization blocks dangerous injection constructs

🎬 Use Cases

AI-Powered Automation

Let AI assistants perform complex GUI tasks that APIs can't handle—filling forms, navigating dashboards, and operating desktop applications just like a human would.

Automated Testing

Run end-to-end GUI tests in a controlled environment. Take screenshots, verify visual output, and simulate real user interactions.

AI Research

Provide AI models with a real graphical environment to interact with. Perfect for training agents, testing reasoning, and developing new interaction paradigms.

Remote Work Automation

Build automation scripts that can interact with any desktop application—legacy software, internal tools, and apps without APIs.

RPA Development

Develop and test robotic process automation workflows in a safe sandbox before deploying to production.

🏗️ Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                         Open-PC System                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   🌐 Web Dashboard        🤖 MCP Server         🖥️ noVNC Web       │
│   (Port 8092)             (Port 8091)             (Port 6080)       │
│   React + Real-time       FastMCP + SSE           Browser VNC      │
│       │                       │                         │          │
│       └───────────────────────┼─────────────────────────┘          │
│                               │                                     │
│                               ▼                                     │
│               ┌──────────────────────────────┐                       │
│               │    🎛️ Agent Server          │                       │
│               │    FastAPI + WebSocket      │                       │
│               │    • Screenshot API          │                       │
│               │    • Mouse/Keyboard Control │                       │
│               │    • Window Management      │                       │
│               │    • MJPEG Streaming        │                       │
│               └──────────────┬───────────────┘                       │
│                              │                                       │
│                              ▼                                       │
│  ┌────────────────────────────────────────────────────────────────┐ │
│  │         📦 Docker Container (Ubuntu 24.04)                     │ │
│  │  ┌──────────────────────────────────────────────────────────┐  │ │
│  │  │  🖥️ TigerVNC Server                                      │  │ │
│  │  │     • Virtual display 1920x1080                          │  │ │
│  │  │     • XFCE4 Desktop Environment                          │  │ │
│  │  │     • Google Chrome Browser                              │  │ │
│  │  └──────────────────────────────────────────────────────────┘  │ │
│  │  ┌──────────────────────────────────────────────────────────┐  │ │
│  │  │  ⚡ Automation Layer                                      │  │ │
│  │  │     • PyAutoGUI (Mouse/Keyboard)                         │  │ │
│  │  │     • MSS (Fast Screenshots)                              │  │ │
│  │  │     • xdotool/wmctrl (Window Management)                 │  │ │
│  │  │     • Tesseract OCR (Text Extraction)                    │  │ │
│  │  └──────────────────────────────────────────────────────────┘  │ │
│  └────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘

🤝 AI Integration

MCP Server (Recommended)

Open-PC includes a native FastMCP server (v3.x) for seamless integration with AI assistants:

{
  "mcpServers": {
    "open-pc": {
      "type": "streamable-http",
      "url": "http://localhost:8091/mcp"
    }
  }
}

Once connected, your AI gains these capabilities:

Category	Available Tools
👁️ Vision	`take_screenshot`, `get_screen_size`
🖱️ Mouse	`move_mouse`, `click`, `double_click`, `right_click`, `scroll`, `drag`
⌨️ Keyboard	`type_text`, `press_key`, `press_hotkey`
🪟 Windows	`list_windows`, `focus_window`, `close_window`, `maximize_window`, `minimize_window`
📱 Apps	`launch_application`, `open_url`, `run_command`
🔧 Utility	`perform_ocr`, `wait_seconds`

REST API

Simple HTTP endpoints for any programming language:

# Take a screenshot
curl http://localhost:8090/screenshot --output screen.png

# Click somewhere
curl -X POST http://localhost:8090/mouse/click \
  -H "Content-Type: application/json" \
  -d '{"x": 500, "y": 300}'

# Type something
curl -X POST http://localhost:8090/keyboard/type \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello, AI World!"}'

# Open a website
curl -X POST http://localhost:8090/apps/open-url \
  -H "Content-Type: application/json" \
  -d '{"url": "https://github.com"}'

Token authentication: If you set REST_AUTH_TOKEN in .env, every REST endpoint (except /health) requires a token via the X-OpenPC-Token header (or Authorization: Bearer <token>):
curl -H "X-OpenPC-Token: your-secret-token" http://localhost:8090/screenshot --output screen.png
When unset, the REST API remains open (backwards compatible).

Capability discovery: GET /capabilities advertises the available tools, transports, and enforced limits (rate limits, command timeout bounds) so an agent or SDK can probe what it can drive without guessing. The full machine- readable contract is also available at the standard FastAPI endpoint GET /openapi.json (and committed as dashboard/openapi.json, which the dashboard's TypeScript SDK is generated from).

⚙️ Configuration

Environment Variables

Variable	Default	Description
`VNC_PASSWORD`	`openpc`	Desktop access password
`VNC_RESOLUTION`	`1920x1080`	Screen resolution
`AUTH_REQUIRED`	`true`	Require WebSocket authentication
`REST_AUTH_TOKEN`	(empty)	Optional token to protect REST endpoints (sent via `X-OpenPC-Token` header). Empty = open
`ENABLE_GPU`	`false`	Set to `true` to install CUDA + PyTorch in the image (use with `docker-compose.gpu.yml`)

Ports

Port	Service
5901	Native VNC Server
6080	noVNC Web Interface
8090	REST API / WebSocket
8091	MCP Server (AI)
8092	Web Dashboard

🧪 Development & Testing

Open-PC ships with a test suite, linting, and CI so changes stay safe.

Python (agent server + MCP server)

# Lint
pip install ruff
ruff check openpc.py docker mcp-server tests

# Run the test suite (no display required — pyautogui is mocked)
pip install pytest httpx fastapi uvicorn pydantic slowapi pillow
pytest -q

The API tests use FastAPI's TestClient against the real agent_server with a mocked display layer, exercising routing, the rate limiter, run_command sanitization, and the REST token auth middleware end-to-end.

Dashboard (React + Vite + TypeScript)

cd dashboard
npm install
npm run lint        # ESLint (flat config)
npm run typecheck    # tsc --noEmit
npm run build        # tsc --noEmit && vite build

CI

A GitHub Actions workflow (.github/workflows/ci.yml) runs three jobs on every push / pull request: lint (ruff), test (pytest), and dashboard (eslint + typecheck + build).

🛡️ Security

Open-PC is designed as a sandboxed environment:

✅ Isolated Container — Runs in Docker, separate from your host system
✅ Network Isolation — Internal Docker network for service communication
✅ Resource Limits — CPU and memory constraints prevent runaway processes
✅ Authentication — Password protection for VNC and WebSocket access, plus optional REST API token (REST_AUTH_TOKEN)
✅ Command Sanitization — run_command blocks shell chaining/injection constructs
✅ No Host Access — Container has no access to host filesystem or devices

Recommended for production:

Change the default password
Run behind a reverse proxy with TLS
Use network isolation for sensitive deployments

📦 Tech Stack

Component	Technology
Base OS	Ubuntu 24.04 LTS
Desktop	XFCE4
VNC	TigerVNC + noVNC
Backend	Python 3 + FastAPI + Uvicorn
Automation	PyAutoGUI, MSS, python-xlib
MCP	FastMCP v3.x (streamable-http transport)
Frontend	React 18 + Vite + TypeScript
Browser	Google Chrome
GPU (opt-in)	NVIDIA CUDA 12.6 + PyTorch

📄 License

MIT License — Use it, modify it, build on it.

🙏 Acknowledgments

Open-PC stands on the shoulders of giants:

FastMCP — MCP server framework
noVNC — Browser VNC client
PyAutoGUI — Desktop automation
FastAPI — Modern web framework

Open-PC
Because AI deserves its own computer.

Made with ❤️ by The A-Tech Corporation PTY LTD

Navigation Menu

Repository files navigation

Open-PC

🎯 What is Open-PC?

🚀 Quick Start

With GPU Support (NVIDIA)

Access Points

`openpc` CLI

✨ Features

🖥️ Complete Desktop Environment

🤖 AI-First Design

🎮 Real-Time Dashboard

🔧 Developer Friendly

🔒 Safe Sandbox

🎬 Use Cases

AI-Powered Automation

Automated Testing

AI Research

Remote Work Automation

RPA Development

🏗️ Architecture

🤝 AI Integration

MCP Server (Recommended)

REST API

⚙️ Configuration

Environment Variables

Ports

🧪 Development & Testing

Python (agent server + MCP server)

Dashboard (React + Vite + TypeScript)

CI

🛡️ Security

📦 Tech Stack

📄 License

🙏 Acknowledgments

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
dashboard		dashboard
docker		docker
docs		docs
mcp-server		mcp-server
scripts		scripts
tests		tests
.env.example		.env.example
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
CHANGELOG.md		CHANGELOG.md
README.md		README.md
docker-compose.gpu.yml		docker-compose.gpu.yml
docker-compose.yml		docker-compose.yml
mcp_config.example.json		mcp_config.example.json
openpc.py		openpc.py
pyproject.toml		pyproject.toml
screenshot.png		screenshot.png

Latest commit

History

Folders and files

Repository files navigation

Open-PC

🎯 What is Open-PC?

🚀 Quick Start

With GPU Support (NVIDIA)

Access Points

openpc CLI

✨ Features

🖥️ Complete Desktop Environment

🤖 AI-First Design

🎮 Real-Time Dashboard

🔧 Developer Friendly

🔒 Safe Sandbox

🎬 Use Cases

AI-Powered Automation

Automated Testing

AI Research

Remote Work Automation

RPA Development

🏗️ Architecture

🤝 AI Integration

MCP Server (Recommended)

REST API

⚙️ Configuration

Environment Variables

Ports

🧪 Development & Testing

Python (agent server + MCP server)

Dashboard (React + Vite + TypeScript)

CI

🛡️ Security

📦 Tech Stack

📄 License

🙏 Acknowledgments

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`openpc` CLI