The First AI-Native Remote Desktop
Built-in MCP Server · AI Agents Control Any Remote Computer · Open-Source & Free

English | 中文

Telegram | Issues | Download

QuickDesk is the first AI-native remote desktop — an open-source, free application with a built-in MCP (Model Context Protocol) Server that lets any AI agent see and control remote computers.

While other remote desktop tools only serve human users, QuickDesk extends AI Computer Use from "local machine only" to "any remote machine in the world". Connect Claude, GPT, Cursor, or any MCP-compatible AI to QuickDesk, and it can screenshot, click, type, drag, and automate across remote desktops — just like a human operator, but faster and 24/7.

Built on Google Chromium Remoting technology (the engine behind Chrome Remote Desktop), QuickDesk delivers industrial-grade performance, stability, and security refined over 10+ years by Google.

Main Interface

Remote Desktop

AI Config

• Built-in MCP Server: AI agents connect via standard MCP protocol — no plugins, no hacks, zero configuration
• Dual Transport: stdio mode (AI client spawns process) or HTTP/SSE mode (QuickDesk hosts MCP server for multi-client access)
• Full Computer Use Toolkit: 20+ MCP tools — screenshot, click, type, drag, scroll, hotkeys, clipboard, and more
• Real-Time Visibility: AI operations are displayed in the QuickDesk GUI in real time — the user sees every mouse move and keystroke, and can intervene at any time
• Multi-Device AI Orchestration: AI can connect to and control multiple remote machines simultaneously — batch automation, cross-device workflows, fleet management
• Guided Prompts: 9 built-in MCP prompt templates covering remote operation, server health check, batch automation, system diagnosis, screen analysis, multi-device orchestration, and SOP documentation

• Open-Source & Free: MIT License, no feature restrictions, no connection limits, commercial use welcome
• Self-Hosted: Deploy your own signaling and TURN relay servers, keep full control of your data
• Commercial-Grade Foundation: Built on Chromium Remoting — the same technology powering Chrome Remote Desktop, refined by Google for 10+ years and proven by billions of users
• Pure C++ Ultimate Performance: Full C++ stack from protocol core to GUI — no GC pauses, no runtime overhead, minimal memory and CPU footprint
• Modern Codecs: H.264, VP8, VP9, AV1 — flexibly switch based on network and hardware conditions
• WebRTC P2P Direct Connection: Prioritizes peer-to-peer connections for lowest latency; automatically falls back to TURN relay when traversal fails
• Cross-Platform: Windows and macOS supported (Linux planned)
• Modern UI: Fluent Design interface built with Qt 6 + QML, with light and dark themes

1. Pure C++ Full Stack: The entire stack — from low-level protocol to GUI — is implemented in C++. No garbage collection pauses, no VM/runtime overhead. Compared to RustDesk's Dart/Flutter GUI layer or ToDesk's Electron-based approach, CPU and memory usage are significantly lower.

2. Chromium-Level Optimization: Core paths for video encoding/decoding, network transmission, and screen capture directly reuse Chromium's highly optimized C++ code, including SIMD instruction optimization and zero-copy rendering pipelines.

3. Shared Memory Video Transfer: QuickDesk uses shared memory to pass video frames (YUV I420) between processes, eliminating the serialization/deserialization and data copying overhead of traditional IPC.

4. GPU-Accelerated Rendering: YUV data is fed directly into the GPU rendering pipeline via Qt 6's QVideoSink, achieving zero-CPU-copy video rendering.

• Built-in MCP Server — AI agents connect via standard protocol, works with Cursor, Claude Desktop, VS Code, and any MCP client
• Dual transport: stdio (AI client launches process) or HTTP/SSE (QuickDesk manages MCP server, multiple AI clients connect)
• Persistent MCP transport mode — remembers your stdio/HTTP choice across restarts
• 40+ MCP tools: screenshot, mouse click/drag/scroll, keyboard type/hotkey, clipboard, OCR text recognition, UI element detection, screen verification, and more
• Host-side AI Agent with built-in skills (system info, file operations, shell execution) — run structured tools on the remote machine
• Pluggable skills architecture — add custom skill directories, skills auto-load and sync to connected clients
• AI Agent toggle in Settings — enable/disable the agent process with persistent configuration
• MCP Resources: real-time device status, connection info, host details
• 9 MCP Prompts: operation guide, server health check, batch automation, system diagnosis, screen analysis, multi-device orchestration, SOP documentation
• Real-time event streaming: connection state changes, clipboard updates, screen changes, performance stats
• Event-driven tools: wait_for_event, wait_for_connection_state, wait_for_clipboard_change, wait_for_screen_change for reactive automation
• Background automation mode: show_window=false for headless batch operations
• Screenshot scaling: adjustable resolution for faster AI processing

