# livelossplot's optional Bokeh backend is a required install

> A plotting package built for notebook users ships three hard runtime dependencies, four ways to install itself, a TensorBoard answer that contradicts the writers it bundles, and a set of examples the README never links.

**stared/livelossplot** — Live training loss plot in Jupyter Notebook for Keras, PyTorch and others

- Repository: https://github.com/stared/livelossplot
- Stars: 1,320 · Forks: 141
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/stared-livelossplot

## bokeh>=3.0 is a hard dependency for a backend you may never touch

The manifest declares three runtime dependencies and no extras:

```toml
dependencies = [
    "matplotlib>=3.6",
    "bokeh>=3.0",
    "ipython>=8.0",
]
```

Bokeh is not optional in that list. The README offers exactly two plot classes, `MatplotlibPlot` and `BokehPlot`, and you pick between them by passing one of them into `PlotLosses(outputs=[...])`. So every user who chooses Matplotlib, which the README presents first and the Keras example never overrides, still resolves bokeh>=3.0 at install time.

The Keras path makes this concrete. `PlotLossesKeras()` takes no outputs argument in the README's own snippet, so nothing in that call names a backend at all, and bokeh is already on disk by then. There is no extras group to trim it, and no environment marker narrowing it to the Bokeh code path.

## The TensorBoard answer contradicts the TensorBoard writers it ships

Two passages pull in opposite directions. The FAQ block, headed with a typo that reads (The most FA)Q, asks Why not TensorBoard and answers with two reasons: Jupyter Notebook compatibility for exploration and teaching, and simplicity of use. The Overview section then says if you want to get serious, use TensorBoard. That sentence is also unfinished, ending in a link followed by a comma and a full stop.

Then the package ships the writers anyway. The outputs module carries `MatplotlibPlot`, `BokehPlot`, and three loggers: `ExtremaPrinter`, which goes to standard output, `TensorboardLogger`, and `TensorboardTFLogger`. A single call wires any of them in, for example `PlotLosses(outputs=[MatplotlibPlot(), TensorboardLogger()])`.

So the advice is not really a refusal. It is a ranking, and one the code does not enforce.

## Four install paths, and one of them skips the release

Installation gets four treatments. From PyPI there is `uv add livelossplot` or `pip install livelossplot`, requiring Python 3.10 or newer. For a one-off script, `uv run --with livelossplot script.py` builds an ephemeral environment instead. Dependencies can also be pinned inside the script itself with an inline metadata block declaring requires-python >=3.10 and dependencies on livelossplot and torch, after which plain `uv run script.py` suffices. For notebooks, `uv run --with livelossplot --with jupyterlab jupyter lab`.

The fifth option is a source install, and it behaves differently from the rest:

```bash
uv add "livelossplot @ git+https://github.com/stared/livelossplot.git"
# or
pip install git+https://github.com/stared/livelossplot.git
```

The manifest declares version 0.6.1 and tag v0.6.1 was published on 2026-05-05, with v0.6.0 a day earlier on 2026-05-04. The last push to main came on 2026-07-26. Installing from git therefore gets you code that is roughly three months newer than the newest tag, with no version number to tell you so.

## Three notebooks in examples/ are never linked from the README

The examples directory holds thirteen files. The README links ten of them, one line each, from `keras.ipynb` through `various_options.ipynb`, and points the reader at Colab for running them.

Three files sit outside that list: `bokeh_colab.ipynb`, `multigrup.ipynb`, and `pytorch-ignite.ipynb`. The last one matters most, because the class list names `PlotLossesIgnite` among the framework callbacks, right beside `PlotLossesKeras`, `PlotLossesKerasTF` and `PlotLossesPoutyne`. The Ignite adapter is advertised in the API section and has no link to its example anywhere in the file.

The ruff configuration explains part of the silence. Its exclude list covers examples, build, dist and scripts, so the notebooks are not linted, and `line-length` is set to 120 with a target version of py310. Whatever the reason, the gap between the class list and the linked examples is where a new user looks first.

## Both ends of the project stop in the middle

The README closes under Trivia. That section says the project began as a gist and was rewritten as a package once it became popular, then points at the author's writing on network diagrams, and ends on a block quote that opens A good diagram is worth a thousand equations and stops after the words let's create more. Nothing follows it in the file.

