Open-source project
root-project/root avatar
root-project/root

ROOT's readme has no install command, its license field is empty, and its wheel version is hand-bumped

The official repository for ROOT: analyzing, storing and visualizing big data, scientifically

3,345 stars1,609 forksC++NOASSERTION

At a glance

What is it?
The C++ and Python data analysis package used at the Large Hadron Collider, whose source tree is a directory per subsystem and whose installation instructions live entirely on a website. The packaging metadata is where the interesting decisions are: the version is regex-scraped out of a C header and rendered with a manually edited alpha suffix, the wheel carries a full ROOT installation layout including a vendored cppyy, and requirements.txt is a list of unpinned floors spanning six machine learning frameworks.
Who is it for?
ROOT suits a scientific analysis that needs columnar storage, histogramming, fitting and a parallel dataframe framework in one package, and for existing CERN users the install path is a website rather than something to discover in the source. Before you build from source, check four things.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • root-project/root3,345 ★ · +51
Star history
Repository2026-09-112026-11-15
root-project/root3.3k3.3k

51 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The readme delegates every instruction to a website

There is no build command and no install command anywhere in this readme. The installation section consists of two links. The first points at `https://root.cern/install` for installation instructions, and the second points at `https://root.cern/install/build_from_source` for building from the source files in this repository. A third link goes to a getting-started page.

So the repository that contains the entire implementation documents none of the steps needed to produce a working binary from it. That is a deliberate arrangement for a project whose users are spread across many platforms, and the linked pages are the real documentation, but it means the source tree alone is not a guide to itself.

The help section is built the same way, pointing at a forum, a documentation reference guide and a tutorials page. Two other destinations are worth separating out. A live demo is labelled for CERN users and points at a SWAN notebook served from cern.ch, so it is not a public instance you can try. And the issue tracker has a second entry for the previous now read-only Jira tracker, which still carries a filter for all open issues on a tracker nobody can write to any more.

The license field is empty and two license files sit at the root

Three artefacts describe the license and they do not line up.

The recorded license for this repository is `NOASSERTION`, which is an absence rather than a choice. The tree contains both an `LGPL2_1.txt` file and a separate `LICENSE` file at the top level, and the readme carries a badge pointing at the GNU LGPL page along with a badge for a research software practices project entry.

The Python packaging metadata then picks one of the two by name. `pyproject.toml` sets `license = {file = "LICENSE"}`, so the wheel's declared license text is the generic `LICENSE` file rather than the explicitly versioned `LGPL2_1.txt`.

That is worth flagging without resolving. Neither file is identified as the authoritative one, nothing says whether their contents are identical, and the packaging metadata's choice of the shorter filename is a fact about the metadata rather than a statement about the terms. Anyone building a compliance list from the recorded field gets nothing, and anyone reading the wheel gets whichever text `LICENSE` contains.

The rest of the packaging metadata is ordinary: `requires-python = ">=3.10"`, a single runtime dependency on `numpy`, and a maintainer entry naming Vincenzo Eduardo Padulano with a cern.ch address.

The wheel version is regex-scraped from a C header and ends in a hand-edited suffix

There is no version literal in `pyproject.toml`. The project declares `dynamic = ["version"]` and a metadata provider that reads a file and applies a regular expression, with the input given as `core/foundation/inc/ROOT/RVersion.hxx` and the result template `{major}.{minor}.{patch}a1`.

The pattern matches three preprocessor defines in order, `ROOT_VERSION_MAJOR`, `ROOT_VERSION_MINOR` and `ROOT_VERSION_PATCH`, so the C++ version macros are the single source of truth for the Python distribution too. The comments in the file spell out the whole scheme. A ROOT version of 6.42.02 becomes the wheel version 6.42.2a1, dropping the leading zero from the patch component, and the `a1` marks a PEP 440 pre-release.

Then comes the part that is genuinely unusual. The comment instructs that `a1` be bumped manually, from `a1` to `a2`, only in order to re-publish a wheel for a ROOT version already on PyPI, because PyPI refuses a filename it has already seen, and that this should happen only when the first upload failed or broke. It also instructs resetting the suffix to `a1` for the next ROOT release.

So the version of the Python package is derived automatically from C source but carries one hand-edited character whose only purpose is to work around an upload failure. Every published wheel for a given ROOT version therefore has a version string that was typed by hand at least once.

The wheel carries a whole ROOT installation tree, vendored cppyy included

The install configuration in `pyproject.toml` does not describe a thin Python layer. Three CMake install directories are set to `ROOT/bin`, `ROOT/cmake` and `ROOT/fonts`, so the build installs into a `ROOT` prefix with the same directory names ROOT itself uses.

