One Software Stack for EtherCAT, Motion, and UI — Written in Rust

Most motion control architectures are not designed. They accumulate. A fieldbus master from one vendor, a motion library from another, a proprietary controller box to host them, and a separate configuration tool, simulator, and HMI layered on top. Each piece may be good on its own. The trouble lives in the seams between them.

Our approach is the opposite: one software stack, total motion control.

What “one stack” means

The Adeeb platform combines a high-performance EtherCAT master with a complete I/O and general motion stack, written 100% in Rust for safety, speed, and reliability.

On top of that sits a web-based UI that runs in any browser, with:

• Configuration of the system
• Real-time 3D simulation
• Python-based motion scripting
• Manual jogging

No overpriced proprietary hardware. No fragile integrations across multiple systems. Just one all-in-one software solution.

The hidden cost of multi-vendor integration

When a machine’s control system is assembled from several independent products, the integration work never really ends. Every boundary between systems is a place where:

• Data has to be translated. Process data, axis states, and errors are modeled differently on each side, and someone has to write and maintain the glue.
• Timing gets harder to reason about. A trajectory computed in one system and delivered over a fieldbus managed by another means two schedulers, two sets of buffers, and two places to look when motion is not smooth.
• Diagnostics fragment. When an axis faults, the answer may be split across a fieldbus tool, a motion log, and an HMI alarm list — each with its own clock and vocabulary.
• Upgrades become risky. Updating one component can break assumptions in another, so working systems get frozen on old versions.

These are fragile integrations, and they add cost long after the machine ships: in commissioning time, in support calls, and in the engineering hours spent keeping them working.

Why a single codebase changes the picture

When the EtherCAT master, the I/O layer, and the motion stack are built together, the seams disappear. The motion layer and the fieldbus share one data model. Configuration, simulation, scripting, and jogging live in one interface instead of four separate tools.

The EtherCAT master at the base of the stack is built for deterministic, synchronized motion: a 250μs minimum cycle time, sub-microsecond jitter, distributed clock synchronization, and up to 128 synchronized axes. Because the motion stack sits directly on top, that determinism is available to motion without being filtered through a third-party integration layer. (For more on how that jitter figure is achieved, see Achieving Sub-Microsecond Jitter with EtherCAT Distributed Clocks.)

Why Rust

Real-time control software has to be fast, and it has to be correct. Traditionally those goals pull against each other: low-level languages give you performance but leave whole classes of memory and concurrency bugs to discipline and code review.

Rust’s ownership model rules out many of those bugs at compile time, without a garbage collector pausing the control loop. Writing the entire stack — not just one component — in Rust means those guarantees hold across the boundaries between fieldbus, I/O, and motion, which is exactly where integration bugs tend to hide. That is what we mean by safety, speed, and reliability.

Built for the people building machines

The browser-based UI is aimed at the full machine-building workflow:

• Configure the system without a dedicated vendor tool.
• Simulate motion in real-time 3D before running hardware.
• Script motion in Python, a language most engineering teams already use.
• Jog axes manually during commissioning and setup.

For complete robot cells, our Robot Controller adds native conveyor tracking, a Python programming interface, and support for 6/7-axis robots, palletizers, SCARA, and delta robots.

The result is a simpler architecture, lower cost, and faster deployment. Cut complexity. Cut costs. Build better machines.

See it running

If you are evaluating a control architecture for your next machine, start with the EtherCAT Master or the Robot Controller product pages, or book a demo to see the stack in action. Questions about your specific application? Contact our engineering team.