The manifest stops at a similar place, partway into the ruff lint table after the exclude list. What is above that line is complete and useful: build backend hatchling, wheel packages set to livelossplot, an sdist include list of livelossplot, README.md, LICENSE.txt and CHANGELOG.md, an MIT license declared with its file named, and a dev group holding pytest, ruff, ty and jupyter alongside a docs group holding pdoc.

The funding note in the README is also specific: four named sponsors, a request to join them, and a European programme acknowledgement for a mapping project led by ECC Games.

## Python 3.10 sets the floor for both install and lint

requires-python is >=3.10, and the classifier list names 3.10, 3.11, 3.12 and 3.13. The lint target matches the floor exactly at py310, so nothing in the configuration suggests testing against a newer interpreter than the one the package refuses to run below. The trove classifier calls the project Beta.

The manifest also fills in what the repository page leaves out. Homepage, Repository, Issues and Changelog all point at the GitHub project, and the README links hosted API documentation generated with pdoc from the docs group. That documentation lives on a personal domain rather than under the repository.

Keywords are six tokens: keras, pytorch, plot, chart, deep-learning. Nine open issues sit against a package whose public surface is small, which is the shape of a project with a broad user base and a narrow core.

## The Keras example silences the log the plot is meant to replace

The headline promise is to be impatient and look at each epoch of training. The one complete code example in the README hands the framework the opposite instruction:

```python
from livelossplot import PlotLossesKeras

model.fit(X_train, Y_train,
          epochs=10,
          validation_data=(X_test, Y_test),
          callbacks=[PlotLossesKeras()],
          verbose=0)
```

`verbose=0` is consistent with the idea, since the callback is the feedback channel now. The example also passes X_test and Y_test as validation data, so the plotted val_loss comes from data named as test data.

The bare API is two calls. `plotlosses.update({'acc': 0.7, 'val_acc': 0.4, 'loss': 0.9, 'val_loss': 1.1})` takes the metric keys, and `plotlosses.send()` draws and updates logs. Those four keys are the only metric names the README demonstrates, and no reference page of accepted keys sits beside them. `MainLogger` is offered when you want logging without plotting.

## Conclusion

The plotting side is small enough to read in an afternoon, and the notebook path it advertises works with one callback object. Two things deserve a decision before you depend on it. Bokeh arrives whether you asked for it, so environments with a locked dependency set need that resolved first. And the TensorBoard story is unsettled: the same package tells you to move to TensorBoard if you want to get serious, then ships two TensorBoard writers. Check which one you actually want, and if you install from git, remember that main is ahead of the newest tag and carries no version bump of its own.

## FAQ

### Does livelossplot replace TensorBoard?

Not according to its own text, which gives two reasons for not using it, Jupyter Notebook compatibility and simplicity of use, then tells readers who want to get serious to use TensorBoard instead. The package still ships TensorboardLogger and TensorboardTFLogger in its outputs module for anyone who wants them.

### What does installing livelossplot pull into my environment?

Three runtime dependencies: matplotlib>=3.6, bokeh>=3.0 and ipython>=8.0, on Python 3.10 or newer. Bokeh is resolved whether or not you use BokehPlot. pytest, ruff, ty and jupyter sit in a dev group, and pdoc in a docs group, so they are not runtime requirements.

### Which livelossplot example should a new user open first?

minimal.ipynb is the bare API and works anywhere, keras.ipynb is the Keras callback, and script.py is meant to be run as a script. The README links ten of the thirteen files in the examples directory, leaving bokeh_colab.ipynb, multigrup.ipynb and pytorch-ignite.ipynb unlinked.

### Which version of livelossplot is current, and does main differ from it?

The manifest declares 0.6.1, and tag v0.6.1 was published on 2026-05-05 after v0.6.0 on 2026-05-04. The last push to main was on 2026-07-26, so an install from git gives code newer than that tag without a version number of its own.

### How old is the livelossplot codebase?

The last push to the main branch landed on 2026-07-26 and the repository is not archived. The trove classifier describes the project as Beta, and the newest release is v0.6.1 from 2026-05-05.

## Sources

- [Issues](https://github.com/stared/livelossplot/issues)
- [License: MIT](https://github.com/stared/livelossplot/blob/main/LICENSE)
- [README](https://github.com/stared/livelossplot/blob/main/README.md)
- [Releases](https://github.com/stared/livelossplot/releases)
- [stared/livelossplot on GitHub](https://github.com/stared/livelossplot)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/stared-livelossplot