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.
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)
17Run 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.
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.
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.
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.
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:
22Using 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.
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.
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.
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.
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.
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.
for 30 days
Top use cases - Virtual integration testing
Use RemotiveTopology to run early integration tests across vehicle domains -without waiting for hardware or other teams.
Whether you're developing body control logic, infotainment features, or services that span multiple ECUs, virtual integration testing lets you configure, simulate, and validate real production setups from your laptop. Iterate faster, collaborate in code, and shift integration left.
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.

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.

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

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.

Frequently asked questions
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.
- 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.
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
Blog posts related to virtual integration testing
Join the automotive rebels that #getstuffdone with RemotiveLabs!





.jpg)
.jpeg)

