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.

The arculees, our Autonomous Mobile Robots, must navigate through their environment to ensure smooth intralogistics operations. While they previously relied on physical markers at client sites, that’s no longer necessary. With the development of our Free Navigation technology, the arculees can now localise and move freely, i.e., without any pre-installed markers. Let’s hear from Dennis Schradick, our Robotics Software Engineer, on how this advanced technology works, reducing costs while improving efficiency.

Autonomous Mobile Robots (AMRs) like our arculees navigate through an environment to efficiently perform their designated tasks, such as material transportation in warehouses. Previously, the arculees relied on physical floor landmarks such as QR code markers to find their way at a site. While these markers enabled millimetre-level localisation accuracy, they required time- and cost-intensive pre-installation, calibration, and maintenance. To make the navigation process thus smoother and marker-independent, arculus adopted the technology called free navigation. Dennis Schradick, our Robotics Software Engineer, elaborates,

"Free navigation is what we call it at arculus. It is the technology that allows our arculee to localise itself and therefore navigate around in any environment without the need to alter the site physically. With free navigation, we are only relying on what's already there, both in terms of the operating environment and the sensor setup of the arculee."

How does Free Navigation Work?

At its core, free navigation enables the arculees to understand where they are in an environment and move autonomously. Dennis explains how it works through a combination of sensing and localisation techniques:

1. Sensing

For a robot to move autonomously, it first needs to perceive its own motion and its surroundings. The arculee achieves this through two types of sensors: Relative Sensors & Absolute Sensors

a. Relative Sensors

Relative sensors provide estimates of how the robot has moved based on its own internal measurements. These include:

• Wheel speed sensors: measure how fast the wheels are turning.
• Inertial Measurement Unit (IMU): measures acceleration and rotational velocity.

By mathematically integrating these measurements, the system can estimate how far the robot has travelled and how much it has rotated. This data gives an estimate of the robot’s current position and orientation relative to the initial point of operation. However, relative sensors are subject to drift over time due to issues like sensor noise and wheel slip, which can cause the estimates to become less accurate over time.

b. Absolute Sensors

To counter the drift issues of relative sensors, arculee uses absolute sensors such as laser scanners (LiDAR) to obtain a precise, external reference of its position in the environment. These scanners were originally part of the robot’s safety system, ensuring safe operation around humans. But with free navigation, they now also serve the additional function of enabling accurate localisation.

The laser scanners provide an absolute reference by recognising features in the environment, which improves navigation accuracy and allows the robot to maintain reliable position estimates without physical markers.

2. Localisation

Once the sensors have gathered data, the next step is to determine the robot's exact location within the environment. This process is known as localisation, and it begins with mapping through a technique known as Simultaneous Localisation and Mapping (SLAM).

SLAM: Building a Map to Get Around

SLAM creates a contour map or grid-based map of the robot’s environment. This map resembles a table-like structure where each cell represents a small portion of the space. Each cell is marked as either occupied (e.g., by a wall or pillar, etc) or free (when the laser detects nothing).

During operation, the robot continuously generates a "snapshot" of its surroundings using the laser scanner. It then matches this snapshot with the pre-generated SLAM map using nonlinear optimisation techniques. This matching process estimates where the robot is most likely positioned in the map.

By combining this absolute position estimate with the data from relative sensors (IMU and wheel speed), the arculee can accurately determine its current location and orientation within the warehouse. Dennis explains:

"This fusion of relative and absolute sensing, anchored by the SLAM map, ensures robust localisation even over long distances without relying on QR codes or physical landmarks."

How Do arculees Solve the Accuracy Challenge

High-accuracy scenarios, such as entering a pallet handover station or picking up a table, are crucial for arculee’s performance. Such use cases pose a unique technical challenge. To handle these, arculee switches to a specialised mode of localisation that no longer references the global map, but instead focuses solely on the object in front of it.

“Think of it like parking a car: once you see the parking space, your only goal is to drive into it precisely, everything else in the environment becomes irrelevant,” explains Dennis, “similarly, arculee approaches the target, detects it using a robust template-matching algorithm, and then begins precise positioning relative to that object.”

At this point, arculee uses a high-resolution contour map with accuracy in the millimetre range to match incoming laser scans and guide movement. This targeted, fine-grained scan matching allows the robot to move in and out of stations reliably and accurately.

