Skip to content

index.md

Latest commit

 

History

History
402 lines (286 loc) · 20.5 KB

index.md

File metadata and controls

402 lines (286 loc) · 20.5 KB

% ROOT Version 6.40 Release Notes % 2026-5

Introduction

For more information, see:

http://root.cern

The following people have contributed to this new version:

Bertrand Bellenot, CERN/EP-SFT,
Jakob Blomer, CERN/EP-SFT,
Lukas Breitwieser, CERN/EP-SFT,
Philippe Canal, FNAL,
Olivier Couet, CERN/EP-SFT,
Marta Czurylo, CERN/EP-SFT,
Florine de Geus, CERN/EP-SFT and University of Twente,
Andrei Gheata, CERN/EP-SFT,
Jonas Hahnfeld, CERN/EP-SFT and Goethe University Frankfurt,
Fernando Hueso Gonzalez, IFIC (CSIC-University of Valencia),
Stephan Hageboeck, CERN/EP-SFT,
Aaron Jomy, CERN/EP-SFT,
David Lange, CERN and Princeton,
Sergey Linev, GSI Darmstadt,
Lorenzo Moneta, CERN/EP-SFT,
Vincenzo Eduardo Padulano, CERN/EP-SFT,
Giacomo Parolini, CERN/EP-SFT,
Danilo Piparo, CERN/EP-SFT,
Jonas Rembser, CERN/EP-SFT,
Silia Taider, CERN/EP-SFT,
Devajith Valaparambil Sreeramaswamy, CERN/EP-SFT,
Vassil Vassilev, Princeton,\

Deprecations

  • The headers in RooStats/HistFactory for data classes related to the measurement definition were merged into the RooStats/HistFactory/Measurement.h header to simplify usage and development. For now, the whole set of header files is kept for backwards compatibility, but the empty headers will be removed in ROOT 7.
  • The TROOT::GetSourceDir() method is deprecated and will be removed in ROOT 6.42. It stopped making sense because the ROOT source is generally not shipped alongside ROOT in the src/ subdirectory anymore.
  • Using the rpath build option - deprecated and without effect since ROOT 6.38 - is now scheduled to give configuration errors starting from ROOT 6.42.
  • TDirectory::AddDirectoryStatus() and TDirectory::AddDirectory() have been deprecated. These functions were meant to replace TH1::AddDirectoryStatus(), but never had any effect on ROOT. The associated bit TDirectory::fgAddDirectory was deprecated as well. Although users can set and read the bit, its usage should be stopped completely to avoid any confusion. The bit and functions will be removed in ROOT 7.

Removals

  • The TH1K class was removed. TMath::KNNDensity can be used in its stead.
  • The TObject equality operator Pythonization (TObject.__eq__) that was deprecated in ROOT 6.38 and scheduled for removal in ROOT 6.40 is removed.
  • Comparing C++ nullptr objects with None in Python now raises a TypeError, as announced in the ROOT 6.38 release notes. Use truth-value checks like if not x or x is None instead.
  • The TGLIncludes.h and TGLWSIncludes.h that were deprecated in ROOT 6.38 and scheduled for removal are gone now. Please include your required headers like <GL/gl.h> or <GL/glu.h> directly.
  • The GLEW headers (GL/eglew.h, GL/glew.h, GL/glxew.h, and GL/wglew.h) that were installed when building ROOT with builtin_glew=ON are no longer installed. This is done because ROOT is moving away from GLEW for loading OpenGL extensions.
  • The TF1, TF2, and TF3 constructors for CINT compatibility were removed. This concerns the templated constructors that additionally took the name of the used functor class and member function. With ROOT 6, these names can be omitted.
  • The TMultiGraph::Add(TMultiGraph*, Option_t*) overload that adds the graphs in another TMultiGraph to a TMultiGraph is removed without deprecation. It was inconsistent from a memory ownership standpoint. A TMultiGraph always owns all the added graphs, so adding the same graph instances to two TMultiGraphs forcibly led to double-deletes. If you want to add all graphs from otherMultiGraph to multiGraph, please use a for-loop and clone the graphs instead: 
    for (TObject *gr : *otherMultiGraph) {
   multiGraph->Add(static_cast<TGraph*>(gr->Clone()));
}

Build System

Core Libraries

  • ROOT now adds a RUNPATH to compiled macros. This ensures that when compiled macros are loaded, they load the libraries that belong to the ROOT installation that compiled the macro. See TSystem::SetMakeSharedLib() for customising or disabling the RUNPATH.
  • rootcling fails if no selection rule is specified and if the creation of a C++ module is not requested.

Geometry

  • The list of logical volumes gets now rehashed automatically, giving an important performance improvement for setups having a large number of those.

