Ship code in six languages, on a runtime that owns the box.

Key metrics

The numbers that size the integration.

6 SDK languages Python · Rust · Lua · Go · C · C++

89 typed interfaces services across 16 shared type packages

180 platform features declared service surfaces across the OS

10 s hot-swap Rust micro service, end-of-compile to first service call on device

<5% container overhead CPU/RAM; ~10 MB RSS per container.

Install

Add the SDK in one command.

Two reference client libraries cover Rust and Python. Other languages reach MOS4 services via the MQTT bridge — no language-specific SDK required.

cargo add mos-sdk-client

pip install mos-sdk-client

Lua, Go, C, and C++ reach the same service surface via the in-process MQTT bridge — see the quickstart documentation for per-language examples.

MQTT bridge

Any client. Any language. No Munic SDK.

MOS4 embeds an MQTT broker in-process. Payloads are accepted as plain JSON or as the typed binary format; JSON is transcoded at ingress. A retained service catalog lets clients discover available services at connect time.

sequenceDiagram
  participant Py as Python container<br/>(paho-mqtt)
  participant MQ as MQTT broker<br/>(in-process)
  participant Svc as Signal-processing service
  Py->>MQ: PUBLISH mos/rpc/MspService/LoadGraph<br/>JSON or typed payload
  Note over MQ: transcode JSON to typed call at ingress
  MQ->>Svc: typed call LoadGraph(graph)
  Svc-->>MQ: response
  MQ-->>Py: PUBLISH mos/rpc/MspService/LoadGraph/reply
  Note over Py,MQ: any MQTT client library, any language — no Munic SDK required

import json
import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect("localhost", 1883)

# Publish to any micro services via the MQTT bridge
client.publish(
    "mos/rpc/MspService/LoadGraph",
    payload=json.dumps(graph_json),
)

Rust micro service authoring

One annotation. Thirty lines.

Rust developers writing a native micro service annotate a struct with #[component] and add one build.rs call. The framework generates service dispatch, proxy creation, lifecycle wiring, config accessors, observability instrumentation, and a fake for unit tests.

use mos_sdk::component;

#[component]
pub struct MyService {
    config: MyConfig,
}

#[async_trait::async_trait]
impl provided::my::MyServiceServer for MyService {
    async fn do_thing(&self, req: Request) -> Result<Response> {
        // your logic — observability and lifecycle are wired by the framework
        Ok(Response { ok: true })
    }
}

// build.rs — single call generates server trait, proxy, fake, metrics
fn main() {
    build_api::generate_component_code(env!("CARGO_MANIFEST_DIR"), "src");
}

Generated fakes compile without a running MOS4 daemon — unit tests run on any host.

Console

One binary. Shell, REST, web, serial.

Cloud-driven flows

Call any micro service from the cloud via the RPC bridge.

The RPC bridge routes JSON calls from external clients to any registered MOS4 service — including containers. method ListServices() exposes the live catalog at runtime. Use cases: remote debug, unblocking rare field situations, and hybrid flows where an AI agent or a cloud service drives the device. See Micro services for cloud-side surfaces and integration patterns.

The internal RPC port is not exposed by default. External access goes through the MQTT bridge or the RPC bridge — no direct port exposure for tooling.

What you bring vs what we bring

Honest split.

FAQ

Frequently asked questions

• What languages ship with pre-built base images?

  Python, Rust, C, C++, Go, and Lua — six language runtimes with OCI container examples and CI-enforced image-size budgets across 15 (language, scenario) pairs.

• How does the MQTT bridge work?

  MOS4 embeds an MQTT broker in-process — no external broker required. Payloads are accepted as plain JSON or as the typed binary format; JSON is transcoded at ingress. A retained service catalog lets clients discover available services at connect time. Any MQTT client library, any language — reaches MOS4 services with no Munic SDK required.

• How fast is hot-swap?

  10 seconds from end-of-compile to first successful service call on a real device. When a new process registers a micro service with an existing component.id, the master stops the old instance, injects serialized state, and starts the replacement. No reflash. Hot-swap is a Rust micro service feature; containers (Python, C, C++, Go) follow a different OTA-update path.

• What is the container overhead budget?

  The container resource budget is under 5% CPU/RAM overhead and approximately 10 MB RSS per container. The mcm standalone CLI is pre-installed on production images.

• Is the internal RPC port exposed for direct tooling?

  The internal RPC port is not exposed by default. The RPC bridge routes JSON calls from external clients to any registered MOS4 service; use the MQTT bridge or the RPC bridge for external access.

• What is the RPC bridge for?

  The RPC bridge calls any MOS4 service — including containers — from the cloud via API. Use cases: remote debug, unblocking rare field situations, and hybrid flows where an AI agent drives the device. No protocol or wiring code beyond the service definition and a cloud-side endpoint.

Developer Tools

AI-aware tooling for MOS4 developers.

The MOS4 developer pack extends the SDK with an MCP connector, a configuration linter, log readers, and project-graph queries — so the AI tools your team already uses understand the platform. Available with engineering.