ADOSMissionControl

ADOS Mission Control

Open-source ground control station for software-defined drones. ArduPilot, PX4, Betaflight and iNav, in the browser.

Mission Control | Drone Agent | Android GCS | Extensions | MCP | Rust crates | Docs | Website | Discord

Live App · Changelog · Contact · Issues

https://github.com/user-attachments/assets/09f265f4-b692-468a-a170-2be2d8525ae7

ADOS Mission Control is the ground control station of ADOS, an open-source platform for software-defined drones. Open it in a browser, connect a flight controller, and you can set it up panel by panel, plan a mission with pattern generators, fly it with a gamepad at 50 Hz and tune PIDs with AI help. No install. No locked hardware.

On its own it talks to any MAVLink or MSP flight controller over USB or WebSocket. Pair it with an ADOS Drone Agent on the drone’s companion computer and it becomes the one place you run the whole aircraft: the flight controller, the long-range radio and HD video link, onboard vision, swarm settings, World Engine (in beta) and every extension you install.

Quick Start

Try it right now at command.altnautica.com. No install needed. Demo mode loads simulated drones with live telemetry, mission planning, and full FC configuration.

Or run locally:

git clone https://github.com/altnautica/ADOSMissionControl.git
cd ADOSMissionControl
npm install
npm run demo

Open http://localhost:4000. Simulated drones, no hardware required.

Features

Plan missions in 3D over real terrain. Docs	Fly from the cockpit with live video and a gamepad. Docs
Rehearse a mission on a Cesium globe before you fly it. Docs	Generate survey, orbit, corridor and search patterns. Docs
See every drone and node on one dashboard. Docs	Edit waypoints with a terrain profile and validation. Docs
Manage paired drones and ground nodes. Docs	Search, edit and write every FC parameter. Docs
Set up the flight controller panel by panel. Docs	Connect an AI client through the MCP wizard. Docs

What it lets you do

• Connect to any drone, no driver install. Plug in over USB (WebSerial), point at a MAVLink WebSocket, or pair with an ADOS agent over your LAN.
• Set up the whole flight controller. More than 80 panels cover calibration, PID tuning, receivers, outputs, failsafe, power, ports, OSD, firmware flashing, and the iNav-specific surfaces.
• Plan a mission by drawing it. Drop waypoints on the map, generate survey, orbit, corridor, SAR, and structure-scan patterns, follow terrain, set geofences and rally points, then validate before upload.
• Fly with a real controller. Gamepad, HOTAS, RC transmitter, or keyboard at 50 Hz, with arm/disarm, mode switching, guided flight, and a kill switch.
• Rehearse in 3D. Replay a mission over real terrain on a Cesium globe before you fly it.
• Tune PIDs with help. FFT-driven noise and motor-health analysis suggests filter settings and PID values.
• Manage a fleet from anywhere. Cloud mode adds multi-drone dashboards, mission sync, and real-time telemetry over MQTT.
• Sign your commands. HMAC-SHA256 on every outbound MAVLink v2 frame, with the key held only in your browser.
• Self-host all of it. Field operations work fully offline, and the cloud relay can run entirely on your own servers.

One system with the Drone Agent

Open a drone that runs the ADOS Drone Agent and Mission Control shows the flight controller and the companion computer as one node:

• Vehicle. Flight controller setup and the full parameter editor, carried over MAVLink by the agent, including drones reached through a ground station’s radio relay.
• Agent. Health with per-service restart and the connected peripherals, battery and profile, the radio link and its setup, networking (Wi-Fi, cellular, MAC pinning, discovery, MAVLink routing and signing), cameras and perception, swarm, cloud relay, security and advanced settings.
• Extensions. Install and update plugins from the same panel. An extension can add its own pages there, the way World Engine adds its world model and perception offload pages.
• Logs. Flight logs and the agent’s on-board recorder.

Smart and autonomous features

• Cockpit skills. The Skill Bar puts flight skills one tap away: take off, land, return home, pause, resume, fly here, change mode and abort. Extensions add their own, such as Follow-Me, which follows a subject you click in the live video.
• Swarm view. A fleet board with a map, a video rail and bulk actions, including formation commands. Per-drone swarm settings drive the agent’s onboard swarm layer, and each drone reports which layer is in control right now.
• World Engine (beta). Start a capture, watch the 3D world model build, then open it as a Gaussian splat, a point cloud or a Rerun recording, next to the compute node’s job queue and the perception offload settings.
• Vision and perception. Camera and perception pages for the agent’s onboard vision, and Vision Navigation for GPS-denied flight on optical flow, with its estimator state and pre-arm status.
• AI that helps, and AI that operates. AI PID tuning suggests filter and PID values from your flight data. The MCP wizard connects an AI client to your drones through ADOS MCP, under scopes you grant and behind a safety gate.

These features are under active development and grow with every release; build on them through extensions and the SDK.

What you can build on it

ADOS is a base, not a finished product for one job. These are directions it is built toward, with the pieces that exist for them today:

