TUEplots and the matplotlib helper for publication-sized figures

A helper for figure geometry rather than a plotting style

tueplots is a small Python package that extends matplotlib for scientific publications. The stated goal is to help you create scientific plots for papers, presentations and posters, and the project description puts it plainly: figure sizes, font sizes, fonts and further configurations at minimal overhead.

The scope is narrower than a plotting style sheet, and that narrowness is the design. The README states that tueplots does not try to make your plots as beautiful as possible, and it explains the reasoning with a parenthetical about judging a favourite colour. Instead, it targets the recurring failures of academic figures: a figure that is too small to read when printed, a font size that does not match the surrounding paper, and inconsistency between the figures of one manuscript.

Two opinions are retained. Figure sizes should match the text width of the publication, and the font size inside the plot should be readable and consistent with the rest of the paper or presentation. Everything else, from colours to frame styles, markers and linewidths, is left to you.

That makes tueplots closer to a set of measurements than to a theme, which is exactly why it can sit next to other matplotlib tooling without a fight over global state.

No internal state, so the change stays yours to apply

The first principle in the README is that tueplots has no internal state. It only passes around dictionaries whose key-value pairs match those matplotlib uses. Nothing is applied behind your back, and nothing is remembered between calls.

Applying the change is a separate, explicit step. The README points at matplotlib's own mechanisms: pass the values to matplotlib.pyplot.rcParams.update() if you want to change settings globally, or to matplotlib.pyplot.rc_context() if the values should apply only inside a specific context. In other words, the package produces the configuration and matplotlib applies it, and the decision about scope stays with the caller.

The stated benefit follows from that arrangement. Because tueplots makes the change easy, the easy change becomes yours to make, and the package is described as naturally compatible with other matplotlib extensions. For a codebase that already sets rcParams for its own reasons, that is the difference between a library you can drop in and one you have to fight.

There is a practical consequence worth weighing: nothing is enforced. If a figure still comes out at the wrong size, the reason is a missing update call or a context that closed too early, and the library will not raise an error about it.

Installing from PyPI and reading the getting-started pages

The README does not contain an installation command. It states that installing tueplots is explained in the documentation, and the installation page lives at tueplots.readthedocs.io under the getting started section. The package itself is published on PyPI, and the README links the PyPI project page from its version badge.

The packaging metadata tells you what you are installing and what it pulls in:

[build-system]
requires = [
    "setuptools>=64",
    "setuptools_scm>=8",
]
build-backend = "setuptools.build_meta"

The build uses setuptools with setuptools_scm, which means the version number is derived from the git history rather than typed into the file:

[project]
name = "tueplots"
description = "Scientific plotting made easy."
requires-python=">=3.10"
dependencies = [
  "matplotlib",
  "numpy",
]

Only matplotlib and numpy are required at runtime, and Python 3.10 is the floor, with classifiers listing 3.10 through 3.14. Two optional extras exist: ci brings tox, and examples brings jupyter for the example notebooks. So a runtime install stays light, and the heavier tooling only arrives if you work on the library itself.

For a first real use, the README routes you to a usage example page, an ICML 2022 tutorial page, a troubleshooting page and example notebooks for more advanced work. That routing is where the actual code lives.

The ICML 2022 template is the reference scenario

The example the README leads with is a style tailored to the ICML2022 template, illustrated with three images: default matplotlib on the left, one line of tueplots code in the middle and two lines on the right. The comparison is deliberately modest. It is not showing a different plot, it is showing the same plot at the size and with the fonts that the template expects.

A more specific tutorial, applying tueplots to figures intended for ICML 2022, has its own page in the getting started documentation, and the README mentions that such a tutorial exists. The pattern this implies is worth naming, because it is how a package like this gets used in practice: a venue publishes requirements about figure width and about the font size that matches the body text, and those requirements become a dictionary in tueplots that your script passes to matplotlib.

