crabpilot.dev
BlogPricing
Open Source

Async MAVLink
in Rust.

Tokio-based MAVLink library with 75% MAVSDK feature coverage. ArduPilot, PX4, CrabPilot on one Vehicle API. Lock-free telemetry, mission + parameter + calibration protocols built in.

CrabLink

Diagram preview coming soon
Autopilot backends

One API. Three autopilots.

The Vehicle facade abstracts ArduPilot, PX4, and CrabPilot behind the same async Rust API. Switch autopilots without changing your application code.

ArduPilot

ArduPilot — Copter, Plane, Rover, Sub, VTOL
Shipping

Copter, Plane, Rover, Sub, VTOL. Mode tables in code, mission protocol fluent.

Full parameter + mission API

DataFlash log download

Tested in CI against every release

PX4

PX4 — 1.14+
Shipping

Copter, Plane, VTOL, Rover. Same Vehicle, different command set under the hood.

MAVLink v2 native

Calibration protocol parity

Fleet-ready

CrabPilot

Our Rust autopilot
Shipping

Our autopilot, identical handling — no special-casing in user code.

End-to-end Rust stack

Parameter metadata bundled

Same API as ArduPilot + PX4

Custom dialect

Bring your own XML or framing
On request

Bring an XML dialect or your own framing. Integration is part of the engagement.

Custom XML dialect support

Bespoke framing adapters

Scoped integration contract

Capabilities

Mission, parameter, calibration, telemetry — async, in one crate.

From raw connection management to high-level mission upload — all async, all in one crate.

Tokio async

Non-blocking I/O on every transport, single runtime.

One Vehicle, three autopilots

Same arm, takeoff, RTL, mode change — regardless of autopilot.

Mission protocol

Upload, download, current item, validation. QGroundControl .plan interchange.

Parameter protocol

Sync, set, get, file import/export, reset.

Calibration + sensors

Accel, compass, gyro, RC, ESC.

75% MAVSDK coverage

Drop-in replacement for many MAVSDK use cases.

Architecture

How it works

A layered facade — application code talks to Vehicle, the backend trait handles autopilot-specific encoding. Transport is pluggable.

Stack

1

Vehicle facade

arm, takeoff, goto, set_mode, mission_upload
2

AutopilotBackend trait

decode_mode, command_int, capabilities
3

ConnectionManager

Serial · TCP · UDP · UDP broadcast
4

mavlink crate 0.17

ardupilotmega dialect, CharArray<N> strings

Arm and take off

Works identically against ArduPilot, PX4, and CrabPilot — the backend handles the differences.

use crablink::Vehicle;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Connect over UDP (ArduPilot SITL default port)
    let mut vehicle = Vehicle::connect(
        "udp:0.0.0.0:14550"
    ).await?;

    // Wait for heartbeat and capabilities
    vehicle.wait_ready().await?;

    // Arm and take off to 10 m
    vehicle.arm(true).await?;
    vehicle.takeoff(10.0).await?;

    // Stream telemetry
    let mut telem = vehicle.telemetry();
    while let Ok(t) = telem.recv().await {
        println!("alt: {:.1} m", t.altitude_rel_m);
    }
    Ok(())
}
Use cases

Who uses CrabLink

GCS apps

Build a Tauri or Electron GCS in a weekend. CrabStation is built on it.

Automation scripts

Spin up a Tokio task, wire telemetry to your own pipeline, ship a CI test.

Fleet management

Multiple Vehicle instances over the same runtime — telemetry, missions, parameters.

Open source

Open source. Async Rust.

CrabLink is the async MAVLink backbone for the entire Crab UAV ecosystem. Add crablink to Cargo.toml and call Vehicle::connect("udp:...").

940+ tests, including SITL integration

Used by CrabStation and CrabCompanion

ArduPilot, PX4, CrabPilot — one API

Mission, parameter, calibration protocols built in

MIT licensed