Whether it’s an in-house-designed station or a customer-provided object, arculee can quickly model the geometry and begin operating with precision, without any need for QR code markers. This flexibility makes it highly adaptable in diverse warehouse environments.

Fast + Reliable = Efficient

One noteworthy feature of arculee’s navigation system is its ability to provide fast and accurate absolute updates of the robot’s position, all while running on a small, integrated, low-power compute platform.

Dennis highlights that this efficiency comes from a smart architecture that balances cutting-edge precision with lightweight performance:

"We achieve this (efficiency) because while we use state-of-the-art non-linear optimisation techniques to find the best match of the laser scan with the map, on the backend, we rely on a lightweight state estimation that is very fast compared to some of the frameworks that are popular within the industry."

Making a Difference

Free navigation is more than a clever trick; it’s a crucial step in how AMRs like arculees move, adapt, and scale. By using what’s already present, the robot’s onboard sensors and the natural contours of the environment, arculus eliminates the need for costly infrastructure, while enhancing precision and safety.

The result? Flexible automation that stays accurate without constant maintenance.

As Dennis puts it,

"We’re using the tools we already have on the robot in smarter ways. That’s what makes the difference."

---

Learn more in the video below!

An Autonomous Mobile Robot (AMR) has various components that work together to ensure smooth and efficient operation. But for these components to communicate and function together seamlessly, the robot relies on something crucial: an embedded system. In this blog post, Kayas Ahmed, Embedded Software Engineer at arculus, explains the essential functions and purpose of the embedded software in AMRs.

What is Embedded Software?

Embedded software is purpose-built code that interfaces directly with a robot’s hardware components, like sensors and actuators. Unlike general-purpose software that can handle a variety of tasks, embedded software is designed to perform one specific function with a high degree of precision and reliability. Its job is to ensure that the robot’s hardware behaves exactly as expected, every time.

Kayas Ahmed, Embedded Software Engineer at arculus, explains the role of embedded systems in arculess (our AMRs), “The embedded software communicates on interfaces, on all the components, all the sensors, on the Printed Circuit Board (PCB) in the robot. In the system hierarchy, embedded comes right after the robot's electronics, making it alive. For example, a visible function of the embedded is to control features like LED blinking and manage motor control.”

How it All Works

The embedded software ensures a predictable response time and executes its specific function by ensuring that all the different components, such as sensors, motors, and processors, communicate effectively. That is where communication protocols come into play.

Communication Protocols

Serial communication protocols are a set of rules that define how devices transmit data to each other. These protocols enable the embedded software to send and receive data from the various components of the robot in real-time.

The arculee uses different serial communication protocols to exchange data between the sensors, motors, and the Linux module, which acts as the main processor running on the PCB. Kayas mentions the following protocols:

• Universal Asynchronous Receiver/Transmitter (UART): This protocol is for communicating with the Linux module, which serves as the central processing unit of the robot. It’s lightweight, fast, and ideal for simple, direct communication.
• Inter-Integrated Circuit (I2C): This is a synchronous protocol for connecting low-speed devices, such as sensors.
• Serial Peripheral Interface (SPI): It is a synchronous serial communication protocol for transferring data between sensors, microcontrollers, and peripherals.
• Controller Area Network (CAN): Originally developed for the automotive industry, CAN is ideal for robust, real-time communication in noisy environments. It’s functions involve coordinating communication between various control units, such as those managing motor functions.

Each of these protocols has its own strengths, and the embedded system knows which one to use based on the component it is interfacing with. This layered, modular approach enables the arculee to maintain smooth data flow between all its critical systems.

Managing Complex Processes

The arculee performs complex processes, which require efficient movement of motors and the processing of data from multiple sensors. So, how does embedded software handle it all?

“To handle complex tasks, we split the problem into smaller tasks,” explains Kayas. “We use an open-source, real-time operating system called FreeRTOS, which allows us to run multiple tasks concurrently on a single microcontroller. For example, in managing LED, the task is simplified and divided into: 1. requesting a new LED pattern and 2. applying the pattern in real-time. This division of labour ensures that each part of the system operates smoothly without interference.”

In the arculee, this distribution of tasks across multiple microcontrollers ensures that the system is more efficient and can handle the intricacies of motor control, sensor data processing, and other essential tasks without interference.

The Time Challenge