The same structure generalises to a lab, a thesis or a talk series. If every figure in a manuscript has to obey one width and one font size, encoding that once and applying it per figure is the whole value proposition, and it is small enough that tueplots does it in a dictionary rather than a framework.

The gap between the README and the documentation

This is the honest limitation of the project as a self-contained reference. The README contains no usage code at all. Every example the project offers is a link: installation, usage examples, an ICML 2022 application page, troubleshooting and example notebooks. The two principles in the README are stated in prose, with the matplotlib calls written as inline code inside sentences rather than as runnable blocks.

That is defensible for a package whose API surface is small, but it does mean that a reader cannot learn the call sequence from the README alone, and the troubleshooting page exists precisely because there are things that do not work as promised.

Two consequences follow for an adopting team. First, you need the hosted documentation at tueplots.readthedocs.io to get started, which means the reading experience depends on that site rather than on the repository. Second, since the package exposes dictionaries rather than a configuration file, there is no project-level file to commit and diff. The style you use lives in your own code, which is a virtue for reuse and a cost for reproducibility across a lab, since there is nothing in the repository that records which venue style a given figure was meant to follow.

The version file is also generated. The setuptools_scm configuration writes the version into tueplots/_version.py, and the ruff configuration excludes both that file and tueplots/__init__.py from linting, which tells you the package entry point carries generated content rather than a hardcoded version string.

Related plotting packages and the difference in approach

The README names a set of related packages and links them. They are Seaborn at seaborn.pydata.org, ProPlot at proplot.readthedocs.io, SciencePlots, MatplotX and Themepy, and it also points to the matplotlib third-party plots page as a more comprehensive list. The README characterises them as similar packages with different foci, respectively, and does not describe what each one does.

That framing is where the difference in approach shows. tueplots keeps its own opinion narrow and explicit, size and font only, and hands you plain dictionaries to apply. A package that instead supplies a coordinated look across colour cycles, markers and axes would be solving a different problem, and the project itself treats the two as adjacent rather than equivalent. The useful question for a reader is therefore not which library wins, but which of the two decisions you want to keep: the geometry of the figure and the size of the text inside it, or the entire visual language of the plot.

Because tueplots passes dictionaries straight to matplotlib, it can also be combined with the others rather than chosen against them. Nothing in its design prevents a Seaborn style from being set on top of a tueplots size configuration.

A 0.2 line release, a generated version and an MIT licence

The release history shows a project still finding its shape. Version 0.2.3 was published on 2026-01-29, v0.2.4 on 2026-03-24 and v0.2.5 on 2026-10-12, and the last push to the repository was on 2026-10-12. The repository is not archived, and the version number is written by setuptools_scm from the commit history rather than maintained in pyproject.toml, which declares the version as dynamic.

That combination has an operational edge. A dynamic version means the tag is the release unit, so pinning tueplots to a specific version in your environment file is the only way to keep a figure reproducible across a re-install of a branch, and a 0.2 line number tells you the interface may still move between minor releases.

The project started at the University of Tübingen, which is where the name comes from, and it is published under the MIT licence with the licence file included in the package distribution. MIT permits use in commercial and academic work alike and requires that the copyright notice travels with copies, which is a reading of the licence text rather than legal advice. The repository also ships a tox.ini and a pre-commit configuration, so the project runs its own tests and lint checks, with ruff configured to a broad rule set in pyproject.toml.

Editorial conclusion

tueplots is worth adopting when a figure has to match a publication's text width and font rules across many scripts, and when you want a venue style recorded as data rather than as a global side effect. Skip it if you need it to decide colours, frame styles or markers, because the README states plainly that it has no opinions about those, and do not expect the README itself to get you started, since installation and every usage example live in the readthedocs pages. Verify first that the style you need matches a published template, and pin the version, because the package is still on the 0.2 line with v0.2.5 published on 2026-10-12 and a version string generated by setuptools_scm rather than written by hand.

Frequently asked questions

Official sources

1. License: MIT
2. pnkraemer/tueplots on GitHub
3. Project website
4. README
5. Releases