Two wheel packages are declared. The first is `bindings/pyroot/pythonizations/python/ROOT`, which is PyROOT itself. The second is `bindings/pyroot/cppyy/cppyy/python/cppyy`, which is cppyy, the dynamic binding technology the readme credits for C++ and Python interoperability. So cppyy is not merely depended on from elsewhere, it is built from this repository's own copy of its source and placed inside the distribution.

Two smaller settings are worth noting. `install.strip = false` means installed binaries are not stripped, which keeps debug information and symbols at the cost of size. And the CMake generator is pinned explicitly with `cmake.args = ["-GNinja"]`, so a build needs Ninja rather than whichever generator the platform would otherwise choose.

The build backend is `scikit_build_core.build` with `scikit-build-core>=1.0` required, and a comment notes that the dynamic metadata syntax used in the file is itself a scikit-build-core 1.0 feature.

Three recent tags come from three different minor branches

The three most recent releases do not form a sequence. They are v6-40-04 dated 2026-08-27, v6-36-14 dated 2026-09-01, and v6-32-24 dated 2026-06-18.

The tag format carries the minor version in the middle component and the patch level in the last one, so these are three separate maintenance lines at 40, 36 and 32. Their patch levels are also different, at 04, 14 and 24, which means the lines are not all at the same point in their own history.

The ordering is the trap. The highest minor number, 40, is not the newest release by date, because the 36 line shipped five days later than the 40 line. The oldest by minor number, 32, is also the oldest by date. So sorting by tag text and sorting by date disagree, and a script that assumes the largest tag is the newest release will pick the wrong one.

The last push is dated 2026-10-04, which is more recent than all three tags, so work on the default branch has moved past every published release. The default branch is `master`.

requirements.txt is a list of floors across six machine learning frameworks

The header calls these the ROOT requirements for third-party Python packages, and the file is organised by which part of ROOT needs them. PyROOT interoperability with numpy arrays needs `numpy` and `pandas`. TMVA's SOFIE path needs `onnx`, `onnxscript` and `packaging`. TMVA's PyMVA interfaces need `scikit-learn`, `tensorflow`, `torch` and `xgboost`. The RDataLoader needs `jax`, the `ROOT.Numba.Declare` decorator needs `numba` and `cffi`, the notebook kernel needs `IPython`, `jupyter`, `metakernel>=0.20.0` and `notebook>=4.4.1`, the distributed dataframe needs `pyspark` for a Spark backend and `dask>=2022.08.1` plus `distributed>=2022.08.1` for a Dask backend, and the unified histogram interface needs `uhi`, `matplotlib` and `mplhep`.

Almost none of those are version constrained. Four carry a floor and the rest are bare names, so the file describes what must be importable rather than reproducing an environment. Nothing in it pins torch, tensorflow, xgboost, jax, numba or scikit-learn to a compatible set, and those six frameworks have to agree with each other and with your numpy.

One entry carries an environment marker rather than a floor: `tensorflow ; python_version < "3.14"`, so TensorFlow is a requirement only below Python 3.14 while the package metadata allows `>=3.10`. A test section adds `nbconvert>=7.17.0`, `pytest`, `setuptools` and `jsonschema`, the last noted as being for RooFit HS3 validation.

The requested citation has not moved since 1996

The readme asks that ROOT be cited in a specific form, and gives the reference as an indented block:

code
Rene Brun and Fons Rademakers, ROOT - An Object Oriented Data Analysis Framework,
Proceedings AIHENP'96 Workshop, Lausanne, Sep. 1996,
Nucl. Inst. & Meth. in Phys. Res. A 389 (1997) 81-86.

The workshop is dated September 1996 and the journal volume appeared in 1997. The current line is 6.40, so the requested citation is roughly three decades older than the software it describes, and it has been left as the original paper rather than updated to a technical documentation reference.

A BibTeX version of the same reference is pointed at, at the path `README/root_citation.bib`. That path also explains an oddity in the tree layout: `README` is a directory as well as there being a `README.md`, so the repository carries both a readme file and a directory named for it.

The reference guide, tutorials and gallery are all hosted off-repository, and the gallery is where the screenshots live rather than an `images/` directory in the source.

One directory per subsystem, and the interoperability claim rests on two projects

The top level is a package per subsystem, which is how a project of this size stays navigable: `core/`, `io/`, `hist/`, `math/`, `tree/`, `geom/`, `graf2d/`, `graf3d/`, `gui/`, `net/`, `sql/`, `js/`, `interpreter/`, `montecarlo/`, `tmva/`, `roofit/`, `rootx/`, plus `bindings/`, `builtins/`, `cmake/`, `config/`, `documentation/`, `tutorials/`, `macros/`, `man/`, `fonts/`, `icons/`, `etc/` and `main/`.

