WireTrace

WireTrace was built for an internal need on my team. We work across a range of problems in research and development, and serial monitoring is one of the things that comes up often — when we are bringing up new hardware, capturing data from a device for later analysis, or trying to make sense of what a board is reporting.

We had been using whatever serial tools were already available, and over time the gaps in those tools started to add up. WireTrace started as something to fill those gaps, and grew from there.

The first version (called SerialLoggerPro) was a single Python file built on Tkinter. It worked for the original use case — one port, one device, one log file — but the way it was structured made it hard to extend. Threading was managed manually with locks. The dependency list grew as each new feature pulled in something else.

Adding multi-device support would have meant rewriting the threading model. Adding cleaner exports would have meant replacing the export pipeline. Each new addition would have made the next one harder to add cleanly.

At that point, continuing to patch the existing code stopped making sense. The decision was to start over with an architecture that could support what the application needed to become.

The current version, WireTrace v1.1.0, is built on PySide6 (Qt6 for Python) and organized into modules with single responsibilities. The serial reader handles only serial I/O. The disk writer handles only disk I/O. The component that filters the on-screen view does not interact with the disk log. These boundaries make it possible for the application to do several things at once without one part interfering with another.

Each connected device opens in its own tab with its own thread, reading from its own port into its own buffer, and writing to its own log file. Multiple USB-to-serial adapters can be connected simultaneously without one device’s data interfering with another’s.

Logging uses a buffered write model. Incoming data is appended to an in-memory buffer with a hard size cap, and a separate thread flushes that buffer to disk on a timer. The read path is never blocked by disk I/O. If the application exits or crashes, the buffer is flushed before shutdown. The log file on disk is the source of truth — it contains every line received, regardless of what the on-screen view is showing at any moment.

The source is available on GitHub under the MIT license. The tool is designed to be installed from a binary, but you can clone the repository and build it yourself if you prefer.

WireTrace is designed to run on Windows, macOS, and Linux. The codebase is cross-platform — it uses Qt for the UI, QSerialPort for serial I/O, and a build pipeline that produces native binaries for all three operating systems.

Pre-built binaries are currently published for Windows only. This is a practical limitation of who maintains the project, not a design limitation of the software. If you want WireTrace on macOS or Linux, you can build it from source using the included build scripts — the build guide in the repository covers all three platforms. If there is enough interest, pre-built macOS and Linux binaries become a realistic priority.

WireTrace uses CPU-only software rendering, which means it works in remote desktop sessions, virtual machines, and hardware without dedicated graphics.

Download the Windows installer from the GitHub Releases page. Run the installer and follow the prompts. The application launches from the Start menu. On first launch, the welcome screen prompts for a device connection — the rest of the interface appears once a device is connected.

For macOS or Linux, clone the repository and build from source. Instructions are in the repository’s build guide.