Test any vehicle logic before HIL

Virtual vehicle integration testing

Teams and individual developers are using RemotiveTopology to test everything from individual nodes to entire vehicle systems, and their interactions early, without hardware, and without having to wait for other teams to mature the dependencies. 

Installation guide
Schedule a demo
Copy
1# Subscribe to the CAN bus
2sub = await broker_client.subscribe(("FLCM-BodyCan0", 
3        [
4          "TurnLightControl.LeftTurnLightRequest", 
5          "TurnLightControl.RightTurnLightRequest"
6        ]
7      ))
8)
9# Check that the turn light request arrive within two seconds
10await await_at_most(seconds=2).until(
11    partial(take_values, sub),
12    equal_to({
13        "TurnLightControl.LeftTurnLightRequest": 1,
14        "TurnLightControl.RightTurnLightRequest": 0
15    }),
16)
17

Run integration tests across ECUs, apps and features in your central pipeline, as often as you need. Virtual runs work from any remote setup, reproduce the same way every time and catch issues early, so your HIL rig only gets the tests that need real hardware.

Test any vehicle logic early - without waiting for hardware

Whether you're working on body control, infotainment, personalization, or diagnostics, RemotiveLabs brings the ability to test any vehicle logic early - essentially bringing the car onto your desktop, allowing you to iterate quickly, stay in sync with your team, and reduce testing costs. Use real signal data, networks, and open tooling - all from your laptop. Shift integration left. Save time later by validating platforms from a functional perspective first.

Describe and run your topology

With RemotiveTopology, you can describe your topology in a way that is instantly executable (learn more: Integration testing from day 1). Freely mix no-code mocks, behavioural models, Simulink models and vECUs like Synopsys Silver. Simulate the part of the vehicle network needed for your use case and run tests locally on a Linux laptop or directly in CI pipelines to collaborate on team level. (Learn more: Integrate with CI pipeline).

Once available, it is also possible to replace nodes with actual hardware. 

RemotiveTopology uses real network protocols, i.e. all bus communication is the same as in the production vehicle platform, including how network packets are encoded, IP/ MAC addresses, VLANS etc. This allows the use standard tools such as Wireshark or candump to inspect the network and mixing of virtual and physical components.

Three steps to virtual integration testing: 1) platform definition from ARXML, DBC and FIDL files, 2) topology configuration in YAML, 3) executable topology that runs locally or in CI

Start building directly with full control over dependencies. Whether you’re working with ARXML, DBC, or FIDL, you can now create a runnable vehicle topology in minutes: (1) Configure the subset of ECUs and buses that should be part of the topology in YAML. (2) Use RemotiveTopology CLI to generate an executable topology. (3) Use Docker/Podman compose to run it locally or in CI.

Easily add behavior using Python

With RemotiveTopology you can create Python-based behavioral models to incorporate specific logic and dynamic behaviors. Easily implement the behavior you need to test your code or prototype and share more complex models across topologies and teams.

Copy
1class BCM:
2    body_can_0: CanNamespace
3
4    async def on_hazard_light(self, frame: Frame) -> None:
5    hazard_signal = frame.signals["HazardLightButton.HazardLightButton"]
6
7    await self.body_can_0.restbus.update_signals(
8        RestbusSignalConfig.set("TurnLightControl.RightTurnLightRequest", value=hazard_signal),
9        RestbusSignalConfig.set("TurnLightControl.LeftTurnLightRequest", value=hazard_signal),
10    )

When a test case requires specific behavior from a topology participant, but no model, simulation, or hardware is available, Python-based logic can replace the mock to enable accurate testing.

Notice that the Python models will participate in the network using production communication exactly as if it was running in a vehicle.

Your Python model can be used by other teams dependent on your nodes.

Once a high-fidelity model, production code, etc. is available, it can also run in your topology, replacing the simple Python model.

Infrastructure as code

With RemotiveTopology, code is used to describe how to instantiate your platform and execute your tests. Code that can be tracked with version control. This allows other teams to reuse your topology and tests, and of course, automate tests in CI pipelines. If there is a bug, it can be reproduced by anyone.

Copy
1# ECUs to instantiate
2ecus:
3  # a mock for SCCM
4  SCCM:
5    mock: {}
6  # a python model for BCM
7  BCM:
8    models:
9      bcm:
10        type: container
11        container:
12          build:
13            dockerfile: ../Dockerfile
14          volumes:
15            - ../ecus/bcm:/app/bcm
16          working_dir: /app
17          command: python -m bcm
18  # no behavior needed for FLCM
19  FLCM:
20    channels:
21      BodyCan0:
22

Using RemotiveTopology Instance YAML, you can describe which parts of the platform you need to instantiate and how the different ECUs will be run. In this example, the BCM ECU has a behavioural model written in Python and the FLCM ECU will run as a mock.

One framework to test components, services, HMI etc.

RemotiveTopology lets you instantiate exactly the part of the platform your device under test needs. Missing parts become mocks or behavioral models you control, so no team waits for another team's delivery. One framework covers every level, from a single ECU to services across the whole vehicle, and the same setup runs on your laptop, in CI and onward to HIL.

Single ECU and component integration testing

Create a component test framework with the surrounding nodes, directly from the platform description, and start integration testing from day 1. Examples include ECU testing with lightweight restbus simulation, a standalone instrument cluster running real AGL code in a container, and hybrid LIN bus testing that mixes virtual and physical nodes.

‍

Central computer with many dependencies