• High-definition, low-latency remote desktop display
• Full keyboard and mouse mapping
• Real-time remote cursor synchronization
• Bidirectional clipboard sync
• Adaptive frame rate and bitrate
• Frame rate boost mode (Office / Gaming)

• 9-digit Device ID + temporary access code mechanism
• Auto-refresh access code (configurable: 30 min to 24 hours, or never)
• Multi-tab simultaneous connections to multiple remote devices
• Connection history with quick reconnect
• Real-time connection status monitoring

• Detailed latency breakdown panel (Capture → Encode → Network → Decode → Render)
• Real-time frame rate, bitrate, and bandwidth statistics
• Input round-trip time (RTT) monitoring
• Encoding resolution and quality information

• Fluent Design style interface
• Light and dark theme switching
• i18n support (Chinese / English)
• Video codec preference (H.264 / VP8 / VP9 / AV1)

• Custom signaling server address
• Custom STUN/TURN servers
• Complete server deployment solution (Go signaling server + PostgreSQL + Redis + coturn)

QuickDesk uses a modular multi-process architecture:

graph TD subgraph AI["AI Agent (Claude / GPT / Cursor)"] A1["MCP Protocol"] end subgraph MCP["quickdesk-mcp (Rust Bridge)"] M1["MCP stdio ↔ WebSocket"] M2["MCP HTTP/SSE ↔ WebSocket"] end subgraph GUI["QuickDesk GUI (Qt 6)"] direction LR WS["WebSocket API Server"] QML["QML/C++"] MainWin["Main Window"] RemoteWin["Remote Desktop Window"] end subgraph Host["quickdesk-host (Chromium Remoting)"] H1["Screen Capture"] H2["Video Encoding"] H3["Input Event Handling"] H4["WebRTC Connection"] end subgraph Client["quickdesk-client (Chromium Remoting)"] C1["Video Decoding"] C2["Input Event Injection"] C3["Shared Memory Video Frames"] C4["WebRTC Connection"] end subgraph Signaling["Signaling Server (Go + Gin)"] S1["WebSocket Signaling"] S2["ICE Config Distribution"] S3["Device Registration & Auth"] S4["PostgreSQL + Redis"] end subgraph TURN["TURN Server (coturn)"] T1["Relay when P2P traversal fails"] end AI -- "stdio (JSON-RPC)" --> MCP AI -. "HTTP/SSE" .-> M2 MCP -- "WebSocket" --> WS GUI -- "Native Messaging\n(stdin/stdout JSON)" --> Host GUI -- "Native Messaging\n(stdin/stdout JSON)" --> Client Host -- "WebSocket" --> Signaling Client -- "WebSocket" --> Signaling Signaling -- "ICE Config" --> TURN Host -. "WebRTC P2P / TURN Relay" .-> Client 

Go to Releases to download the latest version:

1. Install and run QuickDesk on both the host (remote) and client (local) machines
2. The host will automatically generate a Device ID and Access Code
3. On the client, enter the host's Device ID and Access Code, then click Connect
4. You're now remotely controlling the host machine

• CMake 3.19+
• Qt 6.5+ (Multimedia and WebSockets modules required)
• C++17 compiler

# Requires Visual Studio 2022 + MSVC # Set Qt path environment variable set ENV_QT_PATH=C:\Qt\6.8.3 # Build scripts\build_qd_win.bat Release # Package (requires Inno Setup) scripts\publish_qd_win.bat Release scripts\package_qd_win.bat Release

# Requires Xcode Command Line Tools # Set Qt path environment variable export ENV_QT_PATH=/path/to/Qt/6.8.3 # Build bash scripts/build_qd_mac.sh Release # Package bash scripts/publish_qd_mac.sh Release bash scripts/package_qd_mac.sh Release

If you deploy your own signaling server with API Key enabled, you can inject the API Key at build time so your clients can authenticate:

# Windows set ENV_QUICKDESK_API_KEY=your-secret-key scripts\build_qd_win.bat Release # macOS ENV_QUICKDESK_API_KEY=your-secret-key bash scripts/build_qd_mac.sh Release

