At arculus, we rely on a mix of programming languages to power arculees, our autonomous mobile robots (AMRs) and Fleet Management software. Each language is chosen for a reason: reliability, speed, flexibility, or usability. In this post, we take a closer look at the languages that make up our robotics stack.
From mapping, localising and navigating their way through warehouses to coordinating an entire fleet, Autonomous Mobile Robots (AMRs) like our arculees don’t speak just one language. After all, running real-time algorithms on an embedded system requires very different tools than designing UIs or scaling backend services. That’s why the arculus tech stack spans multiple programming languages, each chosen for what it does best. In this post, we’ll explore which ones we use and how they come together to keep our robots and fleet running smoothly.
The Languages of arculus
1. Rust for Reliability
At arculus, we use Rust for programming our Fleet Manager due to its unique ability to combine performance with safety and robustness. For mission-critical systems, such as coordinating arculees in warehouses, these qualities are non-negotiable. Unlike many other languages, Rust enforces strict rules that prevent common programming errors, such as memory leaks and data races, which can cause unpredictable behaviour or even system crashes. Its ownership model and borrow checker act as compile-time safeguards, guaranteeing memory safety without slowing down the system.
By catching bugs early in the development process, Rust allows our developers to write code that is not only fast but also remarkably reliable. This reliability is essential when a fleet of robots must work together in complex environments, where mistakes could result in downtime, collisions, or lost productivity.
Rust’s value extends beyond its core language features. It boasts a thriving community and a mature ecosystem, featuring several high-quality libraries and tools. The Cargo package manager, for example, facilitates dependency management and builds smoothly and efficiently, thereby accelerating development cycles. Andy Brinkmeyer, our Software Developer from the Fleet team, believes,
“Choosing Rust as our main backend language was the best decision for our tool stack because it provides comprehensive solutions, eliminating the need for additional tooling for building and dependency management. It’s part of a robust and growing ecosystem, simplifying our development process and integrating well with our systems.”
2. C: The Language of Hardware Control
The closer you get to the hardware, the more simplicity and speed matter. That is why our Embedded team programs low-level firmware in C. The language offers precise control over hardware and efficient execution, making it ideal for safety-critical systems such as motor controllers and sensor interfaces. With C, we can guarantee that instructions will run exactly when and how we need them to. As Kayas Ahmed, our Embedded Software Engineer, explains,
“C's simplicity and speed are fundamental to achieving predictability in embedded software applications. Its straightforward nature allows for precise control over hardware, and its efficient execution helps ensure that operations occur within strict time constraints, both crucial for reliable performance in embedded systems.”
While C is the foundation of our embedded stack, other languages play supporting roles. For example, C++ facilitates module abstraction, enhancing reusability and simplifying testing, while Python is the preferred choice for quickly building proof-of-concept utilities and testing tools.
3. C++: The Muscle Behind Real-Time Robotics
If C is the foundation, C++ is the engine that drives our robots. Dennis Schradick from the Functions team affirms, “C++ is the main language of our stack.” Most of the core robotics logic, from localisation, mapping, and state estimation to planning, control loops, and sensor fusion, runs here. Its deterministic execution ensures predictable timing for safety-critical loops, while its high performance and low latency enable real-time control even under complex workloads.
Running on NVIDIA Jetson boards, our robots leverage C++ to unlock GPU acceleration through CUDA and TensorRT, enabling fast and optimised inference for machine learning and other compute-intensive tasks. Strong multithreading support further allows precise scheduling across Robot Operating System (ROS) 2 executors and callback groups, preventing bottlenecks and maintaining system responsiveness.
C++ also connects seamlessly to the broader robotics ecosystem. Mature libraries like Eigen, Ceres, OpenCV, and PCL provide ready-made tools for mathematics, vision, and optimisation, letting the team focus on higher-level functionality rather than reinventing the wheel. “This is what makes C++ the workhorse of our stack: it is fast, efficient, and deeply embedded in the robotics world,” concludes Dennis.
4. TypeScript: Clarity for Operators
Robots may not need user interfaces (UIs), but people do. At arculus, the frontend team relies on TypeScript to build UIs. “We use TypeScript as it is the de facto language for frontend development and mandatory by our used framework, Angular,” explains Axel Jäger, Team Lead Frontend.
While most of the visualisation and interactive elements run directly in the web browser, where JavaScript is the native language, TypeScript, a strongly typed superset of JavaScript, provides added clarity and reliability. As a result, it becomes easier to manage large, complex codebases while the program continues to run seamlessly in the browser. In some parts of the visualisation, OpenGL Shading Language (GLSL), a specialised language that executes directly on graphics hardware for high-performance rendering, is also used. Axel elaborates,
“Since we have to visualise warehouse layouts with thousands of items in a browser-based user interface, we try to offload as much as possible to the GPU, keeping the user interface as snappy as possible.”
This combination of Typescript and GLSL allows arculus to ensure smooth visualisations even for complex warehouses, thus making performance and utility go hand in hand.
5. Python: A Tool for Fast Development
Python is everywhere at arculus. It may not power the mission-critical loops, but it is the language of flexibility and speed. The Functions team uses it to train neural networks in PyTorch and TensorFlow before deploying them in optimised C++ pipelines. It also drives lightweight ROS 2 nodes, backend services, and orchestration scripts.
In the Embedded team, Python supports rapid prototyping and firmware interface testing. It is the language to reach for when trying out an idea quickly, connecting different systems together, or automating routine tasks.
Some Other Languages in our Tool Stack: A Word on JavaScript and React
For debugging and diagnostics, our team leans on JavaScript and React to build browser-based interfaces that anyone — operators or developers — can access from any device without setup.
React’s modern framework allows rapid iteration on complex, interactive dashboards, while the rich JavaScript ecosystem provides charts, graphs, and even 3D visualisations for TF trees, node graphs, and other diagnostic data. Integration with Python backend services is straightforward via REST or WebSockets, enabling real-time monitoring and control. These dashboards power a variety of use cases, from inspecting topics and triggering services or actions to recording and downloading rosbags, making complex robot systems more transparent and manageable at a glance.
Wrapping Up
No single language can power an entire robotics stack. While Rust provides reliability, C offers precise control over hardware, and C++ is the go-to language for building fast and efficient robotics software. Similarly, TypeScript delivers clarity to operators, while Python fuels experimentation and AI development. JavaScript fills in the gaps where quick browser-based tools are needed. Together, these languages form a carefully balanced toolkit that allows our robots to be safe, robust, and adaptable. In robotics, performance is not only engineered into the hardware; it is also written into the code.