• Smart agriculture. Survey and terrain-following missions planned here, RTK corrections the agent injects into the flight controller, and payload devices such as sprayers or droppers that extensions can register.
• Indoor operations. GPS-denied flight on optical flow with Vision Navigation, and visual-inertial or LiDAR SLAM poses with indoor world models from World Engine (beta).
• Logistics in GPS-denied warehouses. The same positioning sources, a warehouse reconstruction preset in World Engine, and perception offload so a drone without an NPU can run detection on a nearby compute node.

The parts are open, so you can take them where you need them.

Build on it

ADOS is meant to be extended. An extension has a Mission Control half (React panels in a sandboxed frame) and a Drone Agent half (Python or Rust), packed into one signed archive. Start from ADOS Extensions and the developer docs. Rust plugins build on the ados-sdk crate. Pull requests to Mission Control itself are welcome; see Contributing.

Where it fits

Mission Control is the browser and desktop ground station of the ADOS ecosystem. It reaches the Drone Agent over your LAN or the cloud relay, and a ground node running the Ground Agent profile when the drone is out on the long-range radio link. Android GCS flies the same drones from a phone or tablet, Extensions add panels here and code on the drone, ADOS MCP gives AI clients scoped access to the same agents, and the agent’s reusable code ships as published Rust crates.

How ADOS fits together

ADOS Ground Agent is the Drone Agent running its ground-station profile.

ADOS Rust crates

Reusable libraries from the ADOS Drone Agent, published on crates.io. Versioning and licences: crates index.

Platform (versioned with the ADOS Drone Agent)

Standalone

What ADOS Mission Control Is

• Platform: Browser-based. Runs on any OS with a modern browser. Optional Electron desktop build for WebSerial and WebUSB access.
• Firmware: ArduPilot, PX4, Betaflight, and iNav as first-class targets.
• Protocol: MAVLink v2 and MSP v1/v2 in the same app, behind a unified DroneProtocol adapter interface.
• Flight control: Gamepad, HOTAS, RC transmitter, or keyboard input at 50 Hz.
• AI tuning: PID and filter analysis with FFT-driven noise and motor-health diagnosis.
• 3D simulation: CesiumJS globe with real terrain and flight path replay.
• Fleet mode: MQTT and Convex relay for multi-drone dashboards. Self-hostable end to end.
• License: GPL-3.0-only.

The browser side is TypeScript. The onboard agent it pairs with, ADOS Drone Agent, is Rust-first, which is what carries the long-range link, HD video, and headless operation on small boards.

What It Does

Configure your flight controller

More than 80 panels covering calibration, PID tuning, receiver, outputs, failsafe, power, ports, OSD, firmware flashing, plus iNav-specific panels for safehomes, geozones, navigation config, profiles, output mapping, servos, temp sensors, MC braking, rate dynamics, and mission summary. Works with ArduPilot, PX4, Betaflight, and iNav. AI PID tuning analyzes FFT noise and motor health, then suggests filter settings and PID values. Board auto-detection for firmware flashing. WebUSB firmware flashing with no external tools.

Plan missions

Drag waypoints on an interactive map. Pattern generators for survey (boustrophedon), orbit, corridor, SAR (expanding square, sector, parallel track), structure scan, plus automated landing approaches. Terrain following from the open Terrain Tiles dataset. Geofence editor, rally points, batch waypoint editing, and mission validation before upload. Import and export KML, KMZ, CSV, .waypoints, .plan.

Fly and simulate

Gamepad, HOTAS, RC transmitter, or keyboard input at 50 Hz. Arm/disarm, mode switching, guided flight, mission execution, kill switch. 3D Cesium globe simulation with real terrain, flight path replay, and camera presets.

Monitor telemetry

Real-time attitude, GPS, battery, EKF status, vibration, RSSI, and sensor health. Pre-arm check visualization. Alert feed from the flight controller. Ring-buffered stores keep memory bounded across long sessions.

Sign MAVLink commands

HMAC-SHA256 on every outbound MAVLink v2 frame. The 32-byte key lives only in your browser as a non-extractable Web Crypto key, and is enrolled with the flight controller once via SETUP_SIGNING. Flip require mode from the Configure tab Security panel to make the flight controller reject any unsigned command. ArduPilot 4.0 and newer supported today. See docs.

Connect locally or over the cloud

ADOS is local-first. In field mode the GCS talks directly to hardware over WebSerial or WebSocket, or to an ADOS agent over the LAN by hostname or IP, with no cloud account. Cloud mode adds fleet management, mission sync, and MQTT telemetry relay for reaching drones across networks. When paired with ADOS Drone Agent, the GCS receives live telemetry at 2 Hz and faster and can send commands through the relay.

Manage a ground station

When the paired agent runs in the ground-station profile, the node panel shows role-gated surfaces instead of the flight tabs: Network (uplink priority across WiFi, ethernet, and cellular, plus access-point management), Distributed RX (single-node link stats, relay list, combined stream stats), Mesh (batman-adv health, neighbors, gateways, and the pairing accept window), Display and Physical UI (OLED screens and button mappings), and Peripherals (connected USB and GPIO hardware). A role badge in the top bar shows at a glance whether a node is running as direct, relay, or receiver, and mesh events surface as non-blocking toasts.

Firmware Support