Three of those names carry more weight than the rest. `interpreter/` is Cling. `bindings/` is PyROOT and the vendored cppyy. `tmva/` and `roofit/` are the two statistics packages, and requirements.txt confirms the split by asking for SOFIE dependencies and four ML frameworks for one and `jsonschema` for RooFit validation.

The readme's central technical claim is that ROOT is performance critical C++ which enables rapid prototyping through a C++ compliant interpreter called Cling, and that Cling's type introspection is the building block of automatic interoperability with Python through cppyy, giving on-demand C++ and Python interchange in one execution environment. The packaging configuration is the concrete confirmation: cppyy is built from `bindings/` and shipped in the wheel, so the claim rests on two projects this repository builds itself.

Two test trees sit at the top, `test/` and `roottest/`, alongside `codecov.yml`, `ruff.toml`, `.clang-format`, `.clang-tidy` and an `AGENTS.md`.

Editorial conclusion

ROOT suits a scientific analysis that needs columnar storage, histogramming, fitting and a parallel dataframe framework in one package, and for existing CERN users the install path is a website rather than something to discover in the source. Before you build from source, check four things. Which branch you want, because the three most recent tags come from three different minor lines and the highest number is not the newest by date. What the wheel actually installs, since it carries a full ROOT prefix including a vendored cppyy rather than a thin Python layer. What your Python environment needs, since requirements.txt is unpinned floors across numpy, pandas, torch, tensorflow, xgboost, jax, numba and scikit-learn, with TensorFlow limited to Python below 3.14. And which license text governs, because the recorded field is empty while both an LGPL2_1.txt and a LICENSE file sit at the root. Budget the build accordingly; this is not a package you install in seconds from source.

Frequently asked questions

What is root software?

ROOT is a unified C++ package for storing, processing and analysing scientific data, from acquisition through to publication-ready plots. The source tree is organised one directory per subsystem, including `interpreter/` for the Cling C++ interpreter, `bindings/` for PyROOT and cppyy, `hist/`, `tree/`, `io/` and the `tmva/` and `roofit/` statistics packages, with the homepage at root.cern.

How do I download and install ROOT?

The readme contains no install command and sends you to two pages instead: `https://root.cern/install` for installation and `https://root.cern/install/build_from_source` for building from these sources. A Python route exists through the scikit-build-core wheel, which requires Python 3.10 or newer, scikit-build-core 1.0 or newer and Ninja, since `cmake.args` pins the generator to `-GNinja`.

Why does ROOT's pyproject.toml contain no version number?

The version is declared dynamic and derived by a regex provider that reads `core/foundation/inc/ROOT/RVersion.hxx`, matching the `ROOT_VERSION_MAJOR`, `ROOT_VERSION_MINOR` and `ROOT_VERSION_PATCH` defines and rendering them as `{major}.{minor}.{patch}a1`. ROOT 6.42.02 becomes wheel version 6.42.2a1, and the `a1` suffix is bumped by hand only to re-publish after a failed upload, since PyPI refuses a filename it has already seen.

What are the most recent ROOT release tags?

Three lines are represented: v6-40-04 dated 2026-08-27, v6-36-14 dated 2026-09-01 and v6-32-24 dated 2026-06-18. They come from three different minor branches at different patch levels, and tag order does not match date order because the 36 line shipped after the 40 line. The last push is dated 2026-10-04, later than all three tags.

Which Python packages does ROOT expect?

`requirements.txt` is a list of floors rather than a lock: numpy, pandas, onnx, onnxscript, packaging, scikit-learn, torch, xgboost, jax, numba, cffi, IPython, jupyter, pyspark, uhi, matplotlib, mplhep, pytest, setuptools and jsonschema appear mostly unpinned, with `metakernel>=0.20.0`, `notebook>=4.4.1`, `nbconvert>=7.17.0`, `dask>=2022.08.1` and `distributed>=2022.08.1` carrying floors. Only `tensorflow` is conditional, marked `python_version < "3.14"`.

Which licence applies to ROOT?

The recorded license field is `NOASSERTION`, and the tree holds both an `LGPL2_1.txt` file and a separate `LICENSE` file. The readme badges link to the GNU LGPL page and to a research software practices project entry, while `pyproject.toml` sets `license = {file = "LICENSE"}`, pointing the wheel at the shorter filename rather than the explicitly versioned one.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. root-project/root on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/root-project-root.svg)](https://hysenlabs.com/projects/root-project-root)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/root-project-root.svg)](https://hysenlabs.com/projects/root-project-root)

Was this useful?