New — bulk reads on the hardware thread

Robot code that thinks in signals

Synapse is a tiny, annotation-driven pub/sub bus for FIRST Tech Challenge robots. Nodes talk over named, typed topics while one dedicated thread keeps every hardware touch safe.

Get started Star on GitHub

MIT licensed · 40 KB JAR · zero runtime dependencies

orchestrator — live simulation60 Hzmessages 0

topic log — newest first

waiting for messages…

The bus never sleeps — click any control to publish your own message.

In the field Synapse runs the robot code of FTC Team 23684 · Tech Titans

40 KB

JAR, minified

runtime dependencies

threaded architecture

60 Hz

gamepad-to-topic input

Why Synapse

Safest and smallest, by design

Purpose-built for FTC: fast enough for a 50 Hz drivetrain, strict enough to protect your I²C bus.

One hardware thread, no exceptions

Every motor write, servo command, and sensor read funnels through a single dedicated thread. A runtime assertion fails fast if you touch hardware from anywhere else.

Three-layer API

Annotations, a HardwareActions facade, and SafeDevice<T> wrappers. Pick the style that fits your team — they all serialize onto the same safe path.

Backpressure that respects deadlines

Separate pools for periodic and callback work with bounded queues. A slow subscriber slows its publisher — it never starves your control loop.

Gamepad to topics in one line

GamepadAdaptor.attach() publishes buttons, edges, and axes at 60 Hz. Bind an intake to a rising edge in two lines of annotation.

R8-minify-safe, verified

The entire test suite runs through minification, so the release JAR survives the FTC robot controller build without surprises.

40 KB, zero dependencies

One Gradle line drops it into build.dependencies.gradle. No transitive jars, no version conflicts with the SDK.

Developer experience

Declare intent. Let the bus do the wiring.

Annotate a method and Synapse wires it to the topic, the thread pool, and the hardware thread — no manual tick counting, no references between subsystems.

@SubscribedTo callbacks fire the instant a value publishes.
@RunPeriodically(hz = 50) loops never drift with the main OpMode loop.
@OnHardwareThread hops any callback onto the only thread allowed to touch hardware.

SynapseDemo.java

@TeleOp(name = "SynapseDemo", group = "Demo")
public class SynapseDemo extends SafeOpMode {

  @Override
  protected void onSafeInit() {
    SafeDevice<DcMotorEx> left =
        safeMap.device(DcMotorEx.class, "leftMotor");
    SafeDevice<DcMotorEx> right =
        safeMap.device(DcMotorEx.class, "rightMotor");
    orchestrator.registerNode("drive",
        new DriveNode(orchestrator, left, right));
    GamepadAdaptor.attach(orchestrator, gamepad1, "g1");
  }
}

public static class IntakeNode extends Node {

  @SubscribedTo(topic = "g1/right_bumper/rising")
  @OnHardwareThread
  public void onPress(Boolean v) {
    intake.run(m -> m.setPower(1.0));
  }

  @RunPeriodically(hz = 10)
  public void publishTelemetry() {
    orchestrator.publish("intake/power", lastPower);
  }
}

HardwareActions hw = orchestrator.hardware();

hw.run(() -> motor.setPower(0.5));
double pos = hw.call(() -> motor.getCurrentPosition());

hw.bulkRead(50, view -> {
  double amps = motor.getCurrent(CurrentUnit.AMPS);
  view.publish("motor/amps", amps);
});

Observability

Watch every topic from one panel

Named, typed topics mean your telemetry is a live map of the robot, not a pile of print statements.

orchestrator · live

4 pools50 Hz

Every topic, typed and named — watched from one place.

g1/left_stick_yFloat60 Hz

g1/right_bumper/risingBooleanon edge

drive/motors/ampsDouble50 Hz

imu/headingDouble100 Hz

Live telemetry

Backpressurequeue 41/256

scheduler 8 threads · callbacks 12 · actions 2 · hw 1

Threading model

Four pools, each with a job

Slow callbacks cannot starve periodic loops. Slow periodic loops cannot starve hardware writes.

Pool	Threads	Bounded	Used for
Scheduler	8	—	@RunPeriodically loops
Callback	4–16	256	@SubscribedTo handlers
Action	unbounded	no	@RunnableAction invocations
Hardware	1 (dedicated)	—	All hardware reads/writes

FTC hardware is not thread-safe

Calling setPower or reading a sensor from two threads at once can garble serial-bus responses or crash deep in the SDK. Synapse makes off-thread hardware access fail fast — never silently.

Feedback

Share your experience

Running Synapse in an OpMode? Tell us what's working and what's grinding your gears — it directly shapes the roadmap.

FAQ

Questions teams ask first

Ship safer robot code this season

One dependency line. One hardware thread. No surprises at the competition table.

$implementation "com.aaravlabs:synapse:0.4.0"

Read the docs

Robot code that thinks in signals

Safest and smallest, by design

Declare intent. Let the bus do the wiring.

Watch every topic from one panel

Four pools, each with a job

Share your experience

Questions teams ask first

Why a dedicated hardware thread?

How big is the JAR, really?

Can a slow subscriber starve my control loop?

Does it work with my existing OpMode code?

Ship safer robot code this season