Reference

Interface reference

One interface, every language. The driver handles discovery, connections, background, and power behind the scenes, so the code you write is nearly the same whichever language you're in. Pick yours; every example below switches with you.

Hand-maintained during early access. These samples are kept in sync with the real API by hand today; the intent is to generate them from the C ABI (sdk/hop.h) and its language wrappers per release. Java rides the JVM binding; Objective-C bridges from the Swift binding; Python lands as its binding does.

Open a node

Open a node from your 32-byte secret. The driver owns key storage and the radios, you just hand it the key, and the secret is the address.

let node = HopNode::open(secret)?;

let node = try HopNode(secret: secret)

HopNode *node = [HopNode openWithSecret:secret error:&err];

val node = HopNode.open(secret)

HopNode node = HopNode.open(secret);

Send to a device

Address a sealed payload to another device by its public key. You don't pick a route or a bearer, the driver relays it across whatever it has.

node.send(Destination::device(peer), Payload::message("on my way"))?;

try node.send(to: .device(peer), payload: .message("on my way"))

[node sendTo:[Destination device:peer] payload:[Payload message:@"on my way"] error:&err];

node.send(Destination.device(peer), Payload.message("on my way"))

node.send(Destination.device(peer), Payload.message("on my way"));

Reach the internet from offline

Egress is a hops:// service request addressed to an endpoint node by its key: it fetches the URL and the sealed response routes back to your key. You still pick no route or bearer.

node.send_service_request(endpoint, "http", "get", b"hops://example.com/status")?;

try node.sendServiceRequest(to: endpoint, service: "http", method: "get", args: "hops://example.com/status")

[node sendServiceRequestTo:endpoint service:@"http" method:@"get" args:@"hops://example.com/status" error:&err];

node.sendServiceRequest(endpoint, "http", "get", "hops://example.com/status")

node.sendServiceRequest(endpoint, "http", "get", "hops://example.com/status");

Receive

Drain your inbox of sealed bundles addressed to you, and open them. Delivery acknowledgements and dedup are handled for you.

for msg in node.receive()? { handle(msg.open()?); }

for msg in try node.receive() { handle(try msg.open()) }

for (Message *msg in [node receiveAndReturnError:&err]) handle([msg openAndReturnError:&err]);

for (msg in node.receive()) handle(msg.open())

for (Message msg : node.receive()) handle(msg.open());

Subscribe to a topic

Join a pub/sub topic and receive whatever is published to it across the mesh, one-to-many, region-aware, the same on every platform.

node.subscribe("alerts/region-4")?;

try node.subscribe("alerts/region-4")

[node subscribe:@"alerts/region-4" error:&err];

node.subscribe("alerts/region-4")

node.subscribe("alerts/region-4");

Where this goes next

This is the shared, flow-level interface, the part that's the same everywhere. The full per-language reference (rustdoc, Swift DocC, Kotlin/Java Dokka) is generated per release from the same interface and linked here as it lands. Building on a platform that isn't here yet?Tell us.