Open source · ML infrastructure · Cross-framework adoption

Standalone TensorBoard

In 2016 the best way to watch a model train lived inside one framework. A team on MXNet or PyTorch could write the log file perfectly well and then had no way to open it — the renderer existed only inside a TensorFlow installation. I rebuilt it as a standalone tool that did both halves, logging and rendering, in one package. Amazon built its official MXNet tooling on that work, the PyTorch ecosystem referenced it, and TensorBoard itself now installs without TensorFlow.

Project
Role
Primary author
Problem
Framework lock-in
Built on it
AWS mxboard
Cited in
SOCKEYE, AMTA 2018
Standing
Top 3% of ML-visualisation repos
In one minute, without the jargon

Training a neural network is hours or days of numbers going past. TensorBoard turns them into charts — loss curves, weight histograms, sample images — so you can see whether a run is healthy before spending another day on it. In 2016 it was the best tool of its kind, and Google shipped it as part of TensorFlow.

There are two halves to using it. Writing the log file, and reading it. Writing had precedents: the file format was public, and a few people had written small libraries that produced compatible files from other frameworks. Reading was the wall. The renderer — the web application that actually draws the charts — was built into TensorFlow and could not be run by itself. So an MXNet or PyTorch user could produce a perfectly valid log file and then had to install Google's entire framework, a direct rival to the one they had chosen, purely to look at their own training run.

I built both halves into one standalone package: a logging interface a non-TensorFlow trainer could write through, and the renderer lifted out of TensorFlow. One install, the same charts, no framework attached. That layer is what other people then built on.

Apache MXNet
Its documentation names me the primary author of the repository.
“He carved out from TensorFlow necessary protobuf definitions and designed low level logging interfaces for building a standalone logging and rendering tool.”
AWS
mxboard, the official MXNet visualisation library, was built on this work and credits it in the README.
“The idea of this project comes from discussions with Zihao Zheng, the author of dmlc/tensorboard.”
PyTorch
tensorboardX brought the same capability to a competing ecosystem and lists this project as a reference.
A rival framework's community building on the same layer.
Amazon Science
SOCKEYE, Amazon's neural machine translation toolkit, renders its training statistics with this project and cites it.
Peer-reviewed, AMTA 2018.
Google
TensorBoard installs as its own package today, and TensorFlow is no longer in its requirements.
The architecture argued for here — publicly agreed to by TensorFlow's engineering director in 2017.

A tool you could not open

In late 2016 I was training models on MXNet and doing what everyone else did: plotting metrics by hand with matplotlib, resizing images, mailing PNGs to colleagues. TensorBoard already solved all of that, and I could not use it.

I scoped the work in public, on the MXNet issue tracker, and the sticking point was there in the first pass:

“Or we could install entire TF together with MXNet? Is that acceptable? I think it's okay but not good for our users and make this visualization tool too heavy.”

apache/mxnet#4003, 27 November 2016

That is the whole problem in one line. Asking a framework’s users to install a competing framework in order to see their own charts is not a dependency, it is a tax — and one paid by every non-TensorFlow community at once, which is what made it worth fixing properly rather than fixing for MXNet.

The widget below is that decision, made concrete. Pick a framework, then try to get a chart on screen.

Interactive — pick a framework, try to see your training run

The same log file. Whether you can open it depends on what you trained with.

Writing a valid TensorBoard event file was the half with precedents. The question is what you must install to render it. Switch the standalone tool off to see the world as it was in 2016, then switch it on.

This interactive needs JavaScript. In short: before this project, rendering a TensorBoard event file required a full TensorFlow installation, so MXNet and PyTorch users had to install a rival framework to look at their own training runs. Packaging a logging interface and the renderer together as one standalone tool removed that dependency, and TensorBoard has shipped without a TensorFlow requirement ever since.

The chart is illustrative; the dependency is not. The renderer was a web application that could only be obtained by installing the machine-learning framework it happened to ship inside — which is why the fix had to be a separate package rather than a feature request.

What already existed, and what did not

Writing the log — precedents existed

The event-file format was public, and community developers had already written pure-Python adapters that emitted compatible files. The package carries its own logging interface, built on those same public format specifications by design: the files are worthless unless TensorBoard's own renderer can read them.

Rendering it — nobody had done that

The renderer was compiled as part of TensorFlow and had no life outside it. Carving out the protobuf definitions and the rendering front end, then shipping them together with the logging interface so the whole path installed in one command with no TensorFlow present, is what did not exist before this project.

