QuickDesk

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

English | 中文

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

Why QuickDesk?

AI-First: The Only Remote Desktop with MCP Support → MCP Integration Guide

Built-in MCP Server: AI agents connect via standard MCP protocol — no plugins, no hacks, zero configuration
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

High-Performance Foundation

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

Comparison

Feature	QuickDesk	RustDesk	BildDesk	ToDesk	TeamViewer
AI Agent Support (MCP)	✅ Built-in	❌	❌	❌	❌
Open Source	✅ MIT	✅ AGPL-3.0	❌	❌	❌
Free for Commercial Use	✅	❌ License required	❌	❌	❌
Core Language	C++	Rust + Dart	—	—	—
Remote Protocol	Chromium Remoting (WebRTC)	Custom	Custom	Custom	Custom
Protocol Maturity	⭐⭐⭐⭐⭐ Google 10yr+	⭐⭐⭐	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
P2P Direct	✅ WebRTC ICE	✅ TCP Hole Punching	✅	✅	✅
Video Codecs	H.264/VP8/VP9/AV1	VP8/VP9/AV1/H.264/H.265	—	—	—
Self-Hosted	✅ Full solution	✅	❌	❌	❌
GUI Framework	Qt 6 (C++)	Flutter (Dart)	—	—	—
Memory Usage	⭐⭐⭐⭐⭐ Very Low	⭐⭐⭐ Medium	—	⭐⭐⭐	⭐⭐⭐
CPU Usage	⭐⭐⭐⭐⭐ Very Low	⭐⭐⭐ Medium	—	⭐⭐⭐	⭐⭐⭐
Windows	✅	✅	✅	✅	✅
macOS	✅	✅	✅	✅	✅
Linux	🔜	✅	❌	✅	✅
iOS/Android	🔜	✅	✅	✅	✅

Why Best-in-Class Performance?

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.
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.
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.
GPU-Accelerated Rendering: YUV data is fed directly into the GPU rendering pipeline via Qt 6's QVideoSink, achieving zero-CPU-copy video rendering.

Features

AI Integration (MCP Server)

Built-in MCP Server — AI agents connect via standard protocol, works with Cursor, Claude Desktop, and any MCP client
20+ remote control tools: screenshot, mouse click/drag/scroll, keyboard type/hotkey, key press/release, clipboard read/write, screen size query
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, performance stats
Background automation mode: show_window=false for headless batch operations
Screenshot scaling: adjustable resolution for faster AI processing

Remote Control

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)

Connection Management

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

Performance 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

Personalization

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

Self-Hosted Deployment

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

Architecture

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"]
    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
    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

Tech Stack

Layer	Technology
AI Integration	MCP Server (Rust) + WebSocket API
GUI Client	Qt 6 (QML + C++17)
UI Style	Fluent Design Component Library (custom-built)
Remote Protocol Core	Chromium Remoting (C++)
Video Codecs	H.264 / VP8 / VP9 / AV1
Network Transport	WebRTC (ICE/STUN/TURN)
IPC	Native Messaging (JSON) + Shared Memory
Signaling Server	Go + Gin + GORM
Data Storage	PostgreSQL + Redis
TURN Relay	coturn
Logging	spdlog
Build System	CMake 3.19+
CI/CD	GitHub Actions

Getting Started

Download

Go to Releases to download the latest version:

Platform	Download
Windows x64	QuickDesk-win-x64-setup.exe
macOS ARM64	QuickDesk-mac-arm64.dmg

Usage

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

Build from Source

Requirements

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

Windows

# 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

macOS

# 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

API Key (Optional)

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.

Self-Hosted Deployment

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

Components

Signaling Server (required): Handles device registration and signaling relay
TURN Relay Server (recommended): Provides relay when P2P direct connection fails

For a detailed deployment guide, see Signaling Server Deployment.

Client Configuration

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)

Project Structure

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
├── 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

Roadmap

Contributing

Contributions are welcome! Please follow these guidelines:

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

License

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.

Acknowledgments

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

Name		Name	Last commit message	Last commit date
Latest commit History 210 Commits
.github/workflows		.github/workflows
QuickDesk		QuickDesk
SignalingServer		SignalingServer
WebClient		WebClient
cmake		cmake
docs		docs
examples		examples
quickdesk-mcp		quickdesk-mcp
scripts		scripts
.gitignore		.gitignore
CMakeLists.txt		CMakeLists.txt
LICENSE		LICENSE
README.md		README.md
README_zh.md		README_zh.md
THIRD_PARTY_LICENSES		THIRD_PARTY_LICENSES
version		version

Folders and files

Latest commit

History

Repository files navigation

QuickDesk

Why QuickDesk?

AI-First: The Only Remote Desktop with MCP Support → MCP Integration Guide

High-Performance Foundation

Comparison

Why Best-in-Class Performance?

Features

AI Integration (MCP Server)

Remote Control

Connection Management

Performance Monitoring

Personalization

Self-Hosted Deployment

Architecture

Tech Stack

Getting Started

Download

Usage

Build from Source

Requirements

Windows

macOS

API Key (Optional)

Self-Hosted Deployment

Components

Client Configuration

Project Structure

Roadmap

Contributing

License

Acknowledgments

Star History

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 7

Packages 0

Uh oh!

Contributors 1

Languages

Packages