Repository navigation
Releases
ANet Relay v0.5.4
Firmware twins fly the official PX4 and ArduPilot firmware against Relay's
physics with a real aircraft's version and parameters, PX4 flight controllers
on USB run hardware in the loop, and the simulator gains frames, acro mode and
crashes that tumble.
Added
- Firmware twins (SITL). The desktop build of the official firmware, the
same version as the real aircraft and loaded with its parameters, runs as a
child process of Relay in lockstep with Relay's physics. To the rest of Relay
it is a simulator: claims, sticks, skills, plans, timelines, programs, the
stage and the arena work unchanged, with the firmware's own control loop,
arming checks and failsafes. The firmware only talks to Relay on loopback.- The pack's firmware on screen: Settings → Autopilot packs, an Add
simulator dialog with the fast simulator or a firmware twin, a firmware
block in the inspector (identity, Generate twin profile, Start twin) and a
twin inspector with the process, lockstep and parameter details. - Relay identifies a real aircraft's firmware (family, version, git hash,
board) and ranks the installed packs: exact, version, series, nearest. - Twin profiles capture an aircraft's whole parameter table; calibration,
device ids, serial ports and other hardware-specific parameters stay out,
each with its reason. - Frame presets
micro-120,small-250andlarge-450with adjustable
mass, wheelbase, propeller and battery; a twin hovers at the same throttle
as the real aircraft. - Without a real aircraft, a twin starts from any pack with its default
parameters and a baseline tuned to hover out of the box.
- The pack's firmware on screen: Settings → Autopilot packs, an Add
- Autopilot runtime packs ship with the installer: ArduCopter 4.7.2,
4.6.3, 4.5.7, 4.4.4 and 4.3.8, PX4 1.17.0, 1.16.2, 1.15.4 and 1.14.4 (PX4
not on Windows). 1.7 to 2.6 MB compressed per pack (Windows ArduCopter packs
about 4.4 MB with their Cygwin DLLs), 16 to 22 MB per installer.
Settings lists them and imports further packs. Format:
docs/autopilot-packs.md.- ArduPilot packs built from source bind SITL's RC input and the JSON
physics socket to 127.0.0.1 ("loopback": truein the manifest), so no
firmware socket listens on other interfaces. The linux-x64 ArduPilot packs
are now static builds from source; the official binary stays available as
a build option.
- ArduPilot packs built from source bind SITL's RC input and the JSON
- Hardware in the loop (PX4). Over a USB serial link Relay backs up the
flight controller's parameters, switches it to HITL, feeds it sensor data
from its physics while the firmware keeps the motors locked, and afterwards
restores and verifies every parameter. A step-by-step dialog in the
inspector shows each stage. ArduPilot removed HIL support; Relay explains
this and recommends a firmware twin.- Only
SYS_HITLandSYS_AUTOSTARTchange; the whole parameter table is
backed up first, and the restore reads every parameter back and compares
it with the backup (flight-time counters and the flight UUID excepted). - Starting needs the operator to type HITL, a disarmed aircraft and the
operator's possession. - If Relay quits during a session, the parameters are restored the next
time the board connects over USB, once it is disarmed. - The flow is tested against a scripted PX4 board on a pseudo-terminal; the
full flow on a real board is verified once the larger PX4 aircraft is
available.
- Only
- Serial link. Connect an aircraft over a USB serial port (the flight
controller's own USB socket or a USB-serial adapter) from the USB serial tab
of the Connect dialog; known flight-controller interfaces and USB-serial
adapters are marked and the baud rate is detected automatically. An
unplugged board goes delayed, lost and offline like a UDP aircraft and
reconnects when it comes back, also under a new device name. Needs pyserial
3.5, which ships with the backend. - Simulator physics.
- Rigid-body ground contact at the feet, propeller tips and top: a normal
landing stays upright, a crash bounces, rolls and comes to rest in its
final attitude. Reset restores it upright. - Acro mode in the fast simulator: the sticks set body rates with no
self-levelling or tilt limit, so it flips, rolls and flies inverted.
Timelines takemode: "acro". - Sensors with noise and bias for the twins and HITL: IMU, barometer,
magnetometer and GPS. - The stage interpolates attitude with quaternions, so flips and inverted
flight do not jump; twins and HITL aircraft carry an engine badge. - Reset simulator in the inspector, the fleet card menu, the command
palette and a prompt on the stage over a crashed simulator; holding
Circle on the gamepad also resets a crashed simulator. - Timelines arm with the throttle the mode needs: 0 on ArduPilot, 50 % on
PX4 in the hold modes.
- Rigid-body ground contact at the feet, propeller tips and top: a normal
- API:
GET /autopilots,POST /autopilots/import,DELETE /autopilots/{id},GET /vehicles/{id}/firmware,GET/POST /twins/profiles,GET/PUT/DELETE /twins/profiles/{pid},POST /sims
withengine,profile,pack,frameandhome,GET /sims/{id}/twin,
PUT /sims/{id}/frame,GET /serial/ports,POST /vehicleswithserial,
GET/POST /vehicles/{id}/hitl. Snapshot fieldstransport(udp,
serial,sim),serialandhitl. Eventstwin_started,twin_exited,
twin_start_failed,autopilot_pack_imported,hitl_started,
hitl_restored,hitl_failed. Errorspack_missing,pack_unsupported,
twin_start_failed,twin_limit,frame_unsupported,twin_unsupported,
profile_not_found,params_incomplete,hitl_unavailable,
hitl_restore_mismatch,serial_unavailable. - Copilot, MCP and SDK:
- Copilot and the flight MCP server:
relay_autopilots_list,
relay_firmware_identify,relay_twin_profiles_list,
relay_twin_profile_get,relay_twin_profile_capture,
relay_twin_start,relay_twin_statusandrelay_sim_frame, available
at both flight levels. The flight server now has 34 tools, 26 at the
sticks level. - Copilot and the app MCP server:
relay_hitl(status, start, stop; start
needsconfirm: "HITL"),relay_serial_ports, connecting over serial and
adding twins withengine: "sitl". The app server now has 67 tools. - Copilot asks the operator for every hardware-in-the-loop start and stop,
on any aircraft and also while Allow all is on; that approval card has
no Allow all button. - The SDK adds
autopilots(),firmware(),twin_profiles(),
twin_profile(),capture_twin_profile(),update_twin_profile(),
delete_twin_profile(),start_twin(),twin(),set_frame(),
serial_ports(),serial_ports_status(),connect()andhitl().
- Copilot and the flight MCP server:
Changed
- Resetting a firmware twin restarts its firmware with the same profile; as
before, a reset brings a crashed simulator back upright on the ground. The
Copilot and MCP reset tools say so.
ANet Relay v0.5.3
Stick timelines with their own file format, simulators that drift like a real
airframe in altitude hold, and a fix for real aircraft that would not arm from
the Lab.
Added
- Timeline sequences (
.ars, ANet Relay Sequence): four stick tracks
(throttle, pitch, roll, yaw) of blocks on one time line, opened from Control →
Timeline sequence, the command palette or Records → Open as sequence. The dock
under the stage shows the playhead while it flies.- Drag a block up or down to change its stick, drag its right edge to change
how long it lasts. The arrow keys nudge the stick by 0.01 and the length by
0.1 s. Blocks can be split, inserted and removed, edits can be undone, and
blocks hold or ramp to the next one. - Both sticks at a glance: a strip above the time line draws the two sticks
at every moment a stick changes, and two stick pads show them at the
cursor. Drag a pad to set both sticks from that moment on (Mode 1 or 2,
as in Settings → Controllers). - A trim on all four axes is added to every frame and changes in flight:
cancel a forward drift with a little negative pitch. - Edits to blocks not yet flown reach the aircraft at once.
- Record: the sticks an armed aircraft receives (gamepad, keyboard, plan,
program) become blocks. - Takeoff template, import and export of
.arsfiles. The same file flies
simulators and real aircraft (ARM confirmation on real ones). - API:
POST/PATCH /vehicles/{id}/sequence,
POST /vehicles/{id}/sequence/stop,POST /vehicles/{id}/sequence/record,
GET /history/sessions/{sid}/sequence; eventssequence_started,
sequence_edited,sequence_recording.
- Drag a block up or down to change its stick, drag its right edge to change
- Simulator airframe:
- Also with altitude hold (
with_assist): the CG offset, level error and
the other defects act with hover assist on, so a timeline can be tuned on a
simulator that tilts and drifts like the real aircraft. - Random level error per arming (
arm_bias_deg): a new error of up to 3°
at every arming, like a gyro bias that changes from flight to flight. - The inspector shows this flight's level error (
level_now_deg).
- Also with altitude hold (
- Copilot, flight MCP and SDK:
- New tools
relay_timeline_run,relay_timeline_edit,
relay_timeline_stop,relay_timeline_recordand
relay_timeline_from_record. The flight MCP server now has 26 tools, 18 at
the sticks level, where timelines fly in stabilize. airframe_settakeswith_assistandarm_bias_deg.- The SDK adds
timeline_*,load_arsandsave_ars.
- New tools
Fixed
- Real aircraft did not arm from the Lab. PX4 and ArduPilot arm STABILIZE or
ALT_HOLD only while they see pilot input ("No manual control input",
"Throttle below failsafe"), and a program released the sticks while the
aircraft was disarmed. Now:- Programs hold centred zero-throttle sticks while disarmed.
- An arming deployment sends them before it switches mode and arms.
POST /vehicles/{id}/armsends them first when nothing else feeds the
aircraft.- Skills that arm (take-off, plans, re-fly, timelines) send 0.3 s of
centred zero-throttle sticks before the arm command. - Simulators refuse to arm without pilot input, as the autopilots do.
- An aircraft that is already armed gets no zero-throttle sticks, and an
emergency stop or a change of control during the short wait cancels the
arm instead of arming after it.
- Timelines in the air never drop the throttle: one started in flight begins
on its own first frame, a stabilize timeline cannot start in the air on a
ground throttle, and a stop holds the throttle of that moment rather than the
one the timeline ends on. - Esc in the timeline dock first clears the block selection and otherwise
still stops the aircraft. Undo and redo reach an aircraft that is flying the
timeline.
ANet Relay v0.5.2
Programs can be tried out in the Lab with one click, sequences get adjustable
throttle, Copilot replies are formatted and copyable, and Copilot can be told to
stop asking for approval.
Added
- Lab: Arm and start on the Run tab (on by default). The deployment
switches to STABILIZE and arms once the program is in place, so it flies at
once; a real aircraft asks for the word ARM first. Stopping the program on the
ground disarms again. The Fly inspector's Program group follows the same
preference.POST /vehicles/{id}/programtakesarmandconfirm; the answer
reportsarm {ok, code?, reason?}, and the operator no longer has to possess
the aircraft for it. ctx.disarm(): a program disarms the aircraft after its landing; refused in
the air.- Built-in program
takeoff_hover_land: take off totarget_alt, hover for
hold_sseconds, land atdescentm/s and disarm. Every throttle value is a
parameter to tune while it flies; withlearnon it finds the hover throttle
itself. - Sequence throttle: the Control tab's sequence has a Throttle panel
(Climb, Hold) for aircraft without a position estimate, with the live height,
climb rate, throttle stick and motor output. Changes apply at once, also while
the sequence flies. API:tuning {climb, hover}onPOST /vehicles/{id}/plan,
PATCH /vehicles/{id}/plan/tuning, eventplan_tuned,plan.tuningin the
snapshot. - Copilot Allow all: from an approval card or Settings → Copilot. Commands
on real aircraft then run without asking and are still recorded in the chat; a
red badge in the Copilot title bar shows it is on and turns it off with a
click. Preflight, the Allow programs switch, possession and emergency stop are
unchanged. - Copilot formatting and copying: replies render Markdown (headings, nested and
task lists, tables with alignment, code blocks, quotes, links opened in the
system browser); the transcript is selectable, every Relay window has a
Cut / Copy / Paste / Select All context menu, replies, tables and code blocks
have copy buttons. - Copilot, the flight MCP server and the SDK:
tuningon plans and
relay_plan_tune/plan_tune();program_deploytakesarm.
Changed
- Deploying a new revision while a program flies takes over in the air without
landing (now covered by tests and stated in the Lab). - README animations are animated WebP (3.4 MB instead of 14 MB of GIFs).
Autopilot runtime packs v1
Autopilot runtime packs bundled with ANet Relay (docs/autopilot-packs.md), built from 107241b.
ArduPilot packs are GPL-3.0 and PX4 packs BSD-3-Clause; each manifest.json names its source tag.
| Platform | Packs | Size |
|---|---|---|
| linux-x64 | ardupilot-copter-4.7.2, ardupilot-copter-4.6.3, ardupilot-copter-4.5.7, ardupilot-copter-4.4.4, ardupilot-copter-4.3.8, px4-1.17.0, px4-1.16.2, px4-1.15.4, px4-1.14.4 | 22M |
| mac-arm64 | ardupilot-copter-4.7.2, ardupilot-copter-4.6.3, ardupilot-copter-4.5.7, ardupilot-copter-4.4.4, ardupilot-copter-4.3.8, px4-1.17.0, px4-1.16.2, px4-1.15.4, px4-1.14.4 | 16M |
| mac-x64 | ardupilot-copter-4.7.2, ardupilot-copter-4.6.3, ardupilot-copter-4.5.7, ardupilot-copter-4.4.4, ardupilot-copter-4.3.8, px4-1.17.0, px4-1.16.2, px4-1.15.4, px4-1.14.4 | 17M |
| win-x64 | ardupilot-copter-4.7.2, ardupilot-copter-4.6.3, ardupilot-copter-4.5.7, ardupilot-copter-4.4.4, ardupilot-copter-4.3.8 | 23M |
ANet Relay v0.5.1
Copilot shows what it is doing, reasoning models such as DeepSeek V4 no longer
end a turn in silence, custom dogfights describe each aircraft on its own, and
the README opens with a flatter animated banner.
Added
- Copilot run trace: every message gets a small red pixel aircraft that flies
while Copilot works and names the phase (waiting for the model, thinking,
writing, preparing a tool call, a tool running, waiting for approval) with
the elapsed time; while it is out of view the same chip sits above the input.
A click opens the trace: each model call with its time, input, output and
thinking tokens and stop reason, expandable to the full thinking, the reply
and the tool calls it asked for, and each tool with its arguments and full
result. The main process now forwards thinking, tool-argument drafting, usage
and stop reasons (run_start,turn_start,thinking,draft,run_end
and extendedassistant_end,tool_start,tool_end). - Settings → Copilot: Thinking (
auto,off,low,high) and Max
output tokens (1024–131072, default 16384, thinking included). - Custom dogfights:
POST /scenarios/dogfighttakesentrants(2–8), one entry
per aircraft withrole(gunner,rammer, orpilot, which never fires),
program,team,position(none,uwb,gps),paramsandlabel.
Copilot, the application MCP server and the SDK pass it through; Copilot maps
requests such as "A flies a figure eight and evades with global position, one
aircraft rams A, one shoots A" onto it in one call. POST /vehicles/{id}/programtakesteam: the aircraft's team in every
contact list, also written into a program'steamparameter.- Built-in program
figure8_evader: a figure eight around the arena centre on
a position source with a weaving height, and a sideways dodge with a height
change when a contact of another team closes in; it never fires.
Fixed
- Copilot with reasoning endpoints: the model was declared non-reasoning with a
4096-token output limit, so DeepSeek V4 could spend the whole turn thinking
and stop withlength, and the empty turn disappeared from the chat. The
limit is now configurable with a higher default, and a turn that runs out of
output or says nothing leaves a notice and its trace. - The Copilot setup text said the key is kept in the system keychain; it is
stored encrypted in the app data folder unless the keychain option is on.
Changed
- README banner: 960 × 300 animation with the ANet logo, the app icon and the
name over the formation shot; the loop fades back to its first frame.
ANet Relay v0.5.0
A rigid-body flight model with four rotors after Gazebo's motor model, collision
volumes for aircraft and rings, dogfights started in one sentence, matches and a
leaderboard shared across the LAN, and voxel explosions.
Added
- Collisions: every simulator is a sphere of 0.15 m and every ring a solid torus
with a 0.03 m tube. The fleet steps all simulators together at 250 Hz and
sweeps each step against the other simulators, the rings of the active course
and the aircraft of LAN peers, so fast aircraft never pass through each other.
At a closing speed of 2 m/s or more both aircraft crash; below it they bounce
with a restitution of 0.4 and the off-centre push upsets their attitude. A
shot-down aircraft keeps its volume while it falls. Ring passes count only
when the whole aircraft clears the tube; a pass that scrapes the tube still
counts and reportsring_touch. Eventscollisionandring_touch; the
crashedalert carriesreason_code(ground,collision,shot_down),
the point and what the aircraft hit. - Program observation:
obs.collision(the last contact within 1 s:t_ago,
with,v_rel,normal) andclosingon every contact. The evaluator makes
course rings solid and writescollisionandcrashevents into the trace. - Dogfights:
POST,GETandDELETE /scenarios/dogfightstart a timed fight
of 2 to 8 simulators (free-for-all or 2 or 3 teams) with gunners and rammers,
spawn points around the arena edge, the airframe, hover assist, respawn and a
seed. Relay adds the missing simulators, deploys each role's program, arms
the aircraft and lets the programs take off; at the end it stops them, lands
the aircraft and keeps the final standings. Off the LAN the arena runs in
practice mode without a socket. Real aircraft are refused
(dogfight_real_aircraft). Eventsdogfight_startedanddogfight_finished. - Built-in program
rammer: proportional-navigation pursuit of the nearest
enemy that weaves across the line of sight on the way in, a full push at close
range and a recovery state after the contact; it never fires. The hunters
side-step an aircraft that comes straight at them. New challengeram_easy
(bring down a hovering target by collision, guns off), ten challenges in all. - Matches and leaderboard: a match starts with a dogfight or with
POST /arena/matchon any terminal and resets the statistics of every
version 2 terminal;DELETE /arena/matchends it.GET /arena/leaderboard
withby=downs,survival,accuracyorramsmerges this terminal's
lines with those its peers report: controller, downs, hits, shots, accuracy,
rams, deaths, crashes, survival time, best survival time and damage. The
arena view carriesmatchandboard_rev. Eventsmatch_startedand
match_finished. - Arena wire protocol 2 with
COLLIDE,MATCHand a statistics block in
STATE. Each terminal judges contacts of its own aircraft only and sends
COLLIDEto the owner of the other aircraft, which checks age, distance,
rate and pair cooldown against its own view before it applies the same rule.
Packets that Relay 0.4 knows are still sent as version 1, so 0.4 and 0.5
terminals see each other and hit each other with rounds; collisions and the
leaderboard work between 0.5 terminals. - Copilot, the application MCP server and the SDK:
dogfight_start,
dogfight_stop,dogfight_statusandleaderboard(Copilot now has 113
tools in all, 105 atsticks; the application MCP server 65), and the SDK's
match_startandmatch_end. "A six-aircraft free-for-all, four gunners and
two rammers" maps to onedogfight_startcall. - Fly workspace: Start dogfight… in the Arena menu of the top bar opens a
dialog with the dogfight settings. A collapsible Leaderboard panel with
Downs, Survival, Accuracy and Rams tabs, the match countdown and End match
appears while the arena is on; this terminal's aircraft are set in bold. - Effects: voxel explosions for shoot-downs, rams and hard ground impacts (a
white-hot core, 60 cubes that cool from white to red to grey, fall and settle,
and a dust ring near the ground), sparks at light contacts, dust and debris for
ordinary crashes, and a short camera shake in the chase view within 5 m. Rings
are drawn as voxel tori with their real tube radius; the next ring is outlined
in white and flashes on a touch. A Collision volumes layer (off by default)
shows every aircraft's collision sphere and its hit sphere. Lab replays show
the same effects. Under reduced motion every effect is a still white cube. - Documentation:
docs/simulation.mdanddocs/simulation.zh-CN.md(what the
built-in simulator is for, the simulators in the field and how to connect PX4
SITL with Gazebo or ArduPilot SITL), and the dogfight, match, leaderboard,
obs.collisionandrammersections of the agent API and programs guides.
Changed
- Simulator physics: a rigid body with quaternion attitude and an inertia
tensor, flown by four rotors after Gazebo'sMulticopterMotorModel(first
order rotor speed with separate spin-up and spin-down times, thrust and drag
torque from the rotor speed, rotor drag and rolling moment) and body drag per
axis. A simulated flight controller runs an angle loop, a rate loop with
filtered derivative and limited integral, and a mixer that keeps attitude
priority when the motors saturate;SERVO_OUTPUT_RAWreports its outputs.
Airframe defects act physically: a centre of gravity offset is a moment,
motor differences are per-rotor thrust factors, a damaged propeller loses and
shakes thrust, and the level error sits in the attitude estimate. Hover
throttle stays at 0.50 and the top speed at 30 degrees near 7 m/s; the stick
map, modes and hover assist are unchanged. Flights are still deterministic
by seed. - Bullet tracers are 120 ms long with a larger head glow.
- Stage trails restart when an aircraft jumps more than 3 m between two
samples (a respawn or a reset) instead of drawing a line across the stage. - The leaderboard panel coalesces its reads at most four times a second
instead of aborting the previous read on every revision, so it keeps
updating while rounds are flying. - A shorter README in English and Chinese with new key art and animations, and
a wiki with the guides
that used to live in the README.
ANet Relay v0.4.1
Bullets and hits that read from across the arena, and a reworked set of opening
films.
Changed
- Bullets: every round is now a chain of voxel cubes with a white-hot head and a
bright red tail inside an additive glow. Cubes never shrink below a few pixels,
so rounds stay visible from far away. This terminal's rounds (or the first
aircraft's in a replay) are a lighter red than everyone else's. - Hits: every hit throws a voxel burst at the hit point, a white core that
swells and fades and red and white shards that fly out and fall. A shoot-down
throws a larger grey and red burst. Under reduced motion a still white cube
marks the hit instead. - Lab replays: duel and challenge replays now show the same tracers and the
bursts of every hit and shoot-down. Scrubbing back and forth shows the same
frame each time. - Opening films: three camera-move films are replaced by five new chase films
(tunnel, pillar slalom, dogfight, tower dive and water skim) in the style of
the chase. The director's cut opens on an action film, starting with the
chase, and then a cooperation film. The opening's length is unchanged.
ANet Relay v0.4.0
Onboard programs that fly at 50 Hz on the stick path, judged challenges and duels
between programs, agents limited to sticks by default, simulators with real
airframe defects, a Lab workspace for writing programs, Copilot that writes and
judges them, an opening that starts with the film, and Copilot keys stored without
the system keychain.
Added
- Onboard programs: restricted Python with
PARAMS,init(ctx)and
step(obs, ctx) -> Sticks, checked against an AST whitelist and run at 50 Hz
in an isolated program host process per deployment (--program-host; no
network or file access, a lower priority than the backend, memory and CPU
limits on POSIX and a 512 MB resident-memory watchdog on every platform). The observation holds only what
the aircraft measures: attitude, rates, accelerations, barometric height, a
position only where a source exists, battery, motor output, arena state and
contacts. Therelaylibrary providesclamp,wrap180,lerp,
deadband,lowpass,PID,StateMachineandTimer. Programs are stored
in<data_dir>/programs/with the last 50 revisions, their author and a note,
parameters and unit tests. Six read-only examples:hover_trim,liftoff,
patrolandhunter_easy,hunter_medium,hunter_hard. - Deployment:
POST /vehicles/{id}/programinpilotorcopilotmode, stop,
resume, live parameters (PATCH .../program/params), the log ring and
vehicle.programin the snapshot. The program holds the sticks as the
controllerPROGRAM · <name>on the stage and the relay timeline. Possession
pauses it at once and release never resumes it; emergency stop, link loss and
a crash stop it; the 0.8 s stick timeout is unchanged. Real aircraft accept a
program only after the operator turns on Allow programs on this aircraft
(confirm wordPROGRAM, reset on every connection) and preflight passes, and
theirfireoutput is ignored. Sevenprogram_*events. - Challenges and duels: nine challenges (
liftoff,hover,heading,
square,rings,pursuit,duel_easy,duel_medium,duel_hard) with
visible and hidden seeds whose airframes differ, scored 0 to 100 on the
simulator's true state, with best results and history. Duels of 2 to 8
programs in free-for-all rounds with a pairwise Elo ladder. Both run in a
headless evaluator in its own worker process (--judge-worker), at most two
jobs at once, deterministic for the same scenario, seeds and revisions. Every
judged seed and round keeps a 10 Hz trace of every aircraft and its rounds.
GET /challenges,POST /challenges/{id}/submit,POST /duels,
GET /jobs/{id},DELETE /jobs/{id},GET /ladder,GET /traces/{id}and
the eventjudge_finished. - Agent flight level: the setting
agent_flight_level,sticksby default
and changed only by the operator (Settings → Safety). Atstickssessions fly
with sticks, arming, the manual modes, fire, programs and the safety actions;
take-off, hold, move, turn, go-to, return, velocity and attitude skills, plans
that contain them, re-fly and the hold and automatic modes return 403
sticks_onlyover REST, WebSocket and MCP.landstays available as a safety
action. The flight MCP server lists 13 of its 20 tools at this level.full
restores every v0.3 tool; the operator's own controls are never limited. - Airframe defects for simulators with hover assist off: payload, centre of
gravity offset (an integrator corrects 70 % of the lean within 2 s), level
calibration error, unequal motors, a damaged propeller and IMU noise. Presets
ideal,typical(the default, settingsim_airframe_default) andrough,
or custom values, deterministic by seed.PUTandGET /sims/{id}/airframe,
airframeonPOST /simsand on a program deployment, the event
sim_airframe_changedand an Airframe group in the inspector. The
snapshot and the observation carry only the preset and the seed. Simulators
answerSCALED_IMUon request. - Lab workspace (key
4,⌘4/Ctrl+4): programs, examples and challenges on
the left; a CodeMirror editor with Python highlighting and problems from the
validator in the middle; Params, Tests, Run, Judge, Duel and History tabs on
the right. A Program group in the Control tab of the inspector deploys,
stops and resumes. Judged runs and duels replay with every aircraft and its
rounds on the Fly stage with the Records replay controls. - Copilot and MCP: 18 program, judge, duel and airframe tools in Copilot
(program_list,program_get,program_create,program_update,
program_validate,program_test,program_deploy,program_stop,
program_resume,program_params,program_status,program_log,
challenge_list,challenge_submit,job_status,duel_run,ladder,
airframe_set) plusrelay_arm,relay_disarmandrelay_mode, in every
tool scope (109 tools in all, 101 atsticks). Writing programs needs no
approval; deploying or resuming one on a real aircraft waits for the
operator. AtsticksCopilot drops the high-level flight tools and its
instructions say that stable flight needs a program. The same tools and
program_guidein the application MCP server (now 61 tools), and the same
calls in the Python SDK. - Documentation: the onboard programs guide (
docs/programs.md,
docs/programs.zh-CN.md), the compact programs guide shared with Copilot and
MCP (docs/programs-guide.md), and the program, judge, airframe and flight
level sections of the agent API guide. - Opening films: eight cooperation films (formation, hand-over, ground and air,
a quadruped launching a drone, a VTOL leading a swarm, assembly into a
formation, a gate race and a night search), and nine camera-move films
(barrel roll, pull-back with spin, fisheye, spiral climb, vortex orbit, FPV
flip, helix, dolly zoom and whip pan).
Changed
- Opening: the film now comes first, then the diagonal voxel cut and the voxel
logo, a short hold and the reveal (about 7.8 s for the director's cut, 4.4 s
for the short cut). The director's cut plays a camera-move film and a
cooperation film; the short cut rotates through all nineteen films by launch
count. Skipping
goes straight to the complete logo, held at least 300 ms. While the backend
starts, the logo waits with the progress line under it. - Copilot API keys: stored in
copilot-secrets.jsonin the app data folder,
encrypted with AES-256-GCM under a random per-installation key
(copilot-secrets.key); both files andcopilot.jsonare readable only by
the user's account. The system keychain is an opt-in setting
(Settings → Copilot → Store keys in the system keychain); Relay calls it
only then, never at start-up, when Copilot opens or when its status is read.
A key saved in the keychain by an earlier version is not decrypted on its
own: Copilot offers Enter key again or Keep using keychain. Relay
never reads or needs the login password. - Simulators created without an airframe get the
typicalairframe with a
random seed, so with hover assist off they no longer hover hands-off. - Agents and scripts that flew with skills or plans need the agent flight level
full; at the defaultsticksthey receive 403sticks_only.
Removed
- The
cut-breakthroughopening film.
Downloads
| Platform | File |
|---|---|
| macOS (Apple silicon) | ANet-Relay-0.4.0-mac-arm64.dmg, ANet-Relay-0.4.0-mac-arm64.zip |
| macOS (Intel) | ANet-Relay-0.4.0-mac-x64.dmg, ANet-Relay-0.4.0-mac-x64.zip |
| Linux x64 | ANet-Relay-0.4.0-linux-x64.AppImage, ANet-Relay-0.4.0-linux-x64.tar.gz |
| Windows x64 | ANet-Relay-0.4.0-win-x64.exe |
Verify downloads against SHA256SUMS.txt. The macOS build is signed and
notarized: drag it to Applications and open it. The Windows installer is not
code-signed; when SmartScreen warns, choose More info → Run anyway.
Known limitations
- The headless evaluator reaches more than 10 times real time with one
aircraft, 6 to 8 times with two and about 4 times with four. - The built-in programs pass
liftoff,hoverandduel_easy;heading,
square,ringsandpursuithave no built-in program that passes them yet. - On Windows the program host has no CPU-time limit; the 15 ms frame deadline
and the memory watchdog still end a runaway program.
ANet Relay v0.3.1
Fixed
- macOS installer window: the icon labels sit on graphite nameplates, so they
read clearly whether Finder draws them black (light appearance) or white
(dark appearance). In 0.3.0 the black labels of the light appearance were
hard to read on the dark background.
ANet Relay v0.3.0
A director's-cut opening, bench procedures that calibrate and test an aircraft
step by step, a physical flight model for simulators, control feel presets and
RC transmitters, and a LAN arena in which simulated aircraft see and shoot at
each other.
Added
- Opening: on the first launch of each version a 5.6 s director's cut plays (a
voxel logo, a diagonal voxel cut into a film, a voxel reveal); later launches
play a 3.2 s short cut. Any key, click or controller button skips it, and
Settings → General → Opening sequence chooses Full, Short (the default) or
Minimal (the 1.2 s opening of 0.2). The 8 s and 20 s start-up warnings keep
their timing, the emergency stop works during the opening, and with reduced
motion it takes at most 400 ms and loads no video. Panel loading, workspace
switches, replays and the 3D stage use the same voxel language. - Bench procedures:
full_bench,preflight_quick,motor_check,
vibration_checkandhover_tunechain twelve steps (link and firmware,
battery at rest, parameter baseline, sensor calibration, stick directions,
motor order and direction, ground vibration, propellers fitted, hover test,
step response, hover learning, report). Each step measures, judges against a
stated limit and suggests parameter changes by name and direction; nothing is
written without the operator's consent, and the existing confirm words and
limits apply. Reports are saved, listed under Records → Bench reports and
exported as JSON or a bilingual Markdown table. New inspector tab Bench,
GET /procedures,/vehicles/{id}/procedure(start, answer, abort),
/test-runs, fiveprocedure_*events, seven tools each in the device MCP
server (now 36 tools) and in Copilot, and SDK calls. - Simulator hover assist: every simulator has a hover-assist switch (setting
sim_hover_assist, on by default). Off, it flies like a racing quad without
barometer or position source: the throttle is thrust, the hover point rises as
the battery sags, hold modes are refused, and ground effect, motor lag,
turbulence (settingsim_turbulence) and propeller wake act. The switch works
in flight without a thrust jump.POST /sims/{id}/assist, event
sim_assist_changed,vehicle.simin the snapshot, MCPapp_sim_assist
(the app MCP server now has 42 tools). - Control feel: Gentle, Standard (the default) and Sport presets scale tilt, yaw
and keyboard reach; the throttle has its own linear curve with an optional
centre detent in hold modes; the right stick has a radial dead zone; Mode 1
and per-axis inversion. KeysZ(throttle to the hover point) andH(hover
assist); Triangle switches hover assist on a simulator and altitude hold on a
real aircraft; the D-pad changes the feel. - RC transmitters in USB joystick mode (EdgeTX, OpenTX, RadioMaster, Jumper,
FrSky, TBS and others) and non-standard controllers: an AETR default with an
absolute throttle, a mapping wizard that learns axes, directions, centres and
end points, and switch bindings for hover assist, fire, arm (simulators) and
stop. A transmitter starts sending sticks only once its throttle is lowest, or
centred in hold modes. - Driving HUD on the stage while an aircraft is flown: aircraft, controller,
mode, hover assist, feel, the throttle actually sent against the hover point,
and in the arena the aircraft's hit points and ammunition. - LAN arena: the top-bar Arena switch joins every Relay terminal on the same
network without rooms or a lobby. Remote simulators appear on the stage in
graphite; rounds follow a shared ballistic model; the owner of the aircraft
that is hit judges the hit; 20 damage per round, five bring a simulator down,
and it respawns after 5 s. Scoreboard, crosshair and hit direction on the
stage.GET /arena,POST /vehicles/{id}/fire, the stream messagesarena
andfire, eventspeer_joined,peer_left,arena_hitandarena_down,
settingspeer_port,peer_callsignandarena_auto_respawn, SDKarena()
andfire(). Real aircraft never join the arena and are never affected by
virtual rounds. The arena adds one UDP socket (port 47114 by default) that
carries no control: nothing received from the network reaches sticks, arming,
claims, parameters, skills, plans or device calls. - Installer art: a DMG window background and layout on macOS, and wizard sidebar
and header images in the Windows installer.
Changed
- Keyboard pitch and roll reach follows the control feel (0.6, 0.8 or 1.0)
instead of a fixed half stick; in hold modesRandFclimb and descend
only while held. - The flight tuning and hardware guides (Chinese) start from the bench
procedure.
Fixed
- The
app://protocol answers byte-range requests with 206 and 416, so video
served from the application bundle can seek.
Downloads
| Platform | File |
|---|---|
| macOS (Apple silicon) | ANet-Relay-0.3.0-mac-arm64.dmg, ANet-Relay-0.3.0-mac-arm64.zip |
| macOS (Intel) | ANet-Relay-0.3.0-mac-x64.dmg, ANet-Relay-0.3.0-mac-x64.zip |
| Linux x64 | ANet-Relay-0.3.0-linux-x64.AppImage, ANet-Relay-0.3.0-linux-x64.tar.gz |
| Windows x64 | ANet-Relay-0.3.0-win-x64.exe |
Verify downloads against SHA256SUMS.txt. The macOS build is signed and
notarized: drag it to Applications and open it. The Windows installer is not
code-signed; when SmartScreen warns, choose More info → Run anyway.
Known limitations
- The arena has been tested with several terminals on one machine over
loopback; networks that block both multicast and broadcast keep terminals
apart. - The flight steps of a bench procedure (S9, S10) need altitude hold: on a
simulator with hover assist off they fail at once with that reason. - Transmitter detection and the mapping wizard have been tested with synthetic
controller readings only, not yet with transmitter hardware.