Extensible color schemes for geometry visualization

ROOT now provides an extensible mechanism to assign colors and transparency to geometry volumes via the new TGeoColorScheme strategy class, used by TGeoManager::DefaultColors().

This improves the readability of geometries imported from formats such as GDML that do not store volume colors. The default behavior now uses a name-based material classification (e.g. metals, polymers, composites, gases) with a Z-binned fallback. Three predefined color sets are provided:

  • EGeoColorSet::kNatural (default): material-inspired colors
  • EGeoColorSet::kFlashy: high-contrast, presentation-friendly colors
  • EGeoColorSet::kHighContrast: darker, saturated colors suited for light backgrounds

Users can customize the behavior at runtime by providing hooks (std::function) to override the computed color, transparency, and/or the Z-based fallback mapping.

Usage examples:

gGeoManager->DefaultColors(); // default (natural) scheme

TGeoColorScheme cs(EGeoColorSet::kFlashy);
gGeoManager->DefaultColors(&cs); // select a predefined scheme

Override examples (hooks):

TGeoColorScheme cs(EGeoColorSet::kNatural);
cs.SetZFallbackHook([](Int_t Z, EGeoColorSet) -> Int_t {
   float g = std::min(1.f, Z / 100.f);
   return TColor::GetColor(g, g, g); // grayscale fallback
});
gGeoManager->DefaultColors(&cs);

A new tutorial macro demonstrates the feature and customization options: tutorials/visualization/geom/geomColors.C.

See: root-project#21047 for more details

Accelerated overlap checking with parallel execution

The geometry overlap checker (TGeoChecker::CheckOverlaps) has been significantly refactored and optimized to improve performance and scalability on large detector geometries.

Overlap checking is now structured in three explicit stages:

  1. Candidate discovery Potentially overlapping volume pairs are identified using oriented bounding-box (OBB) tests, drastically reducing the number of candidates to be examined.

  2. Surface point generation and caching Points are generated on the surfaces of the candidate shapes (including additional points on edges and generators) and cached per shape. The sampling density can be tuned via:

  • TGeoManager::SetNsegments(nseg) (default: 20)
  • TGeoManager::SetNmeshPoints(npoints) (default: 1000)
  1. Overlap and extrusion checks The actual geometric checks are performed using navigation queries. This stage is now parallelized and automatically uses ROOT’s implicit multithreading when enabled.

Only the final stage is currently parallelized, but it dominates the runtime for complex geometries and shows good strong scaling.

For large assembly-rich detector descriptions such as the ALICE O² geometry, the new candidate filtering reduces the number of overlap candidates by roughly three orders of magnitude compared to the legacy implementation. Combined with multithreaded execution, this reduces the total runtime of a full overlap check from hours to minutes on modern multi-core systems.

Usage example

ROOT::EnableImplicitMT();        // enable parallel checking
gGeoManager->SetNsegments(40);  // increase surface resolution if needed
gGeoManager0->SetNmeshPoints(2000); // increase resolution of points on surface-embedded segments if needed
gGeoManager->CheckOverlaps(1.e-6);

Performance and scaling plots for the CMS Run4 and ALICE aligned geometry are included in the corresponding pull request.

See: root-project#20963 for implementation details and benchmarks

I/O

  • The behavior or TDirectoryFile::mkdir (which is also TFile::mkdir) was changed regarding the creation of directory hierarchies: calling mkdir("a/b/c", "myTitle") will now assign myTitle to the innermost directory "c" (before this change it would assign it to "a").
  • Fixed a bug in TDirectoryFile::mkdir where passing returnExistingDirectory = true would not work properly in case of directory hierarchies. The option is now correctly propagated to mkdir's inner invocations.

File Permissions Now Respect System umask

ROOT now respects the system umask when creating files, following standard Unix conventions.

Previous behavior: Files were created with hardcoded 0644 permissions (owner read/write, group/others read-only), ignoring the system umask.

New behavior: Files are created with 0666 permissions masked by the system umask (0666 & ~umask), consistent with standard Unix file creation functions like open() and fopen().

Impact:

  • Users with default umask 022 (most common): No change - files are still created as 0644
  • Users with stricter umask values (e.g., 0077): Files will now be created with more restrictive permissions (e.g., 0600 - user-only access)
  • Users with permissive umask values (e.g., 0002): Files may be created with slightly more open permissions (e.g., 0664 - group-writable)

Note: If you require specific file permissions regardless of umask, you can set umask explicitly before running ROOT (e.g., umask 022) or use chmod after file creation.

This change affects the following classes: TFile, TMapFile, TMemFile, TDCacheFile, TFTP, and TApplicationServer.