One of the biggest challenges in embedded software is adhering to strict timing requirements. Kayas believes that embedded systems are all about predictability. Therefore, it is crucial to ensure that tasks, especially motor control algorithms, are executed within a specific time frame. A motor control algorithm has very strict timing needs, and executing tasks in the required time window is crucial for the system’s operation. That is why the embedded software must work perfectly to guarantee a reliable AMR with predictable response times.

Adaptation: The Key to a Successful Embedded System

Just like any tech system, AMRs also evolve. New components are added, and features continue to improve. Therefore, the embedded software must also adapt and evolve. That’s why the arculees support over-the-air (OTA) updates, allowing engineers to upgrade and enhance the software as needed remotely.

Kayas explains, “Our embedded software supports OTA updates via the Linux module. It means that when the Linux module is updated, the software for the microcontrollers is also updated, allowing us to integrate new components or functionalities seamlessly.”

This adaptability ensures that the AMR can evolve, supporting new components or features without needing a complete revamp of the entire system. An up-to-date embedded system makes it easier to ensure the reliable and autonomous function of the robots.

Bottom Line

In short, embedded software is crucial for bringing arculees to life. It ensures the robots operate smoothly, guarantees effective communication between components, and adapts continuously with the addition of new features.

Learn more in the video below!

At the core of every arculee, our Autonomous Mobile Robot (AMR) is its brain. This powerful software system processes sensor data, executes commands, and guides the robot through complex environments. Software Engineer Thomas Fuhrmann explains how it works and why it’s essential to the robot’s performance.

What is the arculee Brain?

The brain is the central software of an arculee that manages all the tasks of the robot, including navigation, decision-making, and command execution. It receives orders from an outside source, like a fleet manager, processes its surroundings through sensor data, decides movements, and ensures overall efficiency in AMR operations.

Thomas Fuhrmann, Software Engineer at arculus, uses the analogy of the human brain to clarify its functions:

"The arculee brain functions similarly to a human brain. If you imagine an arculee as a body, the chassis is like the physical form; the electronics and cable harnesses are the organs and blood vessels. Just like in humans, the brain controls everything for the robot."

Processing the environment

Thomas highlights three main steps the arculee brain follows when processing its surroundings:

1. Sensing: The arculee uses different sensors to gather information about its environment, similar to how humans rely on sight or hearing. For example, sensors like LiDAR generate detailed point clouds that map the robot’s surroundings.
2. Interpreting: The brain processes the sensor data to interpret the real world. For instance, it can locate itself and recognise objects and obstacles that might be present in the robot’s path.
3. Implementing: Based on the interpretation, the robot makes timely decisions, such as stopping or altering its route to avoid collision with an object in the way.

The Brain’s Tech Stack

Developers at arculus build the arculee brain entirely in-house and avoid relying on external frameworks to maintain full control over performance and system behaviour. Thomas explains that they use C++ for the core system because it provides the speed and low-level access required for efficient robotics. For user interface components, they use Python, which allows for faster development and more efficient testing.

To improve modularity and efficiency, the developers plan to migrate the stack to ROS2, a well-known robotics framework that enables clearer system architecture and easier integration of new components. We will explore this migration in a future blog post.

Challenges and Solutions

Developing a sophisticated piece of technology like the arculee brain comes with its own set of challenges. Thomas points out the following three:

1. Code Maintenance: The brain stack, including the code base, has evolved over the years, becoming increasingly complex. As features and functionalities expanded, maintaining the code became more challenging due to increased interdependencies within the program and legacy structures. The team tackles this by constantly checking and conducting frequent debugging sessions.
2. Managing Complexity: Our AMRs navigate autonomously in dynamic environments. This requires a solid system that can handle a wide range of possible scenarios and corner cases for maximum efficiency, safety, and optimal performance.
3. Testing and Validation: The office testing area allows developers to test the arculees in a controlled environment to ensure quality before deployment. However, the robots don’t always behave as expected, especially during the early stages of development. To improve performance and stability, the team runs countless tests and refines the software based on real-world behaviour.

Sharper Brain, Stronger arculees

The arculee brain handles all the core functions of the robot and can thus make or break it. Thomas sees a well-designed brain as key to precision, reliability, and adaptability. As development continues, improvements in navigation and decision-making will help arculees respond more effectively to increasingly complex environments. A sharp brain doesn’t just keep an AMR moving—it sets the foundation for smarter automation.

Learn more in the video below!