QuixiAI/QuixiDesk

Source: https://github.com/QuixiAI/QuixiDesk

QuixiDesk

A Native Rust Desktop Workspace for AI — macOS, Windows & Linux

QuixiDesk is a native Rust (tao + wry) desktop workspace for macOS, Windows, and Linux, with pluggable LLM providers, built-in MCP tools, and a unified task/chat workspace. Its native host runs without an Electron or Node.js application runtime.

Screenshots

QuixiDesk 3.6556.9 on macOS, captured from the running app with an isolated demo profile. The fictional Campus Makers Club conversation and model catalog are sample data.

Start a task

Work through a conversation

Choose a model

Keep project context together

Schedule recurring work

Appreciation & Credit: REA (morluto/rea)

Special appreciation goes to REA — Reverse Engineer Anything (github.com/morluto/rea).

The native runtime development and analysis benefited from REA. If you are analyzing native binaries, Electron/JavaScript bundles, mobile packages, or complex runtime protocols, check out and star https://github.com/morluto/rea.

Key Features

• Native Rust Runtime (Zero Electron / Node.js Overhead): Built on tao + wry with a custom app://localhost protocol router (quixi-app, quixi-ipc, quixi-engine, quixi-workspace, quixi-platform, quixi-mcp, quixi-netstack).
• Unified Workspace: Attach local folders, choose file modification permissions, and run multi-turn streaming sessions in one view.
• Built-In In-App Browser Use & Computer Use (Out of the Box):
  • In-App Browser: Opens a docked browser pane inside QuixiDesk with multi-tab navigation, isolated page snapshots, and interactive [ref_N] accessibility element inspection.
  • Computer Use: Native macOS CoreGraphics screen capture, cursor control, keyboard/mouse synthesis, and window inspection (44 tools active out of the box).
  • Built-in and external MCP tools: Workspace files, Git, shell, desktop/browser automation, memory, fetch, and macOS AppleScript adapters. External servers use persistent stdio, Streamable HTTP, or SSE connections with real discovery, readiness, OAuth, and actionable errors. See the MCP guide.
• Original Interface: System typography, light and dark themes, keyboard navigation, and responsive layouts. The replacement interface currently uses English.

Select a workspace folder before sending a file task. Manual allows directory listings and file reads, then pauses for approval before changes or commands. Allow once approves the displayed action; Allow file edits permits edits in that conversation while commands continue to ask. Auto permits tool actions without individual approval. Approving an action resumes the current request.

Projects bring instructions, folders, conversations, and related artifacts and schedules together on one page. Tasks started from a project inherit its instructions and selected folder; personal and project drafts stay separate. A conversation without a selected folder has no workspace file tools—choose a folder when it needs to read or change local files.

In a project, Manage folders → Add folder opens the native folder chooser on macOS. Enter path also accepts home-folder shortcuts such as ~/Projects/my-project, paths with spaces, and quoted paths copied from your file manager.

Attachments support PNG, JPEG, GIF, WebP, and UTF-8 text files: up to 8 files per message, 5 MiB per image, 1 MiB per text file, and 20 MiB combined. Images require a vision-capable model. Loading and failed attachments remain visible; fix or remove failures before sending. PDF and Office document ingestion is not supported. Unsent attachments are held in memory and do not survive an app restart.

Edit and Retry create a new conversation branch, preserving the original transcript and a link back to it. Stop an active task before branching.

Tool calls and their results appear together in a collapsible activity group. Stop cancels pending approvals and preserves any answer text already received. Follow-up requests retain earlier tool results, and artifact revisions can update the existing preview without changing its link.

Use Search to find conversation titles and messages, project names and instructions, artifact metadata, and schedule names and prompts. Filter by category or include archived conversations. Within a conversation, Find in conversation (Cmd/Ctrl+F) highlights matches; Enter/Shift+Enter or Cmd/Ctrl+G moves between them. Screenshot tool results appear as images and are forwarded to vision-capable models through the OpenAI-compatible and OpenAI OAuth tool paths. Fresh screenshot requests capture fresh observations.

Artifacts has a searchable, sortable gallery with pinning, preview and source views, duplication, and revision restoration. Export HTML saves a local file without overwriting an existing filename; Continue in chat lets you refine the artifact. Artifacts are stored locally; cloud publishing and synchronization are not provided.

