One platform. Many sensors. Intelligence at the edge.

MotionCast is a modular hardware & software platform — a microcontroller, a radar, and a growing list of plug-and-play sensors — orchestrated by an open framework that runs real-time tracking, sensor reporting and Edge AI predictions side by side.

Join the Early Access Waitlist

What is MotionCast?

MotionCast is one platform for responsive, sensor-rich applications. At its core sits a microcontroller paired with a radar module for motion and high-definition location data. From there, the platform extends through a modular catalogue of additional sensors that you choose based on your use case.

The hardware is orchestrated by our software stack: the same MCU streams real-time location and sensor data and runs Edge AI inference concurrently — with the cloud handling fleet training, evaluation and batch insights.

Modular Hardware

An MCU + radar baseline, extended with plug-and-play sensor modules. Browse our growing supported list and pick exactly what your application needs.

Orchestration Software

Our open framework runs on the MCU and manages every connected sensor — handling acquisition, filtering and routing without you wiring it up by hand.

Edge & Cloud AI

On-device inference for real-time predictions, plus a cloud side for fleet training, evaluation and batch-processed insights. You decide where each step runs.

What MotionCast gives you

With a single radar module you already get real-time multi-target location and trajectory predictions running directly on the MCU. Add more sensors, and the platform fuses them into the same edge-AI pipeline — opening up Quality-of-Life and automation applications from residential spaces to industrial settings.

Real-Time Multi-Target Tracking

High-definition, radar-based location of multiple humans or objects in a space — reported live, with no cameras and no cloud round-trip.

Trajectory Prediction

Edge-AI models forecast where a target is going next, so downstream systems — lighting, HVAC, automation, safety — can act before the moment, not after.

Live Sensor Reporting

Every connected sensor streams real-time readings alongside the AI predictions. One MCU, one pipeline — data collection and inference at the same time.

Quality of Life & Automation

From residential automation to industrial environments — informed decisions from the edge to the cloud, built on data the platform already understands.

Two modes. One framework.

Data Collection. Use the platform to listen to the environment and stream high-quality sensor data — for live dashboards, downstream services, or for training models on more powerful compute.

Real-Time Prediction. Take a trained model and run it directly on the MCU for immediate inference. With MotionCast both modes can run concurrently on the same device.

The framework is open and adjustable — you decide where data is filtered, where it's processed, and which sensor mix fits your use case.

Garbage in, garbage out — handled.

Built-in edge filters catch out-of-distribution inputs before they reach your models. And because noise isn't always bad, those filters can be toggled per pipeline.

Code that speaks for itself

The MotionCast framework is written in C for embedded targets. Both live sensor reporting and on-device inference run in the same loop, side by side.

main.c — MotionCast Example

                    // MotionCast platform — radar + sensors + edge AI

                    #include "motioncast.h"

                    mc_platform_t mc;

                    mc_targets_t   targets;

                    mc_trajectory_t trajectory;

                    int main(void) {

                      // 1. Bring up the radar + any plug-and-play sensors

                      mc_init(&mc, MC_RADAR_DEFAULT);

                      mc_attach_sensor(&mc, MC_SENSOR_TEMPERATURE);

                      mc_attach_sensor(&mc, MC_SENSOR_IMU);

                      // 2. Load an edge-AI model for trajectory prediction

                      mc_load_model(&mc, MC_MODEL_TRAJECTORY_V1);

                      while (1) {

                        // 3. Real-time multi-target location from radar

                        mc_read_targets(&mc, &targets);

                        mc_report_sensors(&mc);

                        // 4. Edge-AI trajectory prediction on the same MCU

                        mc_predict_trajectory(&mc, &targets, &trajectory);

                        if (trajectory.confidence > 0.85) {

                          on_target_movement(&targets, &trajectory);

                        }

                      }

                    }

Open at the core. Built as a product.

MotionCast follows an open-core model: the framework and developer tooling are open, while the hardware platform and managed cloud are commercial. You can build on the same stack we ship — or simply pick up a MotionCast device and start.

Our focus today is residential Quality-of-Life and automation, but the platform is intentionally broad: industrial sensing, developer projects, and OEM integrations are all on the same rails.

The team behind MotionCast

Built by two founders covering both halves of the platform — embedded and AI.

Peter Bader

Co-founder. Embedded development, sensory architecture and product architecture.

Adrian Reiter

Co-founder. AI stack & architecture, and the data pipeline behind MotionCast.