By the Numbers

98 top-level Zustand stores. 87 flight-controller panels. Full demo mode with zero setup.

Platform Support

3D features (simulation, terrain rendering) benefit from a dedicated GPU. Works without one, but frame rates will be lower.

External Services

All optional. The GCS works fully offline for local FC configuration and field operations.

Tech Stack

Deployer (ados-deploy)

The stack ships with a full-screen terminal deployer that self-hosts the whole cloud stack (Convex + Mission Control + MQTT + video relay) in one guided flow, and also runs the web GCS, builds the desktop app, and manages a running stack.

# One-line convenience (clones the repo if needed, then launches the TUI):
curl -sSL https://raw.githubusercontent.com/altnautica/ADOSMissionControl/main/tools/deploy/deploy.sh | sh

# Local-first, from a checkout:
npm run deploy                    # interactive menu
npm run deploy -- deploy          # deploy the self-hosted stack (wizard)
npm run deploy -- deploy --plan   # preview the exact commands + files, run nothing
npm run deploy -- status          # a running stack's containers + reach links

The interactive menu covers: deploy the stack, manage a running stack (status / logs / restart / upgrade / teardown), run the web GCS (dev), run demo mode, build / run the desktop app, a system check, and the drone-agent install one-liner. The primitive npm scripts (dev, demo, build, desktop:*, convex:*) are what the deployer shells out to.

Prerequisites: Docker (with the daemon running) + Node 20+. See SELFHOSTING.md for the full self-host walkthrough.

Connecting to Hardware

WebSocket: Connect to any MAVLink-over-WebSocket endpoint. Launch ArduPilot SITL with the bridge tool from tools/sitl/ (cd tools/sitl && npm run setup && npm start).

WebSerial (USB): Plug in your FC, open Mission Control in Chrome 89+, click connect, pick the port. No drivers needed.

ADOS agent (LAN): Add a node by hostname or IP. Mission Control pairs with the agent directly over the local network. No cloud account required.

Desktop App

npm run desktop:build:mac   # macOS .dmg
npm run desktop:build:win   # Windows .exe installer
npm run desktop:build:linux # Linux .AppImage

macOS: the app is not code-signed yet, so right-click it, choose Open, then Open again.

Self-Hosted Web Server

A multi-stage Dockerfile ships at the repo root for running Mission Control as a long-lived web server (instead of the desktop app or local dev). Node 22 alpine base, Next.js standalone output, runs as an unprivileged user.

docker build \
  --build-arg NEXT_PUBLIC_CONVEX_URL=https://your-convex.example \
  -t ados-mission-control .

docker run -d \
  -p 4000:4000 \
  -e NEXT_PUBLIC_CONVEX_URL=https://your-convex.example \
  --restart unless-stopped \
  --name mission-control \
  ados-mission-control

Open http://localhost:4000.

About NEXT_PUBLIC_* variables: these get baked into the client JS bundle at build time. Pass them as --build-arg to docker build AND as -e to docker run (the runtime version is used by server components and route handlers). The Dockerfile declares each NEXT_PUBLIC_* as ARG plus ENV so build args propagate.

Container orchestrators and PaaS: the image works with anything that can build a Dockerfile. Point your tool at this repo, set the build pack to Dockerfile, expose port 4000, and configure the env vars above. No special framework integration is needed.

Fronting with HTTPS: the container serves plain HTTP on port 4000. Terminate TLS at any reverse proxy (Caddy, nginx, Traefik) or tunnel (Cloudflare Tunnel, Tailscale Funnel, ngrok). When fronting with a tunnel, route to 127.0.0.1:4000 rather than localhost:4000, since the standalone server binds IPv4 only.

For self-hosting the supporting cloud relay (Convex, MQTT, and video relay), see SELFHOSTING.md.

Backend and Cloud Features

Field mode works with no backend. Cloud features need a Convex deployment:

npx convex init
npx @convex-dev/auth
npx convex dev

Set NEXT_PUBLIC_CONVEX_URL in .env.local. The first user to sign up becomes admin.

For self-hosted MQTT and video relay, run npm run deploy -- deploy for a guided wizard (port selection, conflict detection, config file generation, optional service start), or follow the manual steps in SELFHOSTING.md. Broker assets: tools/mqtt-bridge/; relay source: tools/video-relay/.

Environment variables (.env.local)

All variables are optional. Set them by editing .env.local directly (or re-run the deployer). The file is gitignored and never committed.

Tools

Community

• Discord - Join the community, ask questions, share builds
• LinkedIn - Follow company updates
• Email - [email protected]
• Changelog - What shipped and when
• GitHub Issues - Bug reports and technical discussions

Contributing

See CONTRIBUTING.md for the full guide. Good areas to start: real iNav 7.x hardware testing, map-based polygon geozone drawing, a dedicated iNav nav-PID panel, Betaflight hardware testing, new board profiles, UDP transport, unit tests, pattern generators.

npm run demo   # Test against simulated drones
npm run lint   # Must pass before PR

License

GPL-3.0-only. Copyright 2025-2026 Altnautica. Free to use, modify, and distribute; modified versions you distribute must also be GPL-3.0.