Skip to content

Releases

0.66.0

Choose a tag to compare

@github-actions github-actions released this 19 Nov 20:51

Altnautica Command v0.66.0

This release covers 106 commits from 2026-11-14 to 2026-11-20, since 0.65.0.
Three threads run through it.

The first is the cockpit working with the agent's onboard pilot. A take-off
goes through the pilot's launch and shows the steady take-off on the launch
strip, the flight-state chip names the speed profile, a late stick and the
limit that cut the commanded speed, a position the drone cannot vouch for
reads red, a mission that stops making progress gets a stall card, and a
confined place class keeps a wall margin from the planner to the send dialog.
Controller-free flight has its groundwork: a No controller chip, a per-tab
pilot stream that ends in the link-loss action when the tab freezes, and
controller rumble and light bar driven by one shared rule table.

The second is the extension split. Capture, Reconstruct and Navigation are
separate extensions, the new Map tab draws Navigation's live map in 2D and 3D
and joins the Reconstruct compute node's live stream, and Follow Me gains its
recovery phases, quick settings on the rail and the standoff and height floors
of follow-me 0.5.

The third is the ground station: a ground station agent on the operator's
own computer is reachable from the hosted page, and the Radio tab shows which
ground holds the uplink and takes it back from a phone.

Added

  • Map tab: while the map's placement is stream, Mission Control reads the drone's live stream on its Reconstruct compute node (/api/plugins/com.altnautica.reconstruct/x/ws/live/<drone>, the node the drone's Capture readiness names): the node's occupancy tiles join the live map and its sweep points draw over the 3D view, and the status card names the compute node and whether its stream is live, connecting or not reachable from this browser. A closed stream is dialled again every 2 s. Demo: the demo drone streams to the demo workstation. New dependency @msgpack/msgpack for the stream's framing.
  • Flight-state chip: while a skill, a goto or the sticks fly, the secondary line says which limit cut the commanded speed, from the pilot's command.limits ("Slowed: obstacle", "Slowed: sensor range", "Stopped: obstacle", ...), as the agent's cockpit does.
  • Map tab: shown while the drone's Navigation extension publishes a live map, with a 2D and a 3D view. 2D is the local-frame map with the map.overlay slot over it, so an extension layer (Capture's coverage) renders in the map's frame; 3D is Navigation's live sweep cloud (/navigation/sweep), coloured by height, with the drone's pose. The status card reads Navigation's map status: placement, memory, voxel size, sweep points, area, the pose provider and the FC IMU feed. Demo: the demo drone's room cloud.
  • Demo: the Capture, Reconstruct and Navigation extensions are installed from their manifests, with demo stand-ins for their pages (the Capture surface shows the capture monitor, Navigation's Agent page the navigation panel).
  • Demo follow-me: a follow distance set below 5 m, the least on a camera's range alone, is flown at 5 m and read back as standoff_min_m, standoff_raised and standoff_reason; the distance setpoint reads "at least 5.0 m with camera-only range", as in follow-me 0.5.0.
  • Demo follow-me: a follow height set below 3.4 m (a 2 m subject, 0.4 m of rotor and 1 m between them) is flown at 3.4 m, and the height setpoint reads "kept above head height for safety". The height setting's least value is 3.4 m, in 0.1 m steps, as in follow-me 0.5.0.
  • Controller-free flight groundwork. The aircraft setup wizard's "Meet ADOS Pilot" step offers "Use ADOS Pilot with no controller" with a line on what stops the drone without one; it leads when the agent saw no RC receiver. While the drone is declared to fly with no RC transmitter, a "No controller" chip sits beside the Confined chip on the top bar, and the new readiness items and refusals read their words from the shared spec. Demo: the demo pilot and setup wizard answer the declaration and its refusals.
  • Cockpit: a take-off goes through the pilot's launch. While the drone's steady take-off runs, the launch strip shows its status line and detail, and the status pill lists the Balance check and Steady take-off rows from the drone, with "I rebalanced it" on a failing Balance check of a disarmed drone. The steady take-off ships switched off on the agent.
  • Plugins: command.send takeoff is refused ("Not armed") until the drone is known to be armed, before the confirm prompt, on every route: the operator arms first.
  • Pilot stream: every frame names this tab with an instance id that stays the same across reconnects, so the drone keeps one link-loss timer per tab, and the tab says goodbye before a deliberate close (switching the drone, closing or leaving the page). The heartbeat is timed by a Web Worker, so a hidden tab's throttled timers no longer look like a lost link. While the tab holds the sticks it beats only while the page itself is responsive, so a frozen operator tab ends in the link-loss action. With no RC declared and the drone armed, closing the tab or switching the drone first warns "Leaving ends in in s", and switching can be cancelled.
  • Controller feedback: the pad rumbles from pilot-state changes by the shared rule table in the cockpit spec, the same rules every surface runs. A profile, owner, skill, control-mode change or a takeover plays the mode-change pattern; avoiding or blocked, a new hold reason, a speed cap coming on or a new readiness warning plays the warning; a lost controller, the link-loss or low-battery countdown, a failsafe, a new blocking item while armed, or the pilot state going stale is critical. One update plays only its strongest class, once.
  • Controller light bar: while the operator's sticks fly, the bar shows the speed profile (Cine soft green-cyan, Normal blue, Sport orange); failsafe, low battery, RTH, mission and skill keep priority, and goto, swarm and tuning show the plain pilot blue.
  • Cockpit: the flight-state chip names the profile with its horizontal limit ("Normal · 7 m/s"), shows a stick input older than 100 ms, and shows the nearest obstacle in amber when it is under twice the margin and in red inside it. Where the bottom row has no room for the speed readouts, the chip carries the horizontal and vertical speed while the sticks fly. Warning and critical facts on the chip keep their colour.
  • Cockpit: the on-screen sticks follow the operator's deadzone and stick mode (Mode 1 flies forward on the left pad and climbs on the right), draw the deadzone as a ring on each pad above the knob, and are checked against the shared stick golden vectors.
  • Cockpit: the proximity radar reads "No returns" in the warning tone when a fresh lidar scan has no return in any bin and nothing else reports a distance, where it read Clear: a lidar that sees nothing is not the same as open space. A return is a finite range above 5 cm, the pilot's own rule, so a scan of only near-zero bins no longer reads as an obstacle at 0.0 m. The shared spec carries the new words ("No returns", "Lidar no returns").
  • Cockpit: a position the drone cannot vouch for reads red. The flight-state chip shows "Position unverified · " (after the flight controller's RTH, Landing and Transition chips, with Take control while the flight controller flies its own mode), the reason read in words from the shared spec, a lost heading or IMU feed included. The hold reads "Holding · position unverified", and the nav-source chip turns crit with FLOW DISAGREES, CORRIDOR or UNVERIFIED. Fly here is not offered while the position is unverified, through the pilot or as a reposition in GUIDED, and the pilot's refusal and readiness item read "Position unverified (nav); fly manually or land" and "Position check (nav)". A stale pilot frame never keeps the nav chip crit. Demo: __adosDemoPilot.pin reaches the state.
  • Cockpit: a mission or return that stops making progress shows a stall card next to the countdowns, with Skip waypoint, Return and Land here (a blocked return offers Land here only) and the time left before the pilot acts on its own. The status pill lists the stall, the voice prompts speak it, and the Flight map marks the waypoints the drone skipped. Demo: __adosDemoPilot pins a stall, counts it down and answers the three actions.
  • Cockpit and planner: a confined-space place class. The Launch sheet and the planner pick Open or Confined space and show the margin each keeps (a confined place keeps the propeller-tip radius plus 0.1 m). A plan saves its class, in the plan library, the native file, a .plan and a share link; a plan with an unknown class loads as Open. The Launch sheet launches only once the pilot flies with the chosen class. A Confined chip on the top bar opens the route check: whether the route keeps the margin, the tight leg with its clearance and the clearance needed, a mission the agent has not downloaded yet, the waypoints the check could not place, and the speed cap near walls. The send dialog shows the same report before a mission is flown. Demo: __adosDemoPilot.confinedPins("feasible" | "unverified" | "infeasible").
  • Follow-me recovery phases. When follow-me loses its subject, the range
    readout under the top bar follows the recovery: Predicting, Moving to look
    and Searching, each with the seconds left of the search budget, then
    "Waiting for you" in the critical colour once the drone holds for the
    operator. The lock chip reads "Waiting for you" too. The re-acquired notice
    names what hid the subject when the drone reported it. A follow report
    older than 2 s blanks the values and reads Stale.
  • Waiting prompt. While follow-me holds for the operator, a prompt drops
    from the follow strip and says why: the search found nothing, the lock was
    lost, predictive search is off, no prediction is left, or the follow camera
    stopped sending frames. It offers Search again (R), Pick a target (P),
    Return home (H), Land (L) and Stop...
Read more

0.65.0

Choose a tag to compare

@github-actions github-actions released this 14 Nov 08:41

Altnautica Command v0.65.0

This release covers fourteen commits over 2026-11-13 and 2026-11-14, since
0.64.0. Two threads run through it.

The first is the cockpit telling the pilot what the drone will and will not
do. The flight-state chip shows the speed cap the drone applies without
GNSS, reads stale or missing obstacle data in the warning colour,
and keeps a blocked go-to on the map and in AR. Resume and Take control are
refused while the flight controller flies its own failsafe, and Copter
BRAKE reads as the flight controller's mode rather than a landing.

The second is a configuration fix: optical flow yaw is edited and checked in
the units ArduPilot uses, on every path that writes it.

Added

  • Planned path on the local-frame map. While a go-to or a skill flies and
    the pilot's frame is fresh, the local-frame minimap draws the pilot's
    planned path as a dashed line and a ring on its goal, in the go-to colour,
    or in the blocked colour while the pilot reports the way blocked. It
    matches the drone's own cockpit and the Android app.
  • GNSS-denied speed cap on the flight-state chip. When the drone caps its
    horizontal speed because it flies without GNSS, the chip's second line reads
    "GNSS-denied: 2.5 m/s max", rounded to one decimal, in the avoiding colour.
    The demo pilot can show it.
  • Stale or missing obstacle data. When avoidance is on and the drone's
    lidar stops reporting, the pilot holds position and refuses motion until
    fresh scans arrive, and reports the stale avoid state with the hold reason
    obstacle-data-stale: the flight-state chip reads "Holding: no fresh
    obstacle data · Obstacle data stale" in the warning colour and the AR path
    draws amber. A drone with no lidar reports unavailable, read as "No
    obstacle sensor" in the warning colour; its sticks fly, Fly Here is refused
    with its own reason, and the readiness list warns "Lidar".

Changed

  • macOS desktop builds are optional. The desktop release workflow builds
    the macOS app only when the repository variable MC_MACOS is true, and
    publishes the Windows and Linux builds without it. When a release ships
    without macOS, its notes say so.

  • Resume and Take control during a flight-controller failsafe. While the
    flight controller flies its own failsafe return or landing, Resume and Take
    control are disabled with the failsafe text, as Pause already was: in the
    skill list, on the flight-state chip button and in the Mode sheet. Until the
    flight controller's mode has been heard, the chip shows it as unknown.

  • Copter return and brake modes on the chip. Copter AUTO_RTL reads as the
    flight controller's return. Copter BRAKE, which holds position, reads as the
    flight controller's mode with a Take control button instead of as a landing.

Fixed

  • Optical flow yaw in centidegrees. Configure > Sensors edits
    FLOW_ORIENT_YAW in centidegrees (-17999..18000 in steps of 10, presets 0,
    ±9000 and 18000) and names the centidegree value an old 1..7 setting meant.
    The Sensors panel (its Save button and Ctrl+S), the Parameters grid and
    parameter file import all refuse a value off the 10 step or out of range,
    with or without the vehicle's parameter documentation. The field used to
    offer 0..7 in 45° steps, which ArduPilot reads as 0.01..0.07°.

  • The demo pilot refuses Take Control during an FC failsafe. As on the
    agent, Take Control, Resume, Takeoff and Launch return failsafe while the
    flight controller flies its own failsafe return or landing; handing the
    drone to an FC mode ends the failsafe, and Take Control works again.

  • A blocked go-to stays on the map and in AR. With agent 0.109.134 and
    later, a go-to the drone holds because a wall blocks the way keeps its goal
    and the straight way to it on the pilot frame, so the local-frame map draws
    both in the blocked colour instead of dropping them. The AR goal ring now
    takes the blocked colour too, as the path already did.

All 15 commits since v0.64.0
  • Desktop release: build macOS only when MC_MACOS is true, and publish without it (ed989c4)
  • local minimap: planned path and goal (300b87f)
  • Changelog: planned path on the local-frame map (8a70319)
  • Docs: note that macOS desktop builds are optional in releases (4f0ca88)
  • AR goal ring and local map keep a blocked go-to in the blocked colour (b1343d3)
  • Changelog: spacing (edd51ec)
  • cockpit: show the GNSS-denied speed cap on the flight-state chip (06a2cad)
  • Refuse take control, resume and launch in the demo pilot during an FC failsafe (e26a5bc)
  • cockpit: round the speed cap to one decimal on the flight-state chip (879b185)
  • cockpit: show stale and missing obstacle data on the chip, the AR path and readiness (4cb5f13)
  • cockpit: Resume and Take control are disabled during a flight-controller failsafe; an unheard FC mode shows as unknown (a34a0a9)
  • cockpit spec: Copter AUTO_RTL and BRAKE chip as the flight controller's return and landing (af76d7f)
  • cockpit spec: Copter BRAKE chips as the flight controller's mode, not a landing (31906f8)
  • sensors: optical flow yaw in centidegrees with validation before save (dc58264)
  • Record unreleased changes in the changelog (40be2e8)

Full diff: v0.64.0...v0.65.0


Downloads

  • Windows: .exe installer, unsigned
  • Linux: .AppImage

These installers are not code-signed. Check a download against
SHA256SUMS in this release (sha256sum -c SHA256SUMS --ignore-missing).

For the latest web version, visit command.altnautica.com.

0.64.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 15:26

Altnautica Command v0.64.0

This release covers everything since 0.63.0: thirty-one commits over
2026-11-12 and 2026-11-13, from a whole-app audit of Mission Control, the
Android app and the drone's own cockpit. Three threads run through it.

The first is a quieter cockpit that lives where the rest of the drone does.
The cockpit is now the drone's Flight tab, beside Overview and Configure,
with a Full screen button instead of a takeover. Panels are sharper and
calmer, every top-bar control has one height, status reads as a dot and
words, and badges across the app are outlined. The fleet sidebar is compact
and the demo fleet is smaller.

The second is safety on every path that ends a flight. Kill goes out in any
arm state, including after a link loss left it unknown, and a confirmed stop
or pause is never dropped mid-hold. An unknown arm state is treated as
possibly airborne everywhere: Land rather than Take off, no tips, and no
setup or reboot controls. The Betaflight failsafe dropdown writes the values
the firmware defines, and Fly Here sends only from the dialog on screen.

The third is the rest of the app. Configure panels follow the flight
controller's firmware and refuse writes to a vehicle that may be armed, the
planner reads uploads back and offers "Fly this mission", flight logs read as
words, and pages that cannot reach a node say so instead of showing blanks.

Added

  • Flight tab. The drone's cockpit is its Flight tab, beside the other
    tabs, with a Full screen button in the top bar. Escape leaves full screen.
    Cockpit keys act only while the cockpit has focus, so typing in the fleet
    search sends nothing. The vehicle readouts, status messages and RC card
    moved to Overview.
  • Fly this mission. After an upload, the planner offers "Fly this
    mission", which opens the drone's Flight tab with Launch set to start it.
  • Relayed commands say when they are still waiting for the drone, can be
    cancelled, and give up after 30 s.
  • Extensions on the LAN. When the drone is reachable on the LAN,
    extensions on it are enabled, disabled and removed directly. Disabling one
    asks first and warns when the drone is armed. Extension tabs say when they
    are loading and offer Retry when their page cannot load.
  • Desktop. Bluetooth connections ask which device to use. A window that
    fails to load offers Retry and Quit, and a failed start names its log file.
  • Demo. The Follow-Me and Vision Nav tabs show their live read-back,
    charts and tour; every first-party extension matches its newest release.
    The Betaflight drone answers receiver reads, the PX4 VTOL carries its
    transition parameters, and rover outputs report their direction.

Changed

  • Cockpit spec sync. Flight-state chips read in sentence case, an unknown
    arm state with no flight controller link refuses Fly here with "No flight
    controller link", and the plugin contract mirror tracks pilot contract v2.
  • Cockpit words. Follow controls, setup steps and unrecognised modes read
    in sentence case, and the link age follows the shared format: one decimal
    below 10 s, whole seconds above.
  • Sharper, quieter chrome. Panels use a smaller radius, light blur, thin
    borders and no shadows. Every top-bar control has one height. The
    flight-state chip and status pill are outlines with a status dot.
  • Fleet sidebar. Rows are compact: an outlined node tile with a liveness
    dot, a one-line summary with labelled icons and a live drone's battery, and
    an icon-only Fly button. Badges across the app are outlined and in sentence
    case.
  • Demo fleet trimmed to eleven drones; swarm conditions follow drone ids.
  • Planner. Uploads count the items the drone has taken. A refused upload
    says why in words instead of a result number. Tool-group openers and outline
    buttons are easier to hit, and the planner calls the aircraft a "drone".
  • Words. Configure, Command, Hardware, History, Logs and Settings render
    through translations, including FC option lists and mission issues.
    Parameter panels share one save bar. Flight-screen labels come from the
    shared cockpit spec.
  • Flight logs. A flight row opens that flight's log, statuses read as
    words, deletes confirm in the app, empty and filtered lists say so, and the
    "Logs" page is called "Flight logs".
  • The split ratio and view persist per drone. The accent colour follows the
    theme actually applied, so night vision always drops it.

Fixed

  • Smoother live video. The glass-to-glass figure updates four times a
    second instead of once per frame, so the HUD, attitude radar and plugin
    overlays no longer re-render at the frame rate. The jitter buffer waits
    longer between changes and steps down only after a sustained clean stretch,
    so a link that freezes now and then holds one steady depth instead of
    stretching and compressing the picture every few seconds.

  • The full-quality stream holds. A failed lease renewal is retried within
    seconds, renewals run at a third of the lease, a failed promotion is retried
    on the next poll, and a camera pipeline restart no longer drops the drone to
    the 1 fps thumbnail.

  • Take control refused by the flight controller reads "The flight
    controller refused: …" with the controller's own reason, and "No answer
    from the flight controller" when it does not reply, instead of a raw code.

  • The planner lists a LAN-paired drone after a reload. Mission Control
    keeps a link open to every drone paired on this network whose flight
    controller is up, not only to the drone open on the dashboard. A full page
    load, or leaving the drone's page, no longer empties the planner's Drone
    list, and a dropped link is dialled again every 3 s. A flight controller
    you disconnect stays disconnected until you connect it again, even if the
    agent's link drops and comes back meanwhile, and a drone reached through a
    ground station is never dialled directly.

  • Map point menu on the cockpit minimap draws above the card's corner
    buttons, so the AUTO / LOCAL / MAP toggle no longer covers "Fly Here", and
    stays inside the window: on a small map every item is reachable.

  • Demo ArduPilot drones keep an uploaded mission altitude in whole
    centimetres, as the firmware does, so a 35.67 m upload verifies and "Fly
    this mission" appears.

  • Camera zoom steps with continuous zoom and then a stop, which ArduPilot
    accepts; it denied the step zoom sent before. The stop goes out on time
    even when the zoom's answer is lost or late, so the camera never runs on to
    the end of its zoom.

  • Fly Here from the local minimap opens its dialog in flight; the dialog
    closed itself as it opened on a remount. A point that offers nothing now
    says so in a toast instead of doing nothing.

  • Dialogs open on first load, such as a pairing link, move focus into
    the dialog.

  • Aircraft setup says the ground wizard waits for the vehicle to report
    disarmed when its arm state is not known yet, as the calibration panels do,
    instead of "Disarm first".

  • Parameters. Picking the same parameter from the palette again moves
    focus back to its row.

  • Betaflight failsafe procedure writes 0 for Land and 1 for Drop, as the
    firmware defines them; the dropdown had the two swapped.

  • Pad stop hold with the top bar's STOP sheet open sends the stop once
    and closes the sheet, so completing it later cannot send a second stop.

  • Extension telemetry keeps updating after the drone's clock steps back
    (a power cycle with no clock source, or a clock correction).

  • Mission read-back on ArduPilot compares altitudes in the whole
    centimetres the vehicle stores (35.67 m no longer reads as different) and
    reads continue-and-change-altitude, loiter-to-altitude, guided enable,
    relay, go-around and VTOL transition items by the fields the vehicle keeps.

  • Send to vehicle holds back the geofence when a waypoint is below its
    floor.

  • Frame and Heli panels hold Save, with the reason, while a staged frame
    edit cannot be written because the vehicle may be armed.

  • Reboot-required banner cannot be confirmed once the vehicle arms with
    the confirmation open.

  • Drone overview says a live node is not connected to this browser,
    rather than unreachable; an FC heartbeat alone no longer marks the
    companion online. Cameras in a cloud session show one notice, and the
    extension disable confirm notes an unknown arm state with no local link.

  • Parameters opened from the palette keep their focus and highlight until
    the filter changes. Compare, restore and scripting labels are translated.

  • Stop and Pause confirmed on their sheet are sent even when the link
    drops or returns during the hold. Holding the pad stop chord while the stop
    sheet is open sends the stop.

  • Fly Here sends only from the dialog on screen, with the altitude typed
    there, and closes when a confirm such as the stop sheet opens, so one hold
    never drives both. It is not offered on the flight-controller route while
    the pilot reports a failsafe.

  • Controller. The Triangle hold lands rather than taking off when the
    pilot data is stale or the arm state is unknown, and the lightbar shows
    link lost at the same age as the rest of the Flight tab.

  • Pre-flight names a failing check as the fault, for example "Home
    position not set", and FC pre-arm text appears without a prefix.

  • Demo. A landed demo drone keeps reporting its navigation source, the
    demo LAN drones never reach a device on the operator's network, and only
    demo drones with a companion take gimbal rates.

  • Relayed commands. Cancel leaves a pending extension install to its own
    cancel instead of failing the install.

  • Unknown arm state counts as possibly airborne in the Flight tab (Land,
    not Take off), Disconnect, camera changes, extension Disable and every
    flight-controller reboot control, which now share one confirm that ...

Read more

0.63.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 16:43

Altnautica Command v0.63.0

This release covers everything since 0.62.0: fifty-four commits, all on
2026-11-10. It is a second pass over the cockpit that 0.62.0 rebuilt, with
three threads running through it.

The first is one behaviour on every cockpit. The flight-state chip, the status
pill, pilot refusals, the tips queue, the link-loss line, battery time to
reserve and the Fly here offer now run on modules shared with the drone's own
cockpit and the Android app, checked against the same case files. Every
flight-screen word, confirm hold, take-off limit and Menu order comes from the
shared cockpit spec, so a refusal reads "Not ready: Controller" instead of a
raw code and the link-loss countdown names the configured action.

The second is safety around the flight screen. Pause is refused while the
flight controller flies a failsafe return or landing, Disarm needs a known
landed state on MAVLink flight controllers, STOP is always enabled and opens a
sheet with one 3 s hold, and every controller binding for STOP waits for that
full hold. The welcome, disclaimer and What's New dialogs wait until no cockpit
is on screen and no vehicle is armed. Sheets open below the top bar so STOP
always takes the first press.

The third is first use without interruptions: one-line contextual tips on the
ground, a controller tour card without a scrim that can be replayed, a small
banner to set up a new flight controller, and a pre-flight checklist that
gates the first arm of a session.

Added

  • Contextual tips. One-line tips anchored to the status pill, chip, layer
    button, STOP, skills chip, card and gimbal pad. One at a time, on the ground
    and disarmed only, never over STOP, the top bar, the left column, the chip or
    an alert, and never while a sheet, menu or the controller tour is open. A tip
    hidden for a moment by a banner or sheet keeps its turn. Settings › General
    has Reset tips.
  • Controller tour card. The tour is a card without a scrim, remembered
    once per device instead of per pad (earlier flags carry over), driven by the
    pad while it shows, and replayable from Settings › Controls.
  • Aircraft setup banner. A new flight controller gets a small "Set up this
    aircraft" banner with Open and Later, once per controller on this device, on
    the ground and never over the flight screen.
  • Pre-flight gate. The Menu's Pre-flight row opens the shared checklist as
    a sheet. The first arm of a session, and the pilot launch, wait until no item
    fails; "Checks done" passes the gate, and the arm confirm names the open
    items. On-screen sticks count as a controller where they are shown.
  • Vehicle camera. Mission Control asks for CAMERA_INFORMATION once per
    connection. Photo and Zoom try a camera extension, then a MAVLink camera
    that advertises capture or zoom, then the shown video (a saved frame and
    digital ×1/×2/×4), with "Photo saved" and "No video" texts. A refused
    capture or zoom shows the failure; a capture still in progress is never
    reported as failed.
  • Gimbal pad. A drag-to-aim pad in the right column: release stops, a tap
    recentres, arrow keys aim, Enter recentres, Space is never handled.
  • Fly here on more maps. The local-frame map (no GNSS fix) offers Fly here
    on right-click and long-press through the EKF origin. On the ground, a long
    press offers Launch here, which prefills the Launch sheet's go-to.
  • Demo states. The demo pilot mirrors the demo drone (missions, Pause,
    Resume, Land, Return home, Kill, Follow-Me from the skill bar), can pin a
    failsafe, a setup step and Fly here, and the demo vehicle has a camera.
    __adosDemo.freezeTelemetry() stalls the pilot,
    __adosDemo.blockNavStream(true) shows the radio fallback and
    __adosDemo.failAgentPolls(n) drops agent polls.

Changed

  • Shared chip and pill. The chip has two lines (state, then details and
    control mode) and shows MISSION · WP n/N with ETA, MISSION COMPLETE,
    TUNING · <step>, TAKING OFF with Abort, Resume after a stick takeover,
    FAILSAFE and NO PILOT. The pill reads "Pilot not answering" for a paired
    agent with no fresh pilot state, treats an unreachable agent as critical,
    lists the flight controller's own failsafe ("Failsafe: ") and a
    failing pre-flight check, and reports storage as " % used" (warning at
    90 %, critical at 97 %). The alert list opens below the top bar with an
    "Alerts" heading and severity glyphs.
  • Shared words. Confirm dialogs, alerts, refusals, command results, the
    navigation source, layers, radar, minimap, camera and card labels come from
    the shared cockpit strings. Skill settings show the manifest's label. Agent
    refusals that carry a code show the shared text for that code.
  • Top bar and Menu. Items move into the Menu in the shared order, and the
    Menu lists only hidden items, then its sections in the shared order with a
    per-layer list. Flight modes opens the Mode sheet. Exit reads "Exit to
    Overview". The controller cell says "No controller" until a pad has been
    seen.
  • STOP. STOP is always enabled. On the flight screen it opens a sheet below
    the top bar titled "Emergency stop" with one hold button that counts down
    the 3 s hold, and a warning when the link is stale. Any keyboard or
    controller binding for STOP runs as that full hold.
  • Layout. The bottom-left card switches by swipe and dots; the Map view's
    video sits in that card; Split has a draggable divider (30 to 70 %) kept per
    vehicle; the follow strip sits under the top bar; the right column drops
    items in the shared order when short; toasts stack above the bottom row.
  • Sheets. Every flight-screen sheet opens below the top bar over a
    translucent scrim, one at a time, closed by Escape or a press outside. The
    Launch sheet takes 1 to 120 m (default 3 m) and has Abort.
  • Chrome. Panels, critical text and STOP use the shared tokens; the left
    column shows short labels; the link cell shows the age of the newest frame
    with signal in its popover; the battery shows time to reserve; hold controls
    say "Keep holding" after a short press; readouts never show a negative zero.
  • Holds and bindings. Take control, hand to FC, VTOL transition, Fly here
    and STOP holds, and the controller's Options button, come from the spec.
  • Map menu Fly here. Offered whenever the ADOS pilot accepts a go-to
    (fresh pilot state, ADOS control, outside a failsafe), whatever the flight
    mode; without the pilot it is a flight-controller reposition offered only in
    GUIDED.
  • Landed state. On connect, after a link restore and after a flight
    controller reboot, Mission Control asks ArduPilot for EXTENDED_SYS_STATE so
    the landed state is known.
  • Shell. On the flight screen Ctrl+K opens only the cockpit palette.

Fixed

  • Pause during a failsafe. Pause is refused while the flight controller
    flies a failsafe return or landing (ArduPilot and PX4 mode names), on the
    pilot and flight-controller routes. A return or landing counts as commanded
    here only once the vehicle accepts it, and every vehicle's own heartbeat is
    checked.
  • Disarm. On MAVLink flight controllers Disarm needs a known landed state
    and otherwise shows "Landed state unknown"; Betaflight and iNav, which report
    no landed state, keep the confirm only. The arm key never turns into Disarm
    in the air.
  • Shell dialogs over the cockpit. The welcome, disclaimer and What's New
    dialogs wait while a cockpit is open or any vehicle is armed (and for 5
    minutes after an armed vehicle loses its link), then open.
  • Link-loss countdown. Names the configured action (Return home, Land,
    Hold) instead of a generic word; both it and the low-battery return are
    critical.
  • Stale pilot state. Countdowns, the gate ring, the handover banner and
    AGL hide when the pilot state is older than 2 s, and Fly here falls back to
    the flight controller route.
  • Fly here send. The send uses the route that was offered, decided again
    at the press.
  • Launch sheet. Hold to launch was unreachable at some sizes; the sheet
    now opens beside the left column at full width.
  • Alert list. The status pill's list was clipped by the top bar and could
    not be read or pressed.
  • Controller tour. The press that closes the tour no longer reaches the
    skill picker.
  • Map notice. "NO GPS FIX" and "POSITION STALE" sit under the GPS badge,
    not at the map's centre.

Notes

  • Tip and tour state is stored in altcmd:cockpit-tips and
    altcmd:cockpit-controls; earlier per-pad tour flags and stored aircraft
    setup offers carry over.
  • Pairs with ADOS Drone Agent 0.109.101 or later for the shared cockpit spec,
    the pilot failsafe flag and the refusal codes.
All 55 commits since v0.62.0
  • Cockpit: the flight-state chip runs on the shared chip rules and inputs; spec copy moves beside the shared HUD modules (0a4edc1)
  • Shell: welcome, disclaimer and What's New wait while a cockpit is on screen or a vehicle is armed (eec45ba)
  • Flight actions: Pause is refused during a flight-controller failsafe on every route; Disarm only on the ground (ecfa559)
  • Map: Fly here in the right-click menu whenever the ADOS pilot accepts a go-to (51347f7)
  • Cockpit: sheets and confirm dialogs open below the top bar so STOP stays reachable; one sheet at a time; toasts clear the bottom row; the controls row names the true stick route; link-loss countdown names its action ([c3feabf](c3feabf37231f84230766b...
Read more

0.62.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 02:34

Altnautica Command v0.62.0

This release covers everything since 0.61.0: sixty-eight commits between
2026-10-22 and 2026-11-10. Three threads run through it.

The first is the cockpit, rebuilt as one full-viewport flight screen. A top
bar carries the flight-state chip, the status pill and STOP; flight actions
sit in a left column, the camera controls in a right column, the telemetry in
a bottom row, and the centre keeps the picture with an Instruments level for
the attitude instruments. Data layers (AR route, obstacles, depth, surfaces
and targets) draw in one canvas over the video, dim and hide when their data
goes stale, and ask the drone only for what is on screen through view leases.
A Fly button opens the flight screen from the fleet rows and the drone page.

The second is the drone's ADOS Pilot. The cockpit streams sticks and actions
to the pilot, shows who flies the drone in the flight-state chip, and offers
the Mode sheet, a skill picker, a Launch sheet and Fly here through the pilot.
Built-in actions fall back to the flight controller when the pilot stalls. A
DualShock 4 follows a shared binding table with gimbal rate on L2/R2 and a
designate reticle on the touchpad, and Settings › Aircraft setup runs the
agent's ground and air setup wizards.

The third is the ground underneath: maps show when the plan on the drone
differs from this device's plan, ground-station pairing sends the fleet key
the agent expects, and a round of refactors splits the largest client,
protocol, Convex and panel modules and generates the agent's API types.

Added

  • Flight screen. The cockpit is one full-viewport grid: a top bar
    (flight-state chip, status pill, battery with time to reserve, link,
    navigation source, controller, layer level, Menu, STOP), a left column of
    flight actions, a right column with the shutter, photo/video, zoom and
    camera settings, a centre for the picture and the layers, a bottom-left card
    that switches between map, attitude and obstacles by swipe or dots, the
    D/H/H.S/V.S/AGL bottom row, and a follow dock above it while following.
    Portrait stacks the picture, the actions, the readouts and the map. Items
    that do not fit the top bar move into the Menu. The flight instruments draw
    only at the Instruments level and shrink to fit a short centre.

  • Fly button. The fleet rows and the drone page open the flight screen.

  • Fly here through the pilot. Under ADOS control, when the drone's pilot
    takes a go-to, Fly here sends the map point to the pilot whatever runs now
    (a mission, a skill, a flight mode), and the hold dialog says it takes over.
    In FC manual or ELRS control it repositions the flight controller. A refusal
    (for example while launching, or while the flight controller flies a
    failsafe return or landing) is shown with its reason.

  • Mission ETA. The active mission chip shows the next waypoint's ETA from
    the drone's AR frame.

  • ELRS control mode. The Mode sheet offers the ELRS control mode when the
    drone is reached through a ground station.

  • Status pill FC warnings. The status pill lists the flight controller
    warnings the pilot reports, and the bottom row's AGL reads the pilot's
    height above ground; when the pilot's reading goes stale the cell shows no
    data instead of falling back to another source.

  • Layer unavailable chips below the top bar. A layer's "unavailable" chip
    stacks centred a fifth down the picture, as on the agent cockpit, so the top
    bar no longer covers it.

  • Designate reticle and gimbal rate on the controller. L2 and R2 drive the
    gimbal pitch rate through the agent, and the touchpad opens a designate
    reticle. The cockpit asks for a button press before a pad reports, shows the
    pad's product name and the first-connect tour, and reads "not supported" for
    a pad without the standard layout.

  • Plan banner on every map. Every full map view carries the plan banner,
    and when the plan on the drone differs the route drawn is the agent's copy
    of the drone's mission.

  • Aircraft setup (Settings › Aircraft setup). The selected drone's agent
    runs the ground and air setup wizards (detection, frame, accelerometer,
    level, compass, airspeed, radio, the ADOS switch position, motor and control
    surface checks, battery, initial tune, notch, the FC parameter profile, Meet
    ADOS Pilot; first hover or flight, trims, airspeed and TECS, autotune,
    verify). Each step is drawn from the agent's step schema with the cockpit
    spec's text and pictures: live values, progress, the motor question, inputs,
    blockers, results, and tap, hold or props-off hold confirms. Any finished
    step can be run again on its own, parameter snapshots can be restored, and
    the setup report lists each step's numbers. Demo mode plays a quad through
    the ground wizard.

  • Aircraft setup entry points. The flight-state chip's NOT READY state
    shows "Set up aircraft" when the drone reports aircraft setup is needed, and
    the first time Mission Control sees a flight controller without a completed
    ground setup a banner offers the wizard (once per aircraft).

  • Cockpit views. V (or Triangle on a controller) cycles Pilot, Map
    (the map main with the video as a picture-in-picture, which draws no data
    layers), Split (video beside the map) and Vision (the video with the
    detection list, model picker, depth options and engine summary at the
    side). O cycles the data-layer level; the layer button and the view button
    sit next to the flight-state chip, with the controller status.

  • Reduced update rate over a radio link. When the drone's live nav stream
    cannot open but its HTTP API answers, the cockpit polls
    GET /api/v1/nav/status at 2 Hz with its view lease and shows "Reduced
    update rate (radio)". Each value keeps its age on the drone.

  • Launch sheet. With the drone's pilot reachable, Take off opens Launch:
    take-off altitude, the after-take-off action (hold, a behaviour skill, start
    the loaded mission, or go to a point) and an optional when-done action. One
    1.5 s hold sends the sequence; the pilot's progress shows as a step strip,
    and Pause aborts it.

  • Flight-flow chrome. The handover banner, the "Centre sticks to take
    control" ring, "Sticks are with " with a Take over hold, the
    low-battery return-home countdown with Cancel, the link-loss countdown,
    voice prompts (handovers, return home, low battery, mission started, paused
    and complete; on by default) and optional on-screen sticks, all in the
    shared cockpit words.

  • Controller bindings from the shared table. PS pauses and held 2 s
    returns home (PS again cancels), L1 + R1 held 2 s with the left stick
    centred arms, L2 + R2 + Circle held 3 s is the emergency stop, the D-pad
    moves through the skill picker and steps the focused parameter (the layer
    level with the picker closed), Cross starts a skill and Circle stops it,
    Triangle cycles the view and held takes off or lands, Options opens quick
    settings, Options + D-pad changes the profile, Share records and Square
    takes a photo. Each action rumbles; on a secure origin a granted DualShock 4
    lightbar follows the flight state. A controller hold confirms a hold-tier
    action by itself (an incomplete checklist still opens the sheet).

  • Settings › Controls. The controller drawing with every control's
    action, live input, per-gesture editing, locked safety bindings that can
    only be moved, conflict highlighting that blocks Save, Mode 1 / Mode 2,
    stick calibration with the deadzone, rumble and lightbar tests, reset,
    export and import of the shared controls file, the first-connect tour,
    on-screen sticks and voice prompts.

  • Pre-flight checklist items for the ADOS Pilot's readiness, a live link,
    a connected controller when the pilot flies the sticks, and drone storage.

  • Plan on drone. Mission uploads record the MISSION_ACK plan identity;
    the cockpit's map views say "Plan on drone differs from this device's
    plan" when the drone holds another plan, with Load from drone.

  • Pilot stream. With an agent-connected drone, the cockpit opens
    WS /api/v1/pilot/stream (ticket scope pilot.control). In ados control
    mode the gamepad's sticks go to the drone's pilot as pilot.v1 input frames
    at 50 Hz, with a radial deadzone of 0.08 by default (the pilot applies the
    expo); the stream sends release when the pad disconnects, the tab is
    hidden or the pad stops reporting for 150 ms. fc_manual and direct-serial
    links keep the RC override. A pad must report the standard layout or carry
    a calibration from the calibration wizard before it streams.

  • Flight-state chip and Mode sheet. A chip at the top left shows who flies
    the drone (READY, PILOT · NORMAL, the skill, MISSION · WP n/N, RTH, FC ·
    mode with Take control, LINK when the pilot state is stale) with the
    secondary line for hold reason, avoidance and control mode, in the cockpit
    spec's words and colours. Tapping it opens the Mode sheet: profile, control
    mode (hold to confirm), avoidance (hold to turn off), hand to FC, VTOL
    transition and the FC modes.

  • Skill picker. The visible skill bar is replaced by a picker at the
    bottom right: tabs Behaviors / Camera / Navigation / Utility, each plugin's
    skills grouped under it, a Tweak panel for the skill's parameters, GO and
    Stop. One motion skill runs at a time; a skill that does not echo its state
    within 3 s reverts with a toast. Skills that exclude the drone's vehicle
    class are hidden. The loadout still holds keyboard bindings.

  • Left column. Take off / Land, Return home and Pause sit at the left,
    vertically centred.

  • Mission state. Mission overlays, the pause/resume binding and the
    upload guard read one mission state (none, loaded, active, paused,
    complete, returning): the drone's own when its agent publishes one,
    otherwise computed from the link's HEARTBEAT custom mode, MISSION_CURRENT
    ...

Read more

0.61.0

Choose a tag to compare

@github-actions github-actions released this 22 Oct 11:33

Altnautica Command v0.61.0

This release covers everything since 0.60.0: fifty-four commits between
2026-10-13 and 2026-10-22, more than half of them on 2026-10-20. Three threads
run through it.

The first is the planner, rebuilt around the selection. A plan outline, an
inspector that follows what you pick, a dock of mission tabs and a 3D view
replace the old panels. Missions now reach ArduPilot and PX4 the way each
autopilot reads them, and validation, flight time and the return leg follow
the autopilot's own rules. Each plan carries its planned home, vehicle profile
and transit altitude into the library, files and share links, and .plan,
.waypoints and KML files round-trip what QGC and Mission Planner read.
Terrain comes from open elevation tiles, and terrain, map tiles and the app
itself are kept for offline use.

The second is nodes beyond the drone. The Visor capture rig is a new node
profile with its own Overview, Sensors and Cameras pages, and it is never
offered flight actions. Ground stations gain GNSS and LoRa tabs with the LoRa
band plan, duty meters and region advisories, and the front-panel buttons
become editable on both. Detection overlays move to wire version 3.

The third is the surface around them: the Dark theme is a neutral black with
one accent, the vector STREETS and LIGHT basemaps and ground-station field tile
packs join the map, and MCP setup runs the server in Docker by default.

Added

  • MCP setup runs the server in Docker by default. The MCP setup wizard,
    the Connect panel and the credential reveal dialog have a Docker / From
    source toggle. Docker needs only Docker: the recipes pull
    ghcr.io/altnautica/ados-mcp, forward keys with -e NAME so no secret
    sits in the docker command, and mount ~/.ados/mcp so the audit trail
    and the live activity view keep working. Docker recipes dial a drone's
    IPv4 address when it is known, since .local names may not resolve inside
    a container. The choice holds for the session.
  • Planner 3D view with editing. A 2D / 3D switch in the planner bar (or
    the 3 key, or "Toggle 3D view" in the command palette) shows the plan on
    terrain with its path, fences, rally points and pattern boundaries. Click to
    place with the same tools as the 2D map, drag a waypoint to move it,
    Alt+drag to change its altitude, right-click for the waypoint menu; Escape
    cancels a drag. Selection is shared with the outline and inspector, edits
    share the undo history, and the chosen view persists. Picking a drawing tool
    switches back to the 2D map, and the map overlays panel and offline area
    download work only on the 2D map. With no plan open, the planner shows the
    2D map.
  • SIM chip on the node header when the agent reports sim: true (its
    simulation mode flag), whether the node is reached on the local network or
    through the cloud relay. Demo mode shows it on Delta-04.
  • Visor nodes. A node running the agent's visor profile shows with a
    scan-line glyph and its own accent, and the profile picker on a node's Core
    settings page lists Visor. Its Overview reads the agent's health, battery
    gauge, capture storage, session clock, a rig summary and the last capture
    session. A Sensors tab lists every rig sensor with its live rate against the
    expected rate (a sensor with no known expected rate shows its rate without a
    verdict), sample age, sync sigma and source, plus the sensor hub and flight
    controller behind them. A reading whose latest read failed keeps its last
    value with a "Stale" chip giving its age, a failed read says whether the
    node answered with an error or did not answer, and a GNSS receiver without a
    fix reads "no fix". Capture storage and session sizes read in binary units
    (GiB). A Visor reached only through the cloud relay says its sensor readings
    need a local-network connection. The Cameras page edits the roles and
    capture keys of the capture cameras. Display, buttons and peripherals are
    the same tabs the ground station uses, with the Visor's own button and
    screen defaults. Extension pages that target the Visor are placed in their
    manifest order, and plugins and their Convex install rows accept visor as
    a target profile. Demo mode includes a Visor with two capture cameras and
    stand-in Capture, Sessions and Calibration tabs.
  • Visors are offered no flight actions. A Visor whose sensor hub answers
    as a MAVLink flight controller shows the flight-controller reading, status
    card and hardware panel; without one it is a host node. Either way it is not
    offered arm, mode change, takeoff, land, return to launch, guided or mission
    commands, mission, fence or rally upload, set home, motor or servo tests, or
    stick input, and a fleet-wide return to launch skips Visors. Any such
    command that still reaches the vehicle connection is refused with "This
    node's flight controller is a sensor hub: flight commands are not offered".
    Disarm and kill are never refused. Readings, parameters and calibration work
    as on any other node.
  • Ground-station GNSS and LoRa tabs, shown when the node advertises the
    gnss / lora flag, whether it is reached on the local network or through
    the cloud relay. The GNSS tab shows receiver fix, RTK base survey/fixed
    control (disabled while the vehicle may be armed), heading and PPS lock. The
    LoRa tab shows the beacon lane with its regional band plan, a region picker,
    a channel and power form (frequency, ERP and spreading factor) that the agent
    checks against the band plan, per-rule duty governor meters, the position
    beacons the lane heard (age, position, altitude, battery, flight mode, RSSI
    and SNR), a Meshtastic card with receive counters and the bridge state, and
    a blocked banner that names the reason and the fix. Transmit reads "Allowed"
    only when transmitting is allowed now, "Paused" with a countdown while a
    duty, dwell or listen-before-talk rule waits, and "Blocked" otherwise; a
    region whose module support is unknown is marked "Module band unknown". The
    Radio tab shows every WFB adapter, with a diversity summary when two or more
    adapters receive; an adapter whose FEC recoveries are counted per stream
    shows a dash for them with its loss marked as an estimate, and a node with
    no WFB receive plane shows an empty state. The RC / ELRS tab shows every
    ELRS module.
  • LoRa region advisories. Amber chips under the active LoRa region flag a
    Meshtastic bridge preset that differs from the one the region maps to, an
    explicitly set region that differs from the plan the node's country setting
    resolves to, and an ELRS module whose domain is not the one the region
    expects for that module's band. They are advisory only and never block
    transmit.
  • LoRa state on the ground-station Overview. A chip shows the region and
    its highest duty use while transmit is allowed, "paused" with a countdown
    while a waiting rule holds it, and "blocked" with the reason otherwise. It
    appears once that node's LoRa lane has been read.
  • Adapter RSSI sparklines. The ground-station Radio tab draws a short RSSI
    history for each WFB adapter chain, and stops polling the adapters route on
    an agent that does not serve it.
  • Demo direct ground station. Demo mode adds "Ground Station Bravo" in the
    direct role, with the multi-adapter Radio tab, seeded RSSI history and the
    GNSS and LoRa tabs. Its mesh view reads as a direct station.
  • Vector street basemaps. STREETS (dark) and LIGHT draw vector tiles from
    the project's tile server. Labels stay crisp at any screen density and use
    the app language where the map data carries it. The map renderer loads only
    when one of them is picked, and the map still zooms to street level past the
    tiles' own detail.
  • Field tile packs. When a paired ground station serves a vector tile pack
    over the local network, the basemap picker offers FIELD and the map works
    with no internet. With several packs, the picker names the active one and
    lets you choose. Settings > Data lists the station's packs with their zoom
    range and size. The list is re-read every minute; a single missed read keeps
    the field map, and three failures in a row (about three minutes) fall back
    to STREETS. A page served over HTTPS cannot reach the station's plain-HTTP
    address, so FIELD appears in the desktop app or in a Mission Control opened
    over plain HTTP on the local network.
  • Send to vehicle. One dialog sends the mission, the geofence and the
    rally points (each when present), shows any blocking issues and the
    pre-flight checklist progress, and reports each item's result. A fence or
    rally points can be sent without a mission. The dialog names the vehicle
    that receives the upload and, when the plan is assigned to another one,
    offers to switch to it.
  • Scrub number fields. Inspector number fields commit on blur or Enter.
    You can scrub them by dragging their label, their unit or, on a bare field,
    the drag handle (Shift ×10, Alt ×0.1), or step them with the arrow keys.
  • Camera and terrain-following patterns. Survey, corridor, structure scan
    and the new facade scan follow the camera and the ground. Patterns can fly
    above home, follow the terrain within a set tolerance and climb and descent
    limits, or use the terrain frame on ArduPilot; a follow-terrain pattern
    applies only once the ground along every leg has been sampled, and says so
    when the ground could not be read. Custom cameras, portrait orientation, a
    minimum trigger interval warning and hover-and-capture for multirotors are
    new, and corridors are drawn as an open line. The survey's wind rows default
    to the Site tab's forecast wind. Alternate transects now fly every line,
    entry corners start where they say, the grid angle is a compass bearing from
    north, a narrow area gets one centred line, photo counts include the shot at
    each end of a line, corridors fly parallel lines along the wh...
Read more

0.60.0

Choose a tag to compare

@github-actions github-actions released this 11 Oct 11:50

Altnautica Command v0.60.0

This release covers everything since 0.59.0: seventy-four commits, most of
them landing in the first two weeks of October on top of a summer of
dependency updates. Three threads run through it.

The first is the cockpit. Mission Control now shares one cockpit standard
with the agent's HDMI cockpit and the Android app: a safety band, alerts by
level, rebuilt HUD instruments and confirmations as gesture tiers that work
from touch, pointer, keyboard and gamepad. Skills resolve through one place,
so the Skill Bar, command palette and gamepad radial agree on what a key does,
and kill, return home and land stay available when the link goes stale.

The second is what Mission Control reports about the vehicle and the node.
Parameter send failures, incomplete downloads, MISSION_ACK refusals and
unconfirmed signing changes now show as failures instead of passing silently.
Radio, relay and TX power readings are shown as measured or unknown, link loss
drives removal and failover per drone, and node pages show what the agent
declares rather than what a table assumes.

The third is the self-hosted stack. The MQTT bridge forwarder is gone: agents
post their status to Convex over HTTPS, and Mosquitto carries only the relay
planes. Local-network server routes answer only local pages, server proxy
routes fetch only from allowlisted sources, and the desktop app no longer
installs unsigned updates by itself.

Added

  • Phone receivers. The ground station Radio tab lists phones asking to
    receive the link directly, with their key fingerprint, for approval. The
    card hides on agents without the route and disables decisions while the
    station is unreachable.
  • Links panel. Each drone has a Links panel listing its connections. A
    protocol-level disconnect drives removal and failover, a reconnecting list
    shows drones being retried with a stop control, and drone identity refreshes
    from AUTOPILOT_VERSION.
  • Inbound signing enforcement. An optional setting drops inbound MAVLink
    frames without a valid signature, and the Signing panel shows inbound
    signing counters. A banner warns while a vehicle runs unsigned.
  • Agent diagnostics strip. Node pages show the flight controller system id
    and the agent's reconciler outcome, uplink route state, proxy posture,
    agent signing, software-encode use and recorder segments. Uploads show a
    busy state and their content digest.
  • Dashboard PIN unlock. An unpaired ground station whose dashboard is PIN
    locked can be unlocked from Mission Control.
  • Perimeter pattern. The planner gains a perimeter pattern, and Planner
    Copilot understands perimeter and intent requests.
  • Desktop updates. About has a "check now" control. Check failures and a
    retry are shown, and an offline check is reported as information rather
    than a failed update.
  • Flight map mission route. While the aircraft flies a mission the open
    plan matches, the Flight map and cockpit minimap draw its route and mark the
    waypoint it is heading to.
  • Demo mode. Each flying drone holds its loop as its mission and reports
    the waypoint it is flying toward, so the WP readout, route and PLAN overlay
    are live. Also new: Wi-Fi status and scan, a receiver ground station with
    mesh pairing, the demo feed in the Overview and downlink video cards, the
    Vision Nav tab body, and registry search and filters. Demo drones land and
    disarm like a real flight controller.
  • OLED contrast. The ground station physical UI tab sets OLED contrast.

Changed

  • Cockpit. A safety band (reach, arm, mode, battery with time to reserve,
    GPS, link, video, stick control, preflight, recording and flight timers,
    guarded Kill), alerts by level, and rebuilt HUD instruments (5° pitch
    ladder, roll scale, flight-path marker, heading tape with home caret,
    scrolling speed and altitude tapes with REL/MSL, vertical speed, wind).
    Confirmations are gesture tiers (tap, hold, slide, guarded); typed-phrase
    confirms are gone from flight skills. Command skills turn off with a reason
    as soon as the flight controller heartbeat is older than 3 s. The cockpit
    adapts to its width and stays still under telemetry load.
  • Skills. One resolver for bound keys drives the Skill Bar, palette and
    radial: arm becomes disarm and pause becomes resume. Each drone has its own
    arm lock, and an unknown arm state is treated as armed. Confirms name the
    drone and re-check before sending, and extension skills always confirm
    unless the vehicle is disarmed. Default skill keys no longer collide with
    built-in or reserved keys.
  • Brand theme. The default theme is the brand navy and blue palette,
    generated from the shared design tokens; the previous neutral look is the
    new "Mono" theme. Text, status and HUD colours meet AA contrast in every
    theme. Night vision overrides the chosen accent.
  • Extensions. Extension skills and target actions inherit their confirm
    and arm gates, write their config over the LAN or a ground station's relay,
    and are disabled with a reason on cloud-only reach. Parameters for every
    installed extension appear on the node's Extensions page and in cockpit
    quick settings, including a camera picker, grouped and translated through
    the extension's own locale. New cockpit.widget slot. Install, enable,
    disable and remove work through a ground station's relay, and rows show why
    an extension failed.
  • Armed actions ask first. When a node refuses an action because the
    vehicle is armed, including extension install, enable, disable and remove,
    Mission Control asks whether to continue and retries with an explicit
    override. Sensor calibrations cannot start while the vehicle is armed or its
    arm state is unknown.
  • Fleet identity. When two aircraft behind one ground station share a
    MAVLink system id, a blocking banner names the id and commands to it are
    held. A relayed drone opens its MAVLink session only once its system id is
    known, and accepts frames from that id only. Live video follows the
    selected drone, with a "Show this drone" action.
  • Agent install command. Every install command uses curl -fsSL with the
    installer from the agent repository's main branch. The agent catalog is
    embedded, and board profiles match with wildcards.
  • Firmware flashing. ArduPilot images go through the bootloader protocol
    with a matching CRC; USB DFU needs the _with_bl.hex image. Parameters are
    backed up (browser storage and a .param download) before flashing and can
    be restored afterwards from a diff. Flashing needs a USB cable to the flight
    controller and is held after an incomplete parameter download. CAN node
    restart, erase, bootloader and node-id changes ask for confirmation and are
    refused while armed.
  • Planner. Terrain samples are dropped when a waypoint moves and the
    validator reports "terrain unknown" until resampled. Every waypoint carries
    an explicit altitude frame, and pattern generators plan relative to home.
    Planner shortcuts work on any keyboard layout.
  • Flight logs. Recordings are stored in chunks with no frame cap and are
    never evicted while a flight references them; a full disk is reported. ULog
    and tlog import in a worker with progress and cancel.
  • Video. WHEP requests send the node key only to the node's own origin and
    close their session on teardown. Detail views hold the high-quality video
    profile while they play and release it when they close. Cloud WebRTC
    signaling is matched by session and closed on teardown.
  • Vision. When the agent reports detection is not running, the cockpit
    chip and pipelines panel say so, and clear when detections resume. A model
    downloads before its detector can be selected.
  • Desktop app. On Windows and Linux, as on macOS, updates install only
    when the operator asks, because the builds are not code-signed. The UDP peer
    is re-learned after silence, permissions are granted to the exact app origin
    only, and installing an update is blocked while a vehicle is armed.
  • Node capabilities come from what the agent declares, not from a SoC
    table.

Fixed

  • Protocol. MAVLink transfers share one state, so a second parameter or
    mission download works after the first. A refused command raises an error,
    MISSION_ACK refusals are shown, stream rates are set once, and transfers
    clean up after errors. MSP arming is confirmed from the vehicle's status,
    and MSP link loss is detected. BLE and WebSocket send queues are bounded.
  • Readouts. Parameter send failures and incomplete downloads are shown with
    a retry. Radio state, relay fragments and TX power readback show as measured
    or unknown. Signing changes the flight controller did not confirm are
    reported. Network writes that drop the link ask first.
  • Gamepad calibration is stored per device.
  • Reconnects. Sockets and video players retry on a fixed cadence and never
    give up. Relayed nodes show why a relay ticket was refused, and relayed logs
    support live tail and export.
  • Flight logs. ULog array fields parse correctly, and re-importing a file
    no longer duplicates it.
  • Server routes. The firmware proxy streams from allowlisted sources with
    a size ceiling, PID analysis has a timeout and spends quota only after a
    delivered answer, concurrent manifest requests share one fetch, and sign-in
    cookies work on a plain-http LAN self-host.
  • Downloading an empty mission leaves the open plan alone. Betaflight polling
    survives transient errors. Community HTML is sanitized. Fleet rows stay
    stable, and extension frames get a grace period before unmounting.
  • Many smaller fixes across hardware pages, input calibration, replay, vision
    overlays, DroneCAN tools, offline maps, mesh and role error copy, and
    translations.

Security

  • The LAN-pair proxy and the MCP activity feed answer only when the page is
    served from a local host (l...
Read more

0.59.0

Choose a tag to compare

@github-actions github-actions released this 25 Sep 08:06

Altnautica Command v0.59.0

This release covers everything since 0.58.0: forty-two commits over two and a
half weeks. Three threads run through it.

The first is what reaches the vehicle. A full pass over the protocol code
corrected wire tables, codecs and message offsets that could configure a
vehicle other than the way the operator asked: the RC protocol bitmask was one
bit off, several iNav and Betaflight mode ids pointed at the wrong mode, PX4
integer parameters and DroneCAN parameters were packed incorrectly, and the
ArduPilot home slot was not reserved on mission upload. MAVLink signing now
follows the MAVLink v2 specification and signs every outgoing frame. Planned
speeds, landing approaches and geofence altitude floors now reach the flight
controller, and a truncated mission, rally or fence download is rejected rather
than accepted as a short plan.

The second is readouts that stay true to their source. Controls that reported
success now wait for the vehicle's own acknowledgement, a value the vehicle
never reported shows as no-data instead of zero, and a reading that has gone
stale is dimmed, aged or cleared. Every node page now reads and writes the node
it is showing, never whichever node was focused last.

The third is the extension platform. First-party extensions can run inline in
Mission Control after a signature check, add their own Agent sidebar pages and
node tabs, and keep small records in the operator's cloud account. The World
Model, Live World, Atlas relay and workstation compute pages now ship in the
World Engine extension (com.altnautica.world-engine) rather than in core, and
battery health is now a built-in Battery page on drone nodes.

Added

  • Custom self-hosted basemap. Point the map at your own tile server (for
    example http://localhost:8080/tiles/{z}/{x}/{y}.png) and fly with no
    internet. Set it from the on-map layer picker (CUSTOM) or Settings > Data
    with a URL template, a max zoom (1-24) and optional attribution; it applies on
    Apply, not per keystroke. The template is checked inline (http or https,
    {z}, {x} and {y} exactly once each, no TMS {-y}), an empty or invalid
    one falls back to the dark basemap with a warning, and a readout ("N tiles
    loaded, M failed" plus the last failing URL) makes a wrong URL easy to spot.
    The offline Download Area panel downloads the custom source up to its max
    zoom and caches it under the same URLs the map reads. Closes #55 (#68).
  • Battery page on drone nodes. A new Agent sidebar page, reachable directly
    or through a ground station's relay, polls the node's battery engine every
    2 s. Each pack shows a cell bar with the weakest cell marked, voltage,
    current, remaining, temperature and consumed mAh and Wh, a time-to-reserve
    prediction, the anomalies currently raised (cell_critical, cell_low,
    cell_divergence, voltage_drop, temp_spike, predictive_low) and the
    last 20 raise and clear events. The rules run on the node, so they keep
    working with the page closed; a newly raised anomaly is announced once as a
    toast and as a battery:<rule> marker on a running telemetry recording. A
    value the flight controller does not report reads as not reported. The page's
    Setup segment edits the node's battery.* thresholds. Demo mode serves two
    4S packs, one with a cell-divergence warning.
  • Inline first-party extensions. A plugin whose manifest declares
    gcs.isolation: inline runs its GCS half as a module inside Mission Control
    instead of a sandboxed iframe; the iframe stays the default. The module loads
    from the node running the plugin (attestation, manifest.yaml, gcs/ files)
    or, for a GCS-only install, from a pinned published archive. Loading shows a
    status line, a load or mount failure shows an error card with Retry, a crash
    is contained by an error boundary, and the host never falls back to an
    iframe. Every call still passes the same method, token and capability checks
    as an iframe plugin.
  • Inline host API. host.agent.fetch and host.agent.websocket reach the
    plugin's own server on the mounted node (/api/plugins/{id}/x/<path>);
    host.nodes.agent(deviceId) reaches it on any other node over LAN or a
    ground station's relay and rejects with node_unreachable when this browser
    cannot reach the node; host.readAsset(path) and host.assetUrl(path) serve
    files from the plugin's gcs/ directory; host.nodes.list() carries each
    node's lanHost; host.nodes.pluginConfig(deviceId) and host.navigate()
    round it out. Object URLs are revoked and sockets closed on unmount.
  • Extension pages in node detail. gcs.contributes.agent_pages[] adds Agent
    sidebar pages (section, after, order, profile, and setup_for to
    become another page's Setup segment); gcs.contributes.node_surfaces[] adds
    top-level node tabs into a declared group (status, vehicle, link,
    device, compute) for the listed profiles. Capabilities
    ui.slot.node-agent-page and ui.slot.node-surface.
  • Plugin cloud records (cloud.records). A plugin can list, read, write and
    delete small JSON records in its own namespace in the operator's account,
    optionally tagged with a node: 64 KiB per record, 5000 records per plugin per
    user, pages of up to 100. The agent half can write through
    POST /agent/plugin-records. Records are purged on uninstall and when a
    device is wiped, and refusals come back typed (unavailable, invalid_args,
    too_large, limit_reached, not_permitted, failed).
  • /api/lan-pair/plugin proxy, so Mission Control served over HTTPS can
    reach a plain-HTTP LAN node's plugin routes (attestation, manifest, state,
    config, gcs/<path> and the plugin's own x/<path>), directly or through a
    ground station's relay.
  • MAVLink command resend. Commands that are safe to repeat (arm and disarm,
    mode, RTL, land, reposition, pause and continue, change speed, set home,
    fence enable, relay, servo, mount, ROI, orbit, message interval and request,
    CAN forward, EKF source set) are resent up to twice when no COMMAND_ACK
    arrives, with the confirmation byte incremented. Commands that would act
    twice (camera trigger, calibration, motor test, takeoff) are still sent once.
  • Geofence altitude floor and fence parameters. A fence upload also writes
    enable, FENCE_TYPE (including the ArduPilot 4.1+ floor bit), floor,
    ceiling and breach action, so the flight controller enforces what the planner
    shows. PX4 has no floor, so a non-zero minimum is refused with a message.
  • Leg-versus-fence check. The validator blocks a leg whose straight line
    leaves a concave fence or crosses a no-fly zone, even when both waypoints are
    on the allowed side.
  • Upload receipts. "On aircraft" indicators for mission, fence and rally
    compare the hash the flight controller acknowledged with what the planner
    would upload now; an edit, plan switch, drone switch or disconnect clears
    them.
  • Live pre-flight checklist. The automatic checklist items re-evaluate for
    the selected drone on every telemetry update, even with the modal closed.
    Stale telemetry returns an item to pending, a drone switch resets the
    session, and the Arm and Take-off confirms read this readiness.
  • Fleet alerts from live telemetry. Dashboard alert counts come from each
    connected flight controller: STATUSTEXT at CRITICAL or worse, failsafe
    announcements, the battery entering the warning or critical band, and link
    loss, each raised once per occurrence.
  • Failsafe audio alert for ArduPilot and PX4 failsafe announcements, not
    replayed for "cleared" or "resolved" messages. Warning and error toasts follow
    the alert popup duration setting.
  • DroneCAN session card on the CAN page with an explicit open and close
    control and bus selector, shared by node parameters, diagnostics, test tools
    and the AP_Periph flasher. A duplicate node-id scan uses repeated GetNodeInfo
    samples and the NodeStatus uptime stream.
  • New flight controller surfaces: a PX4 power and battery-failsafe section
    (BAT1_SOURCE, BAT_LOW_THR, BAT_EMERGEN_THR, COM_LOW_BAT_ACT); an
    ArduPilot OSD editor built from the OSDn_<ITEM> parameters; the PX4 airframe
    picker on SYS_AUTOSTART; ArduRover and ArduSub frame and flight-mode
    support; the full ArduPilot MNT1_TYPE and CAM1_TYPE lists and PX4 mount
    and trigger inputs; iNav six-orientation accelerometer calibration; a
    Betaflight PWM range slider with both ends draggable; a GNSS constellation
    editor; iNav geozone circles; and safety enums (RC options, serial protocols,
    battery, fence and failsafe actions, GNSS, sensors) rendered from parameter
    metadata.
  • Video source badge and frame age. The video canvas names where the
    picture comes from (DIRECT, VIA GROUND, VIA CLOUD, MANUAL) and how old the
    displayed frame is, labelled by source (SEI timestamp or browser frame
    metadata). HUD instruments and plugin overlays read attitude at the frame's
    capture time (frameAgeMs, attitudeAtFrameTime).
  • Minimal HUD (/hud?layer=minimal) for small SBC displays: a small horizon
    and two text lines over video.
  • Remote-access tunnel control on a node's Cloud page, with a confirmation
    before turning it off and a status row that re-reads the node every 5 s.
  • Ground station: a Display settings page (boot renderer, kiosk), an
    access-point editor (name, channel, write-only passphrase) that shows the
    AP's own read-back, and a Carried drones tab listing each relayed drone, when
    it was last decoded and what command authority this browser holds.
  • Node reach block. Names the address a LAN node was last reached at and the
    last failure (nothing answered, answered and refused, internal fault), with a
    "Use " action to switch address without re-pairing.
  • First-run screen. With nothing paired, the dashboard shows the agent
    install one-liner, live LAN d...
Read more

0.58.0

Choose a tag to compare

@github-actions github-actions released this 08 Sep 04:03

Altnautica Command v0.58.0

This release covers everything since 0.57.3, about six weeks of work. Two
threads run through it.

The first is reach. A drone that can only be heard through a ground station's
radio is now a first-class node: it gets the whole agent surface, every
configuration page, extension installs, cockpit video and live vision
detections, and it commands with the vehicle's own acknowledgement coming back.
Above that sits a Swarm tab for flying a fleet from one screen, and below it a
credential model where an operator holds their own expiring, device-scoped
broker grant instead of a shared read-only one.

The second is honesty. Nine protocol constants addressed the wrong message or
sent the wrong command. A waypoint altitude meant two different things depending
on which surface read it. The cockpit painted a dead link as live telemetry, the
HUD drew a level horizon with no attitude data, and the badge whose only job is
to announce a stale link could never appear. A browser holding a receive-only
relay credential showed a healthy commanding link while the broker discarded
every frame it sent. All of that is corrected, and most of it is now provable in
demo mode without hardware.

Added

  • A Swarm tab, a fourth fleet-overview surface beside Grid, Overview and
    Nodes, for flying a multi-drone fleet from one screen. Five bands in
    summary-then-exceptions-then-detail order, because 20+ healthy rows have to
    visually disappear for the unhealthy one to be findable: a severity summary
    strip whose chips filter the table, a fleet action bar (Hold, RTL, Land,
    Set-Formation), a dense one-row-per-slot table sorted unhealthy-first, a
    Leaflet fleet map with marquee select, and a video rail. Arm and Disarm are
    deliberately absent from the bulk actions: arming is the one action whose blast
    radius grows with the selection.
  • Each row renders separate glyphs for armed, guided, emergency and GPS
    rather than blending them into one colour, since each is an independent
    condition, and shows the currently active arbitration level rather than the
    commanded mode — a drone whose separation layer has taken over reads
    hard-separation even while a formation is commanded.
  • Make Hero is a new primitive, not a rename of Pin. Pin is multi-select,
    personal and bandwidth-neutral; Hero is exclusive and changes the aircraft's
    actual radio allocation by demoting the previous hero to a 1 fps thumbnail. It
    has its own verb and icon, and the UI renders the beacon's own hero bit as
    truth, so a failed demotion is visible rather than assumed.
  • Fleet-wide actions carry two independent gates: the existing typed-phrase
    confirmation plus a broadcast toggle that must be armed first and self-reverts
    to per-selection after five seconds. Alerts aggregate rather than enumerate —
    "3 drones low battery" is one chip, not three rows.
  • swarm-beacon-store holds live neighbour beacons keyed by fleet slot, fed by a
    2 Hz bridge against the ground station's /api/swarm/neighbors with back-off
    when a host does not answer. Deliberately not persisted: a beacon with a
    three-second shelf life rehydrated from disk would render a dead aircraft's
    last position as current. A slot the fleet registry knows about but that is
    currently silent gets its own row rather than vanishing from the board, and an
    unprovisioned node reads as unprovisioned rather than defaulting to fleet 1.
  • A Radio settings page under Link & network, carrying fleet addressing, the
    link switches, and modulation. The fleet slot is read-only because the ground
    station assigns it and hand-editing it degrades the shared channel for every
    node on it. The modulation band shows the manual rung only while the adaptive
    ladder is off and otherwise a read-only live readout of the applied rung and
    measured SNR, so the operator always sees which rung is actually live. No
    channel-width control, because the transmitter is pinned to 20 MHz.
  • The per-node Swarm settings page is expanded in place: formation is now a
    closed set of five built-ins instead of free text (a typo previously produced
    no formation at all, silently), flocking gains sit behind an Advanced
    disclosure with their applied float stated, the two separation values are held
    behind a confirmation because they are the safety envelope, task allocation
    shows the assignment and not the algorithm, and the arbitration ladder is shown
    read-only.
  • A drone reached only over a ground station's radio now gets its whole agent
    surface.
    Clicking it connects, the Agent tab and its sub-nav render for real,
    every configuration page resolves through the relay instead of reporting that
    the node configuration could not be read, the Status tab's companion band
    appears, the Extensions tab lists what is installed and can install over the
    relay, and the cockpit gets the ground station's video and polled live vision
    detections. Commands return the vehicle's own acknowledgement, and a "WFB
    relay" transport label appears wherever the reach chip is shown. Log tailing
    and the camera roster stay deliberately unavailable over the relay rather than
    quietly answering with the ground station's own data.
  • Command authority is now a first-class state, separate from a socket being
    open.
    The flight-controller uplink publishes at a quality of service that
    acknowledges nothing, so a browser holding a receive-only broker credential
    kept a transport that read healthy while every frame it sent was discarded with
    no error to catch. The cockpit safety band gains a CMD chip that appears only
    while authority is limited or ending (RECEIVE ONLY, AUTHORISING, ENDING SOON), the flight data card's Link dot is graded on whether a command can
    actually be published and explains itself in one line underneath, and the
    sidebar row, fleet tile, nodes-board reach cell, node-detail header and the
    Overview parameters tile each carry the same badge. The health ring is left
    alone: a node can be alive and uncommandable at once, and one channel cannot
    carry both.
  • Per-operator broker write grants. An operator requests command authority
    from the drone overview and receives their own broker principal, scoped
    server-side to the drones they own, expiring on its own after an hour, renewed
    ahead of expiry, revocable instantly, and confirmed by the first publish the
    broker actually accepts. The plaintext secret is returned once at mint and
    never persisted — the database keeps only a verifier, the same bar the broker
    itself holds — and it is deliberately kept out of store state so no persist
    wrapper or devtools serialiser can pick it up.
  • A World Model generation card. The paired compute node publishes a
    descriptor stream for each completed reconstruct generation, and the GCS now
    subscribes to it and renders the generation's four artifact slots (Gaussian
    splat, point cloud, mesh, occupancy grid) in the drone's world-model surface
    and in the Atlas setup surface. A slot the generation did not produce stays
    absent rather than rendering an empty one, silence renders as "no world model
    was produced" rather than as a surveyed-and-empty world, and every stand-down
    reason is its own stated status. The page appears only when the node's own
    config surface advertises the world-model block, so an agent that predates the
    feature shows nothing rather than an empty page.
  • Image orientation on the Video settings page: rotation in 90° clockwise
    steps plus horizontal and vertical flip, applied on the encode pipeline before
    compression and taking effect at the next pipeline start.
  • Demo mode covers the new surfaces. A 14-slot simulated fleet with formation
    geometry, a synthetic swarm bus, hero promotion and fleet-wide config fan-out
    makes the whole Swarm tab explorable with no hardware. The iNav demo vehicle
    now renders the flight-controller configuration surfaces its firmware badge
    advertises — mixer and servo rules, per-timer output modes, temperature
    sensors, serial ports, battery profiles, OSD layouts and EzTune — and a save
    then reload round trip behaves as it does on hardware. Demo mode can also
    produce a genuinely stale link on demand, which is what makes every
    freshness-gated surface verifiable offline; the staleness bugs fixed in this
    release previously only appeared on a real link loss in the field.
  • New plugin permissions and contracts: msp.read and msp.write for MSP
    flight controllers, the second marked high risk because it can drive the RC
    channels and arm the aircraft; vision.model.read for a plugin's own resolved
    model delivery status; a janitor sidecar carrying disk-janitor footprint,
    budget and reclaim state; a wfb-pair-proof sidecar carrying whether a radio
    key has ever been confirmed to carry a link and the remaining auto-pair re-arm
    budget; and an aux.link_feedback contract so ground-measured video link
    quality reaches the transmitting drone and its bitrate ladder steps on a real
    loss sample instead of the sentinel a transmit-only radio can never leave.

Changed

  • The node Agent page is one sub-nav instead of three stacked sidebars. All
    seventeen configuration pages are now entries beside the live surface for the
    same subsystem, twenty-five entries across Overview, Link & network, Video &
    vision, Cloud & remote, System & safety and Software, with an empty section
    omitted entirely. The Atlas page reads "World model setup" and the vision
    settings page reads "Perception setup".
  • The Video settings page is camera, encode and orientation only; every
    video.wfb.* field moved to the new Radio page. Video is offered on drone
    profiles alone — a ground station encodes nothing, and its radio fields live on
    the page it does get. A profile that fills none of a settings group no longer
    renders that group's header.
  • **Settings ...
Read more

0.57.3

Choose a tag to compare

@github-actions github-actions released this 27 Jul 11:27

Altnautica Command v0.57.3

A third follow-up patch to 0.57.0, shipping three hotfixes that landed the
day after 0.57.2. Everything below is otherwise unchanged from 0.57.2,
repeated here so an update from before that release carries the full picture.

Added

  • Four-firmware flight controller configuration. ArduPilot, PX4, Betaflight
    and iNav each gain deep configuration surfaces. ArduPilot adds rover steering
    and speed tuning, an EKF3 estimator panel, telemetry stream rates, QuadPlane
    and VTOL, plane energy and navigation tuning, ArduSub, traditional
    helicopter, non-GPS positioning, multi-instance rangefinders, airspeed,
    harmonic notch, sailboat, gripper and ADS-b. PX4 adds flight behavior,
    fixed-wing tuning, autotune for multicopter and fixed wing, VTOL transition,
    GPS, control allocation, live actuator test and thermal calibration.
    Betaflight adds serial ports, OSD with font upload, LED strip with a 16-colour
    palette and mode-colour editor, receiver configuration, DShot special
    commands, blackbox download and a CLI terminal with live output. iNav adds
    per-index logic conditions, live global variables, OSD font upload and
    editable landing datums.
  • Parameter metadata registry with bitmask and enum editors. Parameter
    metadata now ships bundled with the app, so full names, ranges, units,
    defaults and per-bit flag descriptions are available offline for every
    firmware rather than only when an external site is reachable. A Set Bitmask
    modal gives you labelled per-bit checkboxes with search, raw decimal and hex,
    and preservation of bits it does not recognise, so an undocumented flag is
    never silently cleared. Enum parameters get a real dropdown. An Options column
    shows the decoded value at a glance, and the write confirmation shows the flag
    difference before you commit.
  • A hosted parameter registry overlay. On top of the bundled floor, the app
    can pull versioned metadata snapshots so parameter help matches the firmware
    version actually on the board. iNav gains its full named-settings registry of
    677 settings.
  • A JavaScript expression compiler for iNav logic conditions. Write a plain
    expression and it compiles down to the underlying logic-condition slots
    instead of hand-assembling them one row at a time.
  • Onboard Lua scripting for ArduPilot. A Scripts section under Setup manages
    the scripts on the board over MAVLink file transfer, with upload by drag and
    drop, download, delete, engine configuration and a filtered script console.
    A starter catalog of first-party applets is one click to install.
  • MAVLink file transfer, structured events and native sockets. The file
    transfer client now writes, lists and removes as well as reads, and is
    hardened against a lossy or hostile server. PX4 structured events (message
    410) decode into a readable feed backed by the vehicle's own event metadata,
    so prearm, mode and failsafe messages are finally visible. Parameter metadata
    can be served by the flight controller itself. The desktop app connects over
    native UDP and TCP in addition to serial.
  • Mission planning, rebuilt. The Plan tab gains a survey solver that works
    backwards from the ground sample distance you want to an altitude and a
    motion-blur-safe speed, wind-optimised line orientation, fixed-wing turnaround
    geometry, keep-out polygon skipping, a coverage footprint overlay, a quick
    builder from the map bounds, and a change-detection resurvey planner. Landing
    patterns cover fixed wing and VTOL.
  • A per-waypoint action timeline. Actions attach to the waypoint they belong
    to, edited inline with reordering and a jump-target picker, and flatten and
    re-nest correctly across upload, download, export and import. The command
    palette filters to what your firmware actually supports.
  • Mission checks before you fly. Upload is blocked while validation errors
    stand. Inclusion and exclusion zones, rally points and terrain clearance are
    enforced, with a soft-buffer warning short of a hard breach. Terrain conflicts
    are flagged along each leg and on the return-to-launch leg. There is an
    advisory item-count check against the flight controller, a keyless airport
    proximity gate, a flight energy model, sun times with a golden-hour card and a
    pre-flight checklist.
  • Weather, import, export and sharing in the planner. A keyless go/no-go
    weather card, boundary import from KML, KMZ and shapefiles, GeoTIFF orthophoto
    overlay, a flight-brief PDF export, a built-in mission template library, plan
    folders, points of interest, and shareable plan links that encode the plan in
    the URL fragment so nothing leaves your machine.
  • A copilot for mission intent. Describe what you want in plain words and a
    deterministic parser sets up the matching pattern. No key and no external
    service.
  • Coordinates and units throughout. Live cursor coordinate and elevation
    readout, a display-format preference across decimal degrees, degrees minutes
    seconds, UTM and MGRS, forward geocoding search on the map, and one shared
    units formatter behind the stats bar, pattern stats and altitude profile.
  • The Cockpit. The old Fly Mode is now the Cockpit, split into a Flight tab
    and an immersive Cockpit tab. Flight behaviors are skills bound to hotkeys and
    gamepad buttons on a shared skill bar, contributed by built-in commands and
    extensions through the same registry. Widgets are arrangeable by zone and
    persist with your loadout, information density is a per-loadout setting, and a
    command palette on Ctrl or Cmd plus K searches and runs any drone command
    through the same pipeline. The safety band showing arm state, battery, GPS and
    link never hides.
  • Target designation in the Cockpit. Click a detection to designate it. A
    what-is-locked chip names the current target, an aim-ahead lead reticle tracks
    a moving one, and extensions contribute their own target actions into the
    click popup with their own hotkeys. Detection boxes ease between batches so
    they follow motion instead of stepping.
  • Multi-camera video with picture-in-picture. A node exposing more than one
    camera gets stream tabs at the top left, switched by the number keys or by
    cycling. A second stream can be pinned as a picture-in-picture inset whose
    position persists per loadout. Concurrent streams flip instantly by
    re-pointing at each leg's own address, switching is debounced so a rapid flip
    cannot stack encoder restarts, and a dead leg is disabled rather than shown
    as live.
  • Camera roster management. A Cameras surface on the node detail reads the
    roster from the agent and round-trips per-leg bitrate and calibration.
  • A Nodes fleet board. A third dashboard view mode renders a dense live
    table ordered live, then stale, then offline. Each row carries reach, link,
    battery, mode and role, with per-row controls that act on that node over the
    LAN or the cloud queue. Rows support selection, bulk apply-one-change and
    search, and flight controls are gated on the same liveness the board shows.
  • A unified per-profile node console. One console adapts to the node in
    front of you across drone, flight controller, ground station and workstation,
    with a profile-aware hero header, sidebar and overview. The agent dashboard is
    folded into Overview, the last tab you used is restored per node, and a
    per-node feature framework lets you opt a drone into World Model capture.
  • A node Settings tab with thirteen configuration pages. Network uplink,
    Wi-Fi scan and join, cellular APN, MAC pinning and adapter stability,
    self-heal and link guardian, MAVLink routing, security, vision and
    perception, world model, discovery and reach names, video and cameras, and
    cloud, organised behind two-tier grouped navigation and reachable over the
    LAN or the cloud.
    Security downgrades and link-affecting toggles ask for confirmation first.
  • Relayed enrollment and a live mesh map. A drone linked to a paired ground
    node over the radio enrolls as its own node, nested under the ground node that
    carries it, with per-bearer reach provenance rather than a bare label. A live
    node-to-node mesh and reach map names each relay funnel.
  • Extensions. What were called plugins are now Extensions, on a contribution
    platform. One manifest block contributes tabs, settings sections, parameters,
    models, mission templates, map overlays, skills, target actions and tools, all
    resolved through one registry so a built-in surface and an extension surface
    are the same shape. Parameters are described by JSON Schema and rendered
    natively. Install works from the registry, from a URL pinned to the bytes the
    agent reviewed, and local-first from a paired agent over the LAN with no cloud
    round trip. The install dialog was rebuilt around trust signals, capability
    chips and a contributions summary.
  • An MCP tab. Connect an AI client to your fleet through the Model Context
    Protocol. A guided local-first setup wizard takes you from nothing to a
    connected client in five steps with a live connection check, including a
    one-command option that covers every drone on your LAN with no file and no
    login. Machine credentials are scoped by capability and by node with an
    expiry, and there is a searchable tool catalog, an audit log and a live panel
    that shows calls as they happen.
  • Perception. The Vision tab is now Perception, grouped into engine,
    execution, feed health, inputs and models. A drone without an accelerator can
    offload detection to a paired workstation, configured per node, with the tier
    and target surfaced honestly in the Cockpit beside streaming-session health.
    Detections carry lock state and association confidence, are keyed by model and
    camera stream, and reach the app over the cloud relay as well as the LAN.
  • ADOS Workstation. The compute profile is now the Workstation, with a
    ...
Read more