Without ENV_QUICKDESK_API_KEY, the build produces an open-source client that can only connect to signaling servers without API Key protection.

WebClient note: The WebClient is a static web page running in the browser. Since API keys embedded in JavaScript are visible via DevTools, the WebClient uses Origin whitelist validation instead of API Key. Configure ALLOWED_ORIGINS on the signaling server to restrict which domains can access it. Browsers automatically send the Origin header and JavaScript cannot forge it, so only the WebClient served from your official domain will be allowed.

See Signaling Server Deployment for details.

QuickDesk supports full self-hosted deployment. You can deploy all services on your own servers to ensure data security.

1. Signaling Server (required): Handles device registration and signaling relay → Signaling Server Deployment Guide
2. TURN Relay Server (recommended): Provides relay when P2P direct connection fails → TURN Server Deployment Guide

In QuickDesk Settings → Network:

• Signaling server address: ws://your-server.com:8000 or wss://your-server.com:8000
• Custom STUN server: stun:your-server.com:3478
• Custom TURN server: turn:your-server.com:3478 (username and password required)

QuickDesk/ ├── QuickDesk/ # Qt GUI client │ ├── main.cpp # Application entry point │ ├── src/ │ │ ├── api/ # WebSocket API server + request handlers │ │ ├── controller/ # Main controller │ │ ├── manager/ # Business managers (Host/Client/Process/TURN/...) │ │ ├── component/ # Video rendering, key mapping, cursor sync │ │ ├── core/ # Config center, user data │ │ ├── viewmodel/ # MVVM ViewModel │ │ └── language/ # i18n │ ├── qml/ │ │ ├── views/ # Main window, remote desktop window │ │ ├── pages/ # Remote control, settings, about pages │ │ ├── component/ # Fluent Design component library │ │ └── quickdeskcomponent/ # QuickDesk-specific components │ ├── base/ # Base utilities │ └── infra/ # Infrastructure (database, logging, HTTP) ├── quickdesk-mcp/ # Rust MCP Bridge (stdio ↔ WebSocket) │ └── src/ │ ├── main.rs # Entry point, CLI args, MCP server startup │ ├── server.rs # MCP tools, prompts, resources │ └── ws_client.rs # WebSocket client for Qt API ├── quickdesk-agent/ # Rust host-side AI Agent (Cargo workspace) │ ├── agent/ # Agent main binary │ ├── mcp-server-common/ # Shared MCP server framework │ └── skills/ # Built-in skill MCP servers │ ├── sys-info/ # System information skill │ ├── file-ops/ # File operations skill │ └── shell-runner/ # Shell execution skill ├── SignalingServer/ # Go signaling server │ ├── cmd/signaling/ # Entry point │ └── internal/ # Business logic ├── scripts/ # Build, package, publish scripts ├── docs/ # Documentation │ ├── mcp-integration.md # MCP integration guide (English) │ └── MCP接入指南.md # MCP integration guide (Chinese) ├── .github/workflows/ # CI/CD configuration └── version # Version number 

• Windows support
• macOS support
• P2P direct connection + TURN relay
• Multi-tab multi-connection
• Auto-refresh access code
• Video performance stats overlay
• Fluent Design UI
• Light and dark themes
• i18n (Chinese / English)
• MCP Server — AI agents can control remote desktops
• 20+ MCP tools (screenshot, click, type, drag, hotkey, clipboard, etc.)
• MCP Resources & Prompts
• Host-side AI Agent with built-in skills (sys-info, file-ops, shell-runner)
• OCR-based UI analysis tools (get_ui_state, find_element, screen_diff_summary, etc.)
• Persistent MCP transport mode and AI Agent settings
• Multi-directory skills loading with user-configurable paths
• Linux support
• File transfer
• Audio streaming
• iOS / Android clients
• Unattended access
• Address book & device groups

Contributions are welcome! Please follow these guidelines:

1. Fork the repository and create a feature branch
2. Keep code style consistent with the project
3. Ensure the build passes before submitting a PR
4. Each PR should contain a single feature or fix

QuickDesk's own code is licensed under the MIT License, free for commercial use.

The bundled quickdesk-remoting component is based on Chromium and licensed under the BSD 3-Clause License.

For complete third-party license information, see THIRD_PARTY_LICENSES.

• Chromium Remoting — Remote desktop protocol core
• Qt — Cross-platform GUI framework
• spdlog — High-performance logging library
• coturn — TURN relay server