TTree

RNTuple

  • RRawPtrWriteEntry is now part of the stable API, in the ROOT::Detail namespace. It is useful for frameworks passing data to RNTuple as const raw pointers.

Math

Migration from VecCore/Vc to std::experimental::simd for Vectorization

We have migrated the vectorized backends of TMath and TFormula from VecCore/Vc to std::experimental::simd, where available.

On Linux, std::experimental::simd is assumed to be available when ROOT is compiled with C++20 or later, which in practice corresponds to sufficiently recent GCC and Clang compilers. To keep the build system simple and robust, ROOT does not explicitly check compiler versions: users opting into C++20 are expected to use modern toolchains.

Impact on Linux users

ROOT builds with C++17 on Linux no longer provide vectorized TMath and TFormula. This is an intentional and accepted trade-off of the migration. These vectorized features were rarely used, while maintaining them significantly complicated the codebase and build configuration.

Users who rely on vectorized TMath or the vectorized TFormula backend are encouraged to build ROOT with C++20. Doing so restores vectorization through std::experimental::simd, providing a more robust and future-proof implementation.

Windows and Apple silicon users are unaffected

VecCore/Vc did not work on Windows previously, and Vc never provided production-ready support for ARM/Neon, so Apple silicon did not benefit from vectorization before this change.

Build system changes

As part of this migration, the following build options are deprecated. From ROOT 6.42, setting them will result in configuration errors.

  • vc
  • veccore
  • builtin_vc
  • builtin_veccore

RooFit

  • A new RooAbsPdf has been added: RooStudentT, which describes the location-scale student's t-distribution.
  • The RooNumber::setRangeEpsRel() and RooNumber::setRangeEpsAbs() have been introduced 2 years ago in 48637270a9113aa to customize range check behavior to be like before ROOT 6.28, but this has not been proven necessary. Instead, looking up the static variables with the epsilon values incurred significant overhead in RooAbsRealLValue::inRange(), which is visible in many-parameter fits. Therefore, these functions are removed.

New implementation of RooHistError::getPoissonInterval

RooHistError::getPoissonInterval was reimplemented to use an exact chi-square–based construction (Garwood interval) instead of asymptotic approximations and lookup tables.

Previously:

  • For n > 100, a hard-coded asymptotic formula was used, which was not explained in the documentation.
  • That approximation corresponds to inverting the Poisson score test and was only correct for nSigma = 1.
  • The behavior for n > 100 was not statistically consistent because of the hard transition between exact formula and approximation, resulting in a discrete and unexpected jump in approximation bias.
  • For small n, numerical root finding and a lookup table were used.

Now:

  • The interval is computed directly using chi-square quantiles for all n.
  • The construction provides exact frequentist coverage.
  • The implementation works consistently for arbitrary nSigma.
  • The hard-coded n > 100 threshold, lookup table, and numerical root finding were removed.
  • For n = 0, a one-sided upper limit is used (with lower bound fixed at 0), consistent with the physical constraint mu ≥ 0.

Results may differ from previous ROOT versions for n > 100 or nSigma != 1. The new implementation is statistically consistent and recommended.

RDataFrame

  • The message shown in ROOT 6.38 to inform users about change of default compression setting used by Snapshot (was 101 before 6.38, became 505 in 6.38) is now removed.
  • Signatures of the HistoND and HistoNSparseD operations have been changed. Previously, the list of input column names was allowed to contain an extra column for events weights. This was done to align the logic with the THnBase::Fill method. But this signature was inconsistent with all other Histo* operations, which have a separate function argument that represents the column to get the weights from. Thus, HistoND and HistoNSparseD both now have a separate function argument for the weights. The previous signature is still supported, but deprecated: a warning will be raised if the user passes the column name of the weights as an extra element of the list of input column names. In a future version of ROOT this functionality will be removed. From now on, creating a (sparse) N-dim histogram with weights should be done by calling HistoN[Sparse]D(histoModel, inputColumns, weightColumn).

Python Interface

  • ROOT dropped support for Python 3.9, meaning ROOT now requires at least Python 3.10.

Change in memory ownership heuristics

In previous ROOT versions, if a C++ member function took a non-const raw pointer, e.g.

MyClass::add(T* obj)

then calling this method from Python on an instance

my_instance.add(obj)

would assume that ownership of obj is transferred to my_instance.

In practice, many such functions do not actually take ownership. As a result, this heuristic caused several memory leaks.

Starting with ROOT 6.40, the ROOT Python interfaces no longer assumes ownership transfer for non-const raw pointer arguments.

What does this mean for you?