The SOCKEYE paper describes it as “a standalone Tensorboard fork,” and in open-source usage that word describes provenance — a repository derived from another — rather than a judgement about originality. Still, it is worth being exact, because the halves are not equally hard. The format was Google’s and public, and logging adapters already existed. What the field lacked was a renderer that ran on its own — and, with it, a single tool that took you from a training loop to a chart without TensorFlow anywhere in the install.

What the field did with it

Two rival ecosystems ended up on it. AWS released mxboard in March 2018 as the official way to log MXNet data for TensorBoard, crediting this project as its origin. In the PyTorch world, tensorboardX — still one of the most widely used visualisation libraries outside TensorFlow — lists it as a reference. Amazon’s research toolkit SOCKEYE cited it in a peer-reviewed paper for rendering training statistics.

AWS mxboard GitHub repository, crediting discussions with Zihao Zheng, the author of dmlc/tensorboard
AWS mxboard — official MXNet tooling, built on this architecture and crediting it in the README.

Two of these numbers are not mine to claim — they count other people’s packages. What they measure is whether the field still runs through this layer nearly a decade later.

5.9M
Monthly downloads of tensorboardX — its README credits this project
5,878,978 in the month to May 2026 — live count
2,075
Monthly downloads of AWS's mxboard eight years after its last release
Final release 0.1.0, May 2018; measured May 2026 — live count
Top 3%
GitHub ranking of dmlc/tensorboard among machine-learning visualisation repositories
≈position 60 of ~2,000 tagged both visualization and machine-learning, and top 2.4% of the ~25,700 in visualization alone, by stars, June 2026

The mxboard figure is the small number that says the most. Its last release was May 2018, and Apache MXNet — the framework it served — was retired to the Apache Attic in September 2023. Eight years without an update and two years after its framework was formally shut down, it is still installed around two thousand times a month by people who need to see inside a training run. Every figure above links to a live counter rather than a screenshot; counts and rankings move, and these were read in May and June 2026.

Then the incumbent moved. In mid-2017 Google split TensorBoard out of TensorFlow into a project of its own, and in a public thread on this repository the engineering director leading TensorFlow acknowledged the work and addressed the dependency directly:

“We appreciate all your work you have done to support this community. […] The last concern for this group is the dependency on TensorFlow. This will take a bit more work to remove, but it does make sense to keep it independent and we will remove it.”

Rajat Monga, Engineering Director for TensorFlow at Google — dmlc/tensorboard#50, July 2017

They did remove it. TensorBoard’s own requirements file no longer lists TensorFlow, and the code keeps a stub that stands in when TensorFlow is absent — running without it is a maintained path, not an accident. Google’s README states it directly: TensorBoard “can be run with a reduced feature set if you do not have TensorFlow installed.” A few plugins and Cloud Storage log directories still want it. For the ordinary case of writing a log and reading it back, the dependency this project existed to work around is gone from the original too. The strongest evidence that a piece of infrastructure was right is usually not that it was adopted downstream but that the incumbent adopted its position, and that is what happened here.

GitHub thread where Rajat Monga of Google thanks @zihaolucky for the standalone TensorBoard work
The public thread on dmlc/tensorboard#50.

Why a charting tool was a competitive problem

Why this is a business result, not only a technical one

Amazon said the quiet part out loud when it launched mxboard: “We have had feedback from many different users, including corporate ones, that they started using TensorFlow because of the rich feature set offered in TensorBoard.” Teams were choosing an entire deep-learning stack — and with it a cloud, a hiring profile and years of code — on the strength of its inspection tooling.

That reframes what this project was. Not developer convenience, but the removal of a switching cost that was steering enterprise customers toward one vendor. It is also why the work survived its author’s involvement: AWS needed MXNet to be a credible choice, the PyTorch community needed the same, and both got there through the same layer.

There is a durable lesson in it for the work I do now. Inspectability decides whether a model can be trusted in production, and inspectability that only exists inside one vendor’s stack is not inspectability for the field — it is a lock. The same instinct runs through the memory-network NLU work, where attention weights were exposed so operators could see why a request routed the way it did, and through the Indicator Loss patent, where the whole point is that a biasing decision is a logged value rather than a guess.

Timeline

The underlying evidence

TensorBoard visualisation toolkit — scalars, graphs and experiment tracking
TensorBoard: the visualisation layer this project made framework-agnostic.

← Back to home · All projects