Desktop application · Windows
Watch the bus move.
AmpTrace plots a live CAN bus in real time. Point it at your DBC file and every signal in it becomes a named, engineering-unit trace you can zoom, cursor and compare while the hardware is still running.
Written in Rust
What it does
A scope for your CAN bus, not a frame dumper.
Most CAN tools show you frames and leave the interpretation to you. AmpTrace decodes every frame against your DBC the moment it arrives and puts the physical values on a plot.
Real-time plotting
The trace grows as the frames land. Nothing to refresh, nothing to wait for.
- Stacked axes per signal, or overlaid on one scale
- Zoom to a millisecond while the capture keeps running
Receive and transmit
AmpTrace is not a listener. Command the target and watch it answer on the same screen.
- Received frames arrive already scaled to Nm, A, rpm
- Encode frames in engineering units, AmpTrace builds and sends the frame
Signals find themselves
No channel list to build or maintain. Load the DBC and the signals are already there.
- Every signal named the way your DBC names it
- Drop any signal on any axis, regroup them mid-run
From bus to plot
Four steps, and you are looking at data.
01
Load the DBC
The file you already maintain for the vehicle or drive. No second definition to keep in sync.
02
Connect to the bus
A USB CAN adapter between the laptop and the hardware. One click to go live.
03
Frames decode
Each frame is matched, scaled and timestamped as it lands, raw bytes become physical units.
04
Plot, probe, export
Watch it live, cursor through it afterwards, or write the whole capture out to disk.
Beyond the live view
Analysis that stays in the same window.
XY plots
Put one signal against another, current against speed or torque against angle, to see the shape of a relationship instead of two lines that happen to move together.
FFT
Take any captured signal into the frequency domain to chase an oscillation back to its source: a switching artefact, a resonance, a control loop hunting. All in real time.
Compare two runs
Load a saved capture alongside a second one and hold them on the same axes. Export a session to disk and bring it back later, or hand it to a colleague.
Built-in test runner
Script the bus, or prove the product works.
Every copy of AmpTrace includes a test runner. It scales with what you are trying to do: the same sequence that saves you from clicking through a start-up procedure by hand is also, once you add assertions to it, a hardware-in-the-loop test you can put in front of an auditor.
Scripting a stimulus
A list of frames to send and how long to wait between them. Press run and the bus is driven for you: a start-up sequence, a sweep through operating points, a fault you need to reproduce for the tenth time today.
Verifying the response
Add the checks and the same sequence becomes a real test. Wait for a signal to settle, assert it lands in tolerance, hold it there to prove it stays. Each step returns a verdict with the captured trace behind it. Setup brings the target to a known state, and teardown runs whatever happens.
Suites are plain files that live in version control beside the firmware they test, so the same scenario runs identically on every bench and on every revision of the product.
Performance
Built in Rust, so the hardware sets the pace.
A viewer that stutters makes you doubt the measurement instead of the machine. AmpTrace is a native desktop application with a Rust core, so a busy bus never turns into a laggy window. What you are watching is the drive's behaviour, never the tool's.
Decoding never blocks the view
Frames are received and decoded on their own asynchronous tasks. A busy bus slows the bus, not the window you are looking at.
Only the new samples move
The display asks for what has arrived since it last drew, not the whole capture again. Long recordings cost the same per frame as short ones.
Drawn on the GPU
Traces render through WebGL, so hundreds of thousands of points stay interactive. Zooming into a millisecond of a long run is instant.
Interface
USB CAN adapter
Definitions
Standard DBC files
Platform
Native Windows desktop app
Built with
Rust · Tauri · WebGL charts
Drive software
Get everything your motor can give.
Our motor control software is already tuned for every WattStep motor and inverter. You get a drive that works from day one, written in Rust.
Talk to us about your drive- Motors
- 4
- Inverter hardwares
- 2
- Application protocols
- 3
[ For customers ]
What must your machine do, and by when?
With a shelf inverter you buy a box and a tuning job. With us you buy a drive that already works on your motor.
Tuning is done for you
Your engineers do not spend months on it.
It fits your system
We adapt to your controller and protocol.
Changes are quick
We own the source, so a change never waits on a vendor roadmap.
Your own motor works too
No datasheet needed. Our test rig extracts the motor parameters automatically and we calibrate the software to them.
[ Why Rust ]
Motor control firmware in the language the industry is moving to.
Rust catches memory errors before the firmware ever runs. Microsoft, Google, Volvo and the Linux kernel are all moving to it. Our firmware has been Rust from the first line.
What Google measured in Android
- Lower memory safety vulnerability density in Rust than in C and C++2
- 1000×
- Lower rollback rate than C++ for medium and large changes2
- ~4×
- Less time in code review than C++ changes2
- ~25%
- Memory safety share of Android vulnerabilities in 2025, down from 76% in 20193
- <20%
What this means in our firmware
We started here
Our motor control code has been Rust since its first line. The firmware holds no C or C++, so there is nothing to migrate.
The compiler guards memory
Our core control library contains no unsafe code, and the compiler rejects any attempt to add it.
Physical units are checked
Every quantity carries its unit in its type, so adding a voltage to a current does not compile. NASA lost the Mars Climate Orbiter in 1999 over a unit mismatch.
Concurrency without fear
The RTIC framework checks at compile time that shared data is safely locked, so tasks from the current loop to communication cannot race or deadlock.
Figures come from large software projects, not motor drives. Control behavior is verified in simulation, hardware in the loop tests and on our test rig.
[ Sources ]
- Microsoft Security Response Center, We need a safer systems programming language, July 18, 2019.
- Jeff Vander Stoep, Google, Rust in Android: move fast and fix things, November 13, 2025.
- Google, Eliminating Memory Safety Vulnerabilities at the Source, September 25, 2024.
- Thomas Claburn, The Register, Microsoft is busy rewriting core Windows code in memory-safe Rust, April 27, 2023.
- Tweede golf, Rust is rolling off the Volvo assembly line, October 7, 2024.
- CISA, New Guidance Released for Reducing Memory-Related Vulnerabilities, June 24, 2025.
- Miguel Ojeda, rust: conclude the Rust experiment, Linux kernel mailing list, December 12, 2025.
- eeNews Europe, report on Ferrocene 26.02.0, March 19, 2026.
- NASA, Mars Climate Orbiter Mishap Investigation Board Phase I Report, November 10, 1999.

[ FIRST CONVERSATION ]
Book a meeting
Erik Strigén, Business Developer, takes the first conversation about your drivetrain, timeline and requirements. Pick a slot directly in his calendar.
Book a meeting with Erik