From the workbench · Open source

Built for my
workbench.
Shared for yours.

Canvaz for CAN bus analysis, Pigtail for serial debugging, and Snout for exploring firmware memory usage. Open-source tools for embedded development on Windows and Linux, built to help with my work and personal projects, and shared in the hope they help with yours.

Explore the tools

CAN buses. Serial ports. Firmware memory. A little less guesswork.

Canvaz / CAN analyzer
Pigtail / Serial terminal
Made for embedded developmentWindows & LinuxOpen source on GitHub

01 / The tools

Three tools. Less friction.

From bus traffic to firmware builds,
make sense of what your device is doing.

CAN ANALYZER01

Canvaz.

See what’s happening on the bus.

Trace, decode, plot, and simulate CAN traffic in one place. Turn raw frames into meaningful signals with DBC files, then follow them live.

Latest release · Click to enlarge
  • Live frame tracing and filtering
  • DBC decoding and real-time signal plots
  • Message simulation and J1939 support
  • Kvaser, PEAK PCAN, and Linux SocketCAN
SERIAL TERMINAL02

Pigtail.

Keep the conversation with your device.

A serial terminal built for real debugging sessions. Follow devices through resets, find what matters in the log, and plot the numbers behind the text.

Latest release · Click to enlarge
  • Auto-reconnect by USB device identity
  • Search and filter the full captured history
  • Live plots linked back to their log lines
  • Continuous raw capture and multi-port views
FIRMWARE EXPLORER03

Snout.

Find where your firmware’s memory goes.

Open a build folder or ELF file to explore Flash and static RAM usage. Find the largest contributors and compare saved builds, with analysis staying on your computer.

Latest release · Click to enlarge
  • Flash and static RAM usage breakdowns
  • Drill into source files, symbols, and sections
  • Saved snapshots and build comparisons
  • Linker dependencies, stack reports, and hex viewer

On Ubuntu? Install with apt below ↓ · Other downloads are available on GitHub.

02 / From download to workbench

Install on Ubuntu

Add the repository once.
Keep your tools up to date with Ubuntu.

Ubuntu 22.04+64-bit Intel / AMD · amd64
  1. Prepare your system

    Open a terminal and install the tools needed to fetch the repository’s signing key.

    Terminal
    sudo apt update
    sudo apt install ca-certificates curl
  2. Add Rusty’s repository

    Save the public signing key and register the package source. You only need to do this once.

    Repository setup
    (
      set -e
      key_file=$(mktemp)
      trap 'rm -f "$key_file"' EXIT
      curl -fsSL https://rustypig91.github.io/rusty-apt/rusty.asc -o "$key_file"
      sudo install -D -m 644 "$key_file" /etc/apt/keyrings/rusty.asc
      echo 'deb [arch=amd64 signed-by=/etc/apt/keyrings/rusty.asc] https://rustypig91.github.io/rusty-apt stable main' | sudo tee /etc/apt/sources.list.d/rusty.list
      sudo chmod 644 /etc/apt/sources.list.d/rusty.list
    )
  3. Install your tools

    Install all three, or keep only the package names you want. Then launch them from your applications menu.

    canvazpigtailsnout
    Ready for the workbench
    sudo apt update
    sudo apt install canvaz pigtail snout

Keep them current

Update alongside your other system packages.

sudo apt update && sudo apt upgrade

Need to uninstall?

Remove any tools you no longer need.

sudo apt remove canvaz pigtail snout

Packages and repository setup: Rusty APT documentation

03 / Made for the debugging session

What sets them apart.

The details that help when a frame table,
a scrolling terminal, or a size total is only the beginning.

CAN ANALYZER

Canvaz.

A conventional CAN workflow can mean juggling a trace viewer, a decoder, and a plotting tool. Canvaz brings those steps into one workspace, with support for the protocols behind the frames.