Simulate large parts of the mechatronic rim and zone controllers around the central computer. Complexity doesn't grow with size: large topologies stay infrastructure as code, created and controlled like small ones. Examples include Volvo Cars mocking a vehicle on a Linux laptop to test the VCU, and full vehicle simulations running across multiple machines.

‍

Services that span several ECUs (central computer, zone controller, mechatronic rim)

Comfort, personalization and body control services usually get tested late, when mature nodes finally arrive. With RemotiveTopology, teams own the nodes they need from day 1 as mocks and behavioral models, then raise fidelity to virtual ECUs and hardware. One European OEM cut multi-ECU regression tests from 3-4 hours on HIL to 21 minutes in SIL.

‍

Infotainment, HMI and digital cockpit testing

Combine closed-loop simulation, where you mock and control the nodes you choose, with open-loop replay of recorded drive cycles, including GPS, speed and video feeds. Examples include Android Automotive integration with Cuttlefish, digital cockpit integration with HERE Navigation, and interactive sound design built on real vehicle data.

Get started

Install RemotiveTopology and run your first topology in minutes, or start from the ready-made examples on GitHub. Prefer a guided tour? Schedule a demo with our team.

‍

‍

Installation guide
Examples

Jump straight into action

Head over to the installation guide to set up RemotiveTopology in minutes. For practical examples and usage patterns, check out our GitHub repository.

Free evaluation

for 30 days

10x faster multi-ECU regression testing in SIL

A European vehicle OEM complements HIL with RemotiveTopology for end-to-end regression tests across the infotainment unit, a low-power ECU and the core computer. Each test went from an average of 3-4 hours on a HIL rig to 21 minutes in SIL, run from the developer’s own laptop.

10x faster feedback: from 3-4 hours on a shared HIL rig to 21 minutes per test, with no rig booking or flashing.

Signals generated from ARXML match the production platform, so standard tools like Wireshark and candump work unmodified.

Roughly one month of waiting time saved per developer and year, while HIL capacity stays free for tests that need hardware.

10x faster multi-ECU regression testing
Multi-ECU regression test in SIL with RemotiveTopology
Mocking a vehicle on a Linux laptop to test the VCU 

Volvo Cars uses RemotiveTopology to simulate entire vehicle topologies on a developer's laptop. By virtualizing ECUs and orchestrating signals with Docker, teams can test usage modes like “driving in reverse” early, without waiting for HIL rigs. When the case study was published in 2024, engineers in Lund ran over 400 integration tests in one week, with at least 20 virtual ECUs on a single laptop, and the setup has kept growing since. It also integrates smoothly into CI pipelines for fast, hardware-free development.

In this example the device-under-test is the Vehicle Control Unit (VCU) and RemotiveTopology is used to simulate the mechatronic rim.

The VCU, running in AWS Graviton is fed with data from mocks and behavioal models running inside RemotiveTopology, controlled through test suites in pyTest.

Early integration testing of core computer functionality in a virtual environment reduces the reliance on scarce/unavailable and costly HIL rigs.

Mocking a vehicle on a Linux laptop
RemotiveTopology Volvo Cars mocking a vehicle for user mode testing
Integrate with Synopsys Silver

Integrate high-fidelity software simulations for increased testing accuracy – vECUs replicates real-world execution for deterministic results.

Validate and integrate individual software components while ensuring seamless operation across the full vehicle network.

The combination allows automotive OEMs to simulate all domains of a modern vehicle network in one place.

Synopsys running with RemotiveTopology: Combining early and advanced software testing.

More about integrating Synopsys
Run Synopsys Silver for increased fidelity together with your RemotiveTopology.
Run integration & functional tests in CI

Volvo Cars: Graviton-powered virtual ECUs enable cloud-based validation of core compute logic with high realism. RemotiveTopology setup with Zuul CI pipeline enables a sense of everyone sitting in the same room, with the same repo, talking to each other.

Test complex software flows across ECUs, apps, and services—without waiting for hardware or full system maturity.

Combining CI pipelines with RemotiveTopology brings stable, scalable simulation into everyday development.

Overview of planned test cases for Software In the Loop (SIL) in coming architectures. A large portion of the tests will be using RemotiveTopology to simulate peripherals, resulting in a fully functional system during tests.

Integrate with CI pipeline
Volvo Cars CI testing overview of central computers and zone controller tests enabled by RemotiveTopology.
What is virtual integration testing?

Virtual integration testing checks that ECUs, services and vehicle functions work together before the hardware exists. With RemotiveTopology, your E/E architecture runs as code on a laptop or in CI, with the same network communication as the real vehicle. You then reuse the same tests from SIL to HIL.

What are examples of virtual integration testing?

- A single ECU tested against a simulated rest of the vehicle, using restbus simulation.
- A central computer with many dependencies, for example mocking a vehicle on a Linux laptop to test the VCU.
- Services that span several ECUs, for example personalization features as in 10x faster multi-ECU regression testing in SIL.
- Infotainment, from Android to ECUs with Cuttlefish.

What is big bang integration, and how do you avoid it?

Big bang integration means all components are integrated and tested at once, often late, when the hardware arrives. Interface errors then show up when they are most expensive to fix. Avoid it by integrating step by step from day one, top-down or bottom-up: start with mocks of the ECUs you depend on, and swap in real software and hardware as they mature.

Watch: Avoiding integration hell in automotive software development

Related articles

Blog posts related to virtual integration testing

Blog
Street lights city