In Tools & skills, use Add connection to configure an MCP server through a form, or Advanced JSON for direct configuration. Connections can be edited, enabled, disabled, and removed individually. Search installed skills, read their instructions, or choose Try in a new task to prepare a prompt with the skill files attached for review before sending.

Settings → Application & audio shows the installed version, storage status, keyboard shortcuts, and available audio features. Read-aloud and in-app dictation depend on the system webview’s speech services; dictation may require microphone permission and an online service. When in-app recognition is unavailable, use your operating system’s dictation in the prompt.

Stop terminates running Bash command trees. Commands have a 120-second default timeout; a task can request up to one hour. Manual and Allow file edits modes ask before file access outside the selected workspace, including symlink targets. Auto mode grants broader access; these approvals are not an operating-system sandbox.

Long conversations automatically summarize older provider context near the model’s context budget while keeping the original transcript. Tasks can run up to 100 tool rounds, with an explicit wrap-up at the limit. The summary is model-generated and may be imperfect; if compaction fails, the app preserves the conversation and reports the problem.

Subagents handle bounded parts of a request with their own saved activity. The parent supplies an explicit assignment and receives a short result; child tool chatter stays in the expandable Subagents panel. Children inspect files by default. Delegated edits and commands use the conversation’s current permissions, and approval cards identify the requesting child. Stop cancels the parent and its children. Interrupted children remain visible after restart and are never automatically replayed. See Subagent design for limits and provider behavior.

Schedules offer daily, weekday, weekly, hourly, and custom five-field cron schedules, with next-run previews in the computer’s local time zone. Context & permissions selects the project, folder, model, and approval mode. Automatic runs require QuixiDesk to remain open. The app reports missed times and skips catch-up runs; it also skips overlapping runs of the same schedule. Run now starts a conversation immediately without moving the next scheduled occurrence, and View last run opens it. Run states distinguish work in progress, pending approval, completion, failure, and interruption. Existing definitions from older builds need to be enabled or saved once to activate automatic dispatch. Manual-mode runs still wait for tool approvals.

Provider credentials are encrypted with AES-256-GCM; the encryption key is held in macOS Keychain, Windows Credential Manager, or the Linux Secret Service. Linux needs an unlocked desktop secret service (such as GNOME Keyring or KWallet with Secret Service support). Existing plaintext provider settings migrate on successful unlock/save. If unlocking or saving fails, the existing file is preserved and the app reports the error. Disposable test profiles use a separate local test key and must not contain production credentials.

Supported LLM Providers

QuixiDesk includes a built-in Provider Manager (open Settings → Providers) supporting cloud, OAuth, and local inference providers:

Configure the endpoint and credentials, then save. QuixiDesk loads all models advertised by the provider’s /models endpoint; no model ID is required during setup. Use the chat model picker to search, select, or refresh the catalog. Custom Endpoint and OpenRouter also support adding exact IDs for unadvertised models without replacing the discovered list.

Priority Providers

Cloud Providers

Local Zero-Key Providers (Auto-Detected)

Installation & Build Instructions

QuixiDesk uses the system webview: WKWebView on macOS, WebKitGTK on Linux, and WebView2 on Windows. Build on the target OS with the current stable Rust toolchain from rustup and Git. The lockfile is checked in; use --locked for reproducible dependency selection. Node.js and Electron are not required to build or run the checked-in application.

The original interface, bootstrap defaults, icons, and task instructions are checked in under resources/. Keep that directory with the application. Build directly from the repository; no extracted application bundle or external renderer is required. Regenerate the skill archives with python3 scripts/package-bundled-skills.py after editing their sources.

Clone using HTTPS (or your configured Git SSH credentials):

git clone https://github.com/QuixiAI/QuixiDesk.git
cd QuixiDesk

macOS

Use macOS 14 or later for the documented build/test setup (Apple Silicon or Intel). Install Apple’s command line tools and Rust:

xcode-select --install
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Open a new terminal after installation, then enter the checkout.
rustup update stable
cargo build --locked --release --workspace
./target/release/QuixiDesk

To create a relocatable, ad-hoc signed app bundle:

./scripts/package-macos-app.sh
open dist/QuixiDesk.app
# Optional installation; quit any existing QuixiDesk instance first.
cp -R dist/QuixiDesk.app /Applications/