Automatic reconnect
Recover from an interrupted connection without rebuilding your workspace. Keep your channel setup ready for the next round of debugging.
DBC decoding and live plotting
Load a DBC per channel to turn bytes into named signals, units, and value-table labels. Drag signals into live plots with zoom and multiple signal panes to follow how values change.
J1939 beyond individual frames
See PGN, priority, source, and destination addresses in the trace. Passive transport protocol reassembly supports both BAM and RTS/CTS, bringing multi-packet messages back together.
Simulation in the same workspace
Send DBC-defined messages or raw frames at configurable intervals. Build repeatable bus traffic alongside the trace and plots you use to inspect the response.
A setup you can come back to
Save channels, plots, and simulator settings as a project, or resume your last session automatically. DBC browsing and configuration stay editable even when an interface is missing.
Recording independent of the view
Continuously record received and transmitted frames across channels to CSV, including reassembled J1939 messages. Display filters, a paused trace, and the in-memory retention window do not limit the recording.
Explore Canvaz’s features

SERIAL TERMINAL

Pigtail.

A conventional serial terminal gets you connected and shows the output. Pigtail adds ways to keep that session useful through device resets, repeated commands, and long streams of logs.

Reconnect to the device, even on a new port
Automatic reconnect uses USB VID, PID, and serial number to find the device after it resets or re-enumerates. A visible gap marker shows where the connection was interrupted.
Macros and command history
Recall previous sends, including commands sent by macros. Named macros combine commands, delays, and regex waits, with loops and keyboard shortcuts for repeatable debugging sequences.
Filters that reach back into history
Plain-text and regex filters apply to output already captured, as well as new arrivals. Search the captured scrollback and highlight patterns to find the lines that explain a problem.
Live plots linked to the log
Extract numbers from text or regex matches and plot them live. Click a point to jump to its source log line; adding or editing a plotting rule also reprocesses the captured session.
Raw capture and restored history
Raw bytes are written to disk continuously, and saved captures restore history across restarts. Use text, hex, or ANSI/VT views to inspect logs, binary data, or interactive device shells.
Multiple devices, one timeline
Keep ports in named tabs, compare them in resizable split panes, or merge selected connections into a timestamped view. Follow the conversation between devices without switching between separate terminals.
Explore Pigtail’s features

FIRMWARE EXPLORER

Snout.

A firmware size total tells you how much memory a build uses. Snout helps you find what contributes to that total and understand what changed after a rebuild.

From memory totals to individual symbols
Explore Flash and static RAM usage by source file, function, variable, and ELF section. Supported linker maps add memory-region capacity and remaining space.
Compare builds with saved baselines
Save a snapshot before a change, then compare builds to investigate size differences. Refresh after rebuilding to follow the effect of your changes.
Supporting files found automatically
Open a build folder or ELF file. Matching linker maps and compiler stack reports are discovered automatically where possible.
Look beyond memory size
Explore linker dependencies, compiler stack reports, and firmware bytes in the hex viewer to investigate the build in more detail.
Desktop exploration and command-line analysis
Browse builds in the desktop app or analyze and compare firmware with the CLI. Firmware analysis stays on your computer.
Built for embedded firmware
The main target is ARM Cortex-M firmware built with GCC. Other ELF files depend on available metadata; static RAM totals do not predict all runtime heap and stack requirements.
Explore Snout’s features

04 / Behind the tools

It starts with
“I wish I had a tool
for this.”

Christoffer @rustypig91 ↗

I build tools to solve the problems I run into at work and in my personal projects.

Sometimes it’s a CAN signal that’s hard to follow. Sometimes it’s a serial device that disappears halfway through a debugging session. Sometimes it’s a firmware build that’s running out of memory. These tools grow out of those everyday moments.

I’m developing Canvaz, Pigtail, and Snout as open source because I hope they can be useful to others, too. Sharing them is also a way to learn: different hardware, different workflows, and fresh ideas can help me make them better over time.

They’re ongoing projects, shaped by real use. If one helps you, or you see a way to improve it, I’d love to hear about it.

05 / Build along

Better tools start with real feedback.

Try them on your hardware. Report a bug. Suggest a feature.
Or jump into the code and help make the next version better.