Because Python no longer automatically relinquishes ownership, some code that previously relied on the old heuristic may now expose:

  • Dangling references on the C++ side
  • Double deletes

These issues must now be fixed by managing object lifetimes explicitly.

Dangling references

A dangling reference occurs when C++ holds a pointer or reference to an object that has already been deleted on the Python side.

Example

obj = ROOT.MyClass()
my_instance.foo(obj)
del obj  # C++ may still hold a pointer: dangling reference

When the Python object is deleted, the memory associated with the C++ object is also freed. But the C++ side may want to delete the object as well, for instance if the destructor of the class of my_instance also calls delete obj.

Possible remedies

  1. Keep the Python object alive

    Assign the object to a Python variable that lives at least as long as the C++ reference.

    Example: Python lifeline

    obj = ROOT.MyClass()
my_instance.foo(obj)
# Setting `obj` as an attribute of `my_instance` makes sure that it's not
# garbage collected before `my_instance` is deleted:
my_instance._owned_obj = obj
del obj  # Reference counter for `obj` doesn't hit zero here

    Setting the lifeline reference could also be done in a user-side Pythonization of MyClass::foo.

  2. Transfer ownership explicitly to C++

    • Drop the ownership on the Python side: 
      ROOT.SetOwnership(obj, False)
    • Ensure that the C++ side will take ownership instead, e.g. by explicitly calling delete in the class destructor or using smart pointers like std::unique_ptr.

  3. Rely on Pythonizations that imply ownership transfer

    If the object is stored in a non-owning collection such as a default-constructed TCollection (e.g. TList), you can make the collection owning before adding any elements:

    coll.SetOwner(True)

    This will imply ownership transfer to the C++ side when adding elements with TCollection::Add().

Note on TCollection Pythonization

TCollection-derived classes are Pythonized such that when an object is added to an owning collection via TCollection::Add(), Python ownership is automatically dropped.

If you identify other cases where such a Pythonization would be beneficial, please report them via a GitHub issue. Users can also implement custom Pythonizations outside ROOT if needed.

Double deletes

A double delete indicates that C++ already owns the object, but Python still attempts to delete it.

In this case, you do not need to ensure C++ ownership, as it already exists. Instead, ensure that Python does not delete the object.

Possible remedies

  1. Drop Python ownership explicitly:

    ROOT.SetOwnership(obj, False)

  2. Pythonize the relevant member function to automatically drop ownership on the Python side (similar to the TCollection Pythonization described above).

Temporary compatibility option

You can temporarily restore the old heuristic by calling:

ROOT.SetHeuristicMemoryPolicy(True)

after importing ROOT.

This option is intended for debugging only and will be removed in ROOT 6.44.

UHI

Backwards incompatible changes

  • TH1.values() now returns a read-only NumPy array by default. Previously it returned a writable array that allowed modifying histogram contents implicitly.
  • To modify the histogram buffer, you must now explicitly request it:
h.values(writable=True)[0] = 42
  • When the histogram storage allows it, TH1.values() returns a zero-copy view. For histogram types that cannot expose their memory layout (TH*C and TProfile*), .values() returns a copy. In these cases passing writable=True is not supported and raises a TypeError.

New features

  • TH1.values(flow=True) now exposes underflow/ overflow bins when requested.
  • ROOT histograms now support UHI serialization via intermediate representations with the methods _to_uhi_ and _from_uhi_
  • Example usage:
h = ROOT.TH1D("h", "h", 10, -5, 5)
h[...] = np.arange(10)

json_str = json.dumps(h, default=uhi.io.json.default)

h_from_uhi = ROOT.TH1D(json.loads(json_str, , object_hook=uhi.io.json.object_hook))

ROOT executable

  • Removed stray linebreak when running root -q with input files or commands passed with -e. This ensures that there is no superfluous output when running root. Note that ROOT 6.38 already removed a spurious newline when starting root without input files or commands.
  • The ROOT header printed by default when starting the interpreter is now suppressed when scripts or commands are passed on the command line. This makes sure the output doesn't contain unexpected and ROOT version dependent output, which helps in case the output is piped to other commands or compared to reference files.

Command-line utilities

  • rootls has a new flag: -c / --allCycles, which displays all cycles of each object in the inspected file/directory even in normal mode (cycles are already displayed by default with -l or -t).
  • rootcp and rootrm have a new native implementation, which should make them significantly faster to startup and usable even without Python.

JavaScript ROOT

Experimental features

Versions of built-in packages

The version of the following packages has been updated:

  • cppzeromq: 4.10.0
  • fftw3: 3.3.10
  • gsl: 2.8
  • gtest: 1.17.0
  • libzeromq: 4.3.5
  • xrootd: 5.9.1

Items addressed for this release