make app and make install are shortcuts for packaging and installation. QUIXI_APP_SYMLINK_RESOURCES=1 make app links resources for local iteration; use the default copied resources when distributing a bundle. Screen recording, Accessibility, and Automation access for native computer-use tools are granted through macOS System Settings when needed.

Linux (Debian / Ubuntu)

Install the GTK 3 and WebKitGTK 4.1 development packages described by Wry’s platform notes:

sudo apt update
sudo apt install build-essential pkg-config libgtk-3-dev libwebkit2gtk-4.1-dev curl git
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Open a new terminal after installation, then enter the checkout.
rustup update stable
cargo build --locked --release --workspace
./target/release/QuixiDesk

Run from an active graphical login with a working session D-Bus and Wayland or X11 display. A plain SSH session without a display is insufficient for normal desktop use. For a dedicated X11 test display, set GDK_BACKEND=x11; GTK container construction supports both X11 and Wayland. Native build and isolated app tests have been exercised on Ubuntu 26.04 x86_64.

For a portable install, copy the executable, helpers, and resources together:

mkdir -p "$HOME/.local/opt/QuixiDesk"
cp target/release/QuixiDesk target/release/quixi-* "$HOME/.local/opt/QuixiDesk/"
cp -R resources "$HOME/.local/opt/QuixiDesk/resources"
QUIXI_RESOURCES_DIR="$HOME/.local/opt/QuixiDesk/resources" "$HOME/.local/opt/QuixiDesk/QuixiDesk"

The destination machine needs GTK 3 and WebKitGTK 4.1 runtime libraries. Build on a compatible Linux distribution; this is not a universal static binary or an AppImage.

Windows 10 / 11 (native, PowerShell)

Install Git, Rust for Windows, and Visual Studio C++ Build Tools with the Desktop development with C++ workload and a Windows SDK. Use the MSVC Rust toolchain, not the GNU or WSL toolchain. Install the Microsoft Edge WebView2 Evergreen Runtime if it is not already present. Reopen PowerShell after installation so Cargo and Git are on PATH.

From the checkout:

rustup update stable-msvc
rustup default stable-msvc
cargo build --locked --release --workspace
.\target\release\QuixiDesk.exe

Use a Windows desktop session for normal app interaction. SSH can build and run automated storage tests, but does not provide an interactive desktop. Native shell tools use cmd.exe with AutoRun disabled; browser fetching uses Windows’ System32\curl.exe (included in the tested Windows 10 22H2 installation).

For a portable install, copy the binaries and resources into a user-owned folder:

$install = Join-Path $env:LOCALAPPDATA 'Programs\QuixiDesk'
New-Item -ItemType Directory -Force $install | Out-Null
Copy-Item .\target\release\*.exe $install
Copy-Item .\resources (Join-Path $install 'resources') -Recurse -Force
$env:QUIXI_RESOURCES_DIR = Join-Path $install 'resources'
& (Join-Path $install 'QuixiDesk.exe')

There is no MSI or Windows signing/installer workflow yet. Keep the resources directory available; QUIXI_RESOURCES_DIR explicitly selects it when launching outside the source checkout.

Platform scope and configuration

Native CoreGraphics/AppleScript computer-use integration is macOS-specific. Linux and Windows builds do not currently provide the same native computer-use and folder-picker capabilities. Building the cross-platform shell does not imply full native-feature parity.

QUIXI_WORKSPACE overrides the engine’s development workspace default, which otherwise uses the source checkout. This does not grant folderless conversations access to that directory: choose a folder in the composer or start a task from a project with a configured folder. QUIXI_RESOURCES_DIR overrides resource discovery. Normal app data is stored under the OS user’s .quixi directory; test profiles below use a separate location. Configure a provider in the app after launch; no API credential is required to compile or run the tests.

Tests and disposable account profiles

Run the workspace tests with a disposable app profile. On macOS/Linux:

QUIXI_TEST_PROFILE="$(mktemp -d)" cargo test --locked --workspace
./target/release/QuixiDesk --test-profile /tmp/quixi-qa-profile
# Optional complete account bootstrap fixture:
./target/release/QuixiDesk --test-profile /tmp/quixi-qa-profile --mock-account /absolute/path/mock-account.json

On Windows, preserve any existing test-profile setting while running tests:

$previousProfile = $env:QUIXI_TEST_PROFILE
$env:QUIXI_TEST_PROFILE = Join-Path $env:TEMP ('quixi-unit-' + [guid]::NewGuid())
try { cargo test --locked --workspace } finally { $env:QUIXI_TEST_PROFILE = $previousProfile }
$profile = Join-Path $env:TEMP 'quixi-qa-profile'
.\target\release\QuixiDesk.exe --test-profile $profile
# Optional: append --mock-account C:\absolute\path\mock-account.json

The first profile launch creates mock-account.json with a synthetic account. Its account object requires a UUID and memberships array; current_user_access and featureFlagsOrgUuid can also be supplied. Providers start unconfigured and are saved separately. The profile contains data/, home/, workspace/, and independent web storage. QUIXI_TEST_PROFILE is the equivalent environment option for launching a separate test bundle. QUIXI_AUTOMATION_PORT selects its automation port (test default: 19456; normal default: 19455); use distinct ports for concurrent profiles. macOS test web-store isolation requires macOS 14+. This isolates app/account state, not OS permissions or tool filesystem/network access. No OS HOME override or real account credential copy is needed.

Conversation records are saved atomically. If the usual session folder is unavailable, QuixiDesk keeps a recovery snapshot under the app data directory’s recovery/ folder and restores it on restart. A persistent notice offers Retry saving and Copy recovery data for affected conversations. If both save locations fail, keep the app open: normal Quit and window close are blocked until a durable save succeeds. A force kill or power loss can still lose data held only in memory.

After building on Windows, run the targeted storage integration test:

powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\test-windows-storage.ps1

It launches the native WebView2 app with a fresh profile, obstructs only fixture save paths, verifies recovery and restart, exercises Retry saving, and checks allowed/blocked native close events. It leaves its JSON results and logs in a newly created temporary directory and restores the caller’s environment. This is an automated app-bridge test; manual desktop checks remain separate.

The original interface has a separate development-only Node.js test suite. Node.js is not needed by the production app:

npm ci --prefix tests/ui
node --test tests/ui/*.test.cjs
python3 scripts/audit-product-assets.py

The asset audit rejects imported branding and private font bundles and checks the integrity of redistributable artifact libraries and their licenses. The UI tests cover drafts, attachments, conversation branches, streaming, tool failures, project context, search, schedules, MCP connection forms, sandbox attributes, and concurrent updates; they do not replace native desktop or browser security testing.

Native desktop validation and the full E2E catalog remain separate from the automated regression checks.

On Linux, after a release build, run real WebKit frame isolation and navigation checks with python3 scripts/test-linux-ui.py (requires xvfb-run, dbus-run-session, and Python 3). It starts only a local fixture server and disposable profile and records its JSON results in a temporary directory. --output and --port select an evidence directory and unused automation port.

The E2E test suite design defines the proposed full packaged-app suite, fixtures, isolation requirements, and CI rollout; its full runner is not implemented yet.

Workspace Architecture

QuixiDesk/
├── crates/
│   ├── quixi-app/        # Native tao + wry WKWebView shell, custom app:// protocol & original UI
│   ├── quixi-ipc/        # Desktop service and event router
│   ├── quixi-engine/     # Session orchestrator, multi-provider LLM router & streaming engine
│   ├── quixi-mcp/        # Persistent MCP clients, discovery, OAuth, and built-in adapters
│   ├── quixi-platform/   # macOS CoreGraphics Computer Use, In-App Browser Use & SafeFS sandbox
│   ├── quixi-workspace/  # Native file indexer, git pool engine, transcript search & PTY shell host
│   ├── quixi-netstack/   # Egress policy & credential management
│   ├── quixi-proto/      # Shared EIPC protocol types and channel parser
│   └── quixi-guest-daemon/ # VM guest vsock/virtio daemon
├── bins/
│   ├── quixi-mcp-builtin/        # Standalone stdio MCP server (--computer-use / --browser-use)
│   ├── quixi-chrome-native-host/ # Native messaging host for browser extension bridge
│   ├── quixi-disclaimer/         # TCC permission disclaimer helper
│   └── quixi-ssh-askpass/        # Native SSH askpass helper
└── resources/            # Bundled UI assets, original interface, bootstrap defaults, icons & skills

License

Released under the MIT License.