Changes between Version 9.7.1 and 9.8.0

This is the list of changes made between the release of deal.II version 9.7.1 and that of 9.8.0. All entries are signed with the names of the author.

Incompatibilities

Following are a few modifications to the library that unfortunately are incompatible with previous versions of the library, but which we deem necessary for the future maintainability of the library. Unfortunately, some of these changes will require modifications to application programs. We apologize for the inconvenience this causes.

1. Changed: GridIn::read_partitioned_msh(), the overload of GridIn::read_msh() which uses the GMSH API, and the overload of GridOut::write_msh() which uses the GMSH API now require that gmsh::initialize() is run prior to calling those functions. This change was made to ensure consistent initialization and finalization of gmsh as well as its dependencies (such as MPI).
   (David Wells, 2026/06/19)

2. Changed: TriangulationDescription::CellData::boundary_ids is now a std_cxx26::inplace_vector instead of a std::vector. This change makes this class, when compiling with C++20 or newer, trivially copyable.
   (David Wells, 2026/06/15)

3. Changed: The mapping_q.h header no longer includes quadrature_lib.h.
   (David Wells, 2026/06/08)

4. Changed: CellData::vertices is now a std_cxx26::inplace_vector instead of a std::vector. This change was made to improve performance and decrease the total number of memory allocations, as the maximum number of vertices per cell is known at compile time. Some code, like assigning vertices to a std::vector, will no longer compile, but most constructions (like the assign() member function, assigning to a std::initializer_list, etc.) will continue to work. In particular, pre-2021 code (before we switched to std::vector from a C array) will not require updates.
   (David Wells, 2026/05/26)

5. Changed: The maximum number of levels in a Triangulation is now capped at 31. This is the same limit used by p4est, and was previously implicitly enforced through the CellId class.
   (David Wells, 2026/05/26)

6. Changed: Increased the maximum number of children after refinement (ReferenceCells::max_n_children()) from 8 to 10 to accommodate the isotropic refinement of pyramids.
   (Andreas Steger, 2026/05/01)

7. Changed: FESubfaceValues::reinit() now checks whether the face under consideration actually belongs to a cell whose neighbor is more refined. This was previously only enforced on cell iterators based on a Triangulation object, not those associated to a DoFHandler object. The new behavior is now uniform in both cases.
   (Martin Kronbichler, 2026/04/17)

8. Changed: There are some functions in deal.II that compute the curl of vector fields. The curl is only defined for vector fields in \({\mathbb R}^3\), or for two-dimensional vector fields on two-dimensional manifolds (perhaps embedded in \({\mathbb R}^3\)). Historically, it was possible to also call these functions for dim==1, which made no sense but was syntactically allowed. However, this is now forbidden and will lead to syntax errors.
   (Wolfgang Bangerth, 2026/04/13)

9. Changed: In three space dimensions, the curl of a vector field is unambiguously a three-dimensional vector. In two space dimensions, it is typically defined as a scalar, interpreted as the magnitude of a vector aligned with the \(z\)-axis that results from taking the curl of a vector field that lives in the \(x\)- \(y\) plane. For historical reasons, deal.II used to represent this scalar as a Tensor<1,1> (i.e., a tensor of rank one – a tensor with one index – for which the only possible value of the index is zero). This is, of course, entirely equivalent to it being a scalar, but it is semantically wrong: The data type should have been a scalar, not a vector with one element. This is now fixed: The data type defined by FEValuesViews::Vector::curl_type used for curls is now simply a scalar value for dim==2. For dim==3, it is unchanged from what it was before.
   (Wolfgang Bangerth, 2026/03/31)

10. Removed: The function TrilinosWrappers::Vector::reinit with the option to copy values from a differently partitioned vector has been removed due to inconsistent behavior with the other reinit functions. If you require this functionality, use the copy-constructor specifying the parallel partitioning, or the equivalent assignment operator.
    (Rene Gassmoeller, 2026/03/30)

11. Changed: The ReferenceCell class now has a template argument dim like many of the other classes that have to do with meshes.
    (Wolfgang Bangerth, 2026/03/27)

12. Deprecated: Overloads for TrilinosWrappers sparse matrix classes allowing a default number of entries per row have been deprecated. The respective overloads for TpetraWrappers classes have been removed.
    (Daniel Arndt, 2026/03/25)

13. Changed: If Trilinos was built with Tpetra support but without Epetra support, the TrilinosWrappers classes are aliases for the respective TpetraWrappers classes with NumberType=double and MemorySpace=Host.
    (Daniel Arndt, 2026/03/21)

14. Deprecated: All classes in the EpetraWrappers namespace have been deprecated.
    (Daniel Arndt, 2026/01/27)

15. Changed: Most of the parallel vector classes (in particular those wrapping the functionality in the PETSc, Trilinos Epetra, and Trilinos Tpetra packages) observe semantics whereby vectors that have ghost elements need to be treated as unchangeable. This is because whenever you change a locally-owned element of such a vector, this change is not propagated to those processes that store this element among their ghost elements; these processes' view of the vector is now no longer in sync with the view on that process that owns the element, and that is a common source of very hard to find bugs.
    As a consequence, many functions inside these vector classes that modify the vector check that the vector has no ghost elements. But some did not, such as TrilinosWrappers::MPI::Vector::operator+=(), TrilinosWrappers::MPI::Vector::operator-=(), TrilinosWrappers::MPI::Vector::operator*=(), TrilinosWrappers::MPI::Vector::operator/=(), and the corresponding functions in the Epetra and Tpetra wrappers, along with an assortment of other non-const functions in these classes that include assigning a scalar to all elements of a vector, and writing into (or adding, or multiplying/dividing) a single vector entry.
    This oversight has now been fixed. We know that some of these functions are used in parallel contexts in application codes that will now no longer work and will need to be fixed. For this, you will want to perform the modifying operations on full-distributed vectors (i.e., vectors of the same type that store no ghost elements) and then copy the result into the ghosted vector.
    (Wolfgang Bangerth, 2025/12/15)

16. Changed: The class Rol::VectorAdaptor has been renamed TrilinosWrappers::ROLAdaptor. Its corresponding header file has been moved from deal.II/optimization/rol/vector_adaptor.h to deal.II/trilinos/rol_adaptor.h.
    (Marc Fehling, 2025/11/12)

17. Changed: A template parameter for dim has been added to MGTwoLevelTransferBase.
    (Ryan Moulday, 2025/11/10)

18. Changed: The function Timer::stop() no longer returns the CPU time after stopping the timer. This functionality is covered by the existing function Timer::cpu_time(), which should be called instead.
    (Rene Gassmoeller, 2025/10/04)

19. Changed: The TimerOutput class no longer supports producing output while actively timing a subsection. This feature was removed to simplify internal data storage and to avoid inconsistencies in parallel computations.
    (Rene Gassmoeller, 2025/10/02)

20. Changed: Renamed FETools::cell_to_face_patch() to FETools::cell_to_face_patch_numbering(). FETools::cell_to_face_patch() was marked deprecated.
    (Michał Wichrowski, 2025/09/15)

21. Removed: The classes MGTransferMF, MGTransferGlobalCoarsening, MGTransferBlockMF, and MGTransferBlockGlobalCoarsening have been deprecated. Their functionalities are now part of MGTransferMatrixFree and MGTransferBlockMatrixFree.
    (Peter Munch, 2025/09/12)

22. Removed: Deprecations from the 9.6 release have been removed. See https://github.com/dealii/dealii/pull/18709 for details.
    (Daniel Arndt, 2025/07/17)

General

1. New: Portable::MGTwoLevelTransfer now supports FESystem.
   (Ivan Prusak, 2026/07/09)

2. New: step-104 is a new tutorial on solving the Stokes equations matrix-free on GPUs.
   (Quang Hoang, Timo Heister, 2026/07/01)

3. New: Added Portable::MGTwoLevelTransfer class supporting geometric multigrid transfer operators on GPUs. At the moment, only globally refined meshes and FE_Q are supported.
   (Ivan Prusak, Martin Kronbichler, 2026/06/23)

4. Deprecated: deal.II has had a long list of classes in namespace MeshWorker that were developed decades ago when we had a different programming style and that were intended to hide some of the complexity of assembling linear systems as well as evaluating and postprocessing solutions. Many parts of the MeshWorker framework worked well for a specific purpose, but turned out to be very difficult to adapt to other tasks – say, converting the assembly of a term to a term that nonlinearly depends on coefficients that themselves depend on the current solution. The framework also dates back to a time when deal.II had substantially poorer test coverage and documentation, and as a consequence corner cases were often found to not actually work as expected, and/or not well documented. As a consequence, we have over time developed other, better, better documented, and better tested tools for all of these tasks. The only remaining hold-out that used the old MeshWorker framework was step-39, and with the conversion of step-39 from the old MeshWorker::loop() function to the newer MeshWorker::mesh_loop() function, many of the old classes have become unused in the tutorial and have been deprecated (and will consequently be removed in the second-next release). Specifically, these classes and functions are:

   • MeshWorker::DoFInfo
   • MeshWorker::IntegrationInfo
   • MeshWorker::IntegrationInfoBox
   • MeshWorker::loop().
     This has also led to many other classes that were previously only used within the classes and functions mentioned above, and that are now also deprecated:
   • MeshWorker::Assembler::Functional
   • MeshWorker::Assembler::ResidualLocalBlocksToGlobalBlocks
   • MeshWorker::Assembler::MatrixLocalBlocksToGlobalBlocks
   • MeshWorker::Assembler::MGMatrixLocalBlocksToGlobalBlocks
   • MeshWorker::Assembler::ResidualSimple
   • MeshWorker::Assembler::MatrixSimple
   • MeshWorker::Assembler::MGMatrixSimple
   • MeshWorker::Assembler::SystemSimple
   • MeshWorker::Assembler::CellsAndFaces
   • MeshWorker::Assembler::GnuplotPatch
   • MeshWorker::VectorSelector
   • MeshWorker::VectorDataBase
   • MeshWorker::VectorData
   • MeshWorker::MGVectorData
   • MeshWorker::LocalResults
   • MeshWorker::LoopControl
   • MeshWorker::cell_action()
     All of these classes will disappear in a future release.
     (Wolfgang Bangerth, 2026/06/16)

5. New: The new time-steppers have been added for SUNDIALS::ARKode: SUNDIALS::ERKStepper wrapping the ERKStep (Explicit Runge-Kutta) module of ARKODE, SUNDIALS::LSKRStepperSSP and SUNDIALS::LSKRStepperSTS providing access to the SSP (Strong-Stability-Preserving) and STS (Super Time-Stepping) time integration methods within the LSRKStep (Low-Storage Runge-Kutta) module of ARKODE, respectively.
   (Vladimir Ivannikov, 2026/04/21)

6. New: Portable::MatrixFree now supports systems with more than DoFHandler.
   (Timo Heister, 2026/06/01)

7. New: deal.II has a C++17-compliant version of most of C++26's new inplace_vector class template.
   (David Wells, 2026/05/16)

8. Reworked execute_refinement_isotropic to handle cells producing children of different reference cells and added support for isotropic pyramid refinement.
   (Andreas Steger, 2026/05/01)

9. New/Changed: The SUNDIALS ARKODE wrapper has been substantially extended and refactored. The time-stepper functionality previously embedded in SUNDIALS::ARKode has been extracted into the new SUNDIALS::ARKodeStepper interface. A concrete implementation is currently provided for the SUNDIALS implicit/explicit ARKStep integration module (SUNDIALS::ARKStepper), but the design is open to further ARKODE time-steppers. A stepper object is constructed independently and passed to the SUNDIALS::ARKode driver, which handles the time-marching loop. Method-specific parameters are configured through per-class AdditionalData structures.
   The previous interface of SUNDIALS::ARKode that exposed the right-hand side functions directly on the ARKode object is still available but is now deprecated and will be removed in a future version. Users are encouraged to migrate to the new stepper-based interface.
   (Vladimir Ivannikov, 2026/04/21)

10. New: The step-98 tutorial program illustrates application of the FE_Q, FE_Nedelec, FE_RaviartThomas, and FE_DGQ finite elements to two-dimensional problems in magnetostatics.
    (Siarhei Uzunbajakau, 2026/04/10)

11. Reworked execute_refinement_isotropic to support cells with multiple face types. Additionally, support for the isotropic refinement of wedges was added.
    (Andreas Steger, 2026/01/20)

12. DataOut has been generalized to correctly handle parallel vectors with arbitrary ownership layouts, improving robustness and correctness for distributed output.
    (Mathias Anselmann, 2026/01/11)

13. New: Matrix-free infrastructure for evaluation/integration of Nedelec elements has been developed.
    (Natalia Nebulishvili, Martin Kronbichler, 2025/12/30)

14. New: PETSc linear algebra now supports multi-threaded assembly and reading from ghost vectors.
    (Timo Heister, 2025/11/23)

15. Improved: The hp adaptivity features for DG of MatrixFree have been extended. For face-centric loops, neighboring cells can have quadrature rules with different number of quadrature points. On each face, the quadrature rule with the highest number of quadrature points is used. For element-centric loops, p-adaptivity is enabled. It is experimental, since categorization and hp-enabled DoFHandler are not supported at the same time by MatrixFree, limiting, in most cases, the usablity to VectorizedArray<double, 1>.
    (Peter Munch, 2025/10/21)

Specific improvements

1. New: We introduced a new function parallel::shared::Triangulation::communicate_coarsening_and_refinement_flags() that communicates coarsen and refine flags among all MPI processes prior to mesh refinement. Previously, this functionality was an inherent part of parallel::shared::Triangulation::execute_coarsening_and_refinement() and has now been moved into a separate helper function. Now, both functions parallel::shared::Triangulation::prepare_coarsening_and_refinement() and parallel::shared::Triangulation::execute_coarsening_and_refinement() begin with communicating flags through the new helper function.
   (Matthias Maier, 2026/08/01)

2. Fixed: TriangulationDescription::Description now correctly sets material_ids of cells on finer levels.
   (David Wells, 2026/07/13)

3. Fixed: SolverGMRES and SolverFGMRES with orthogonalization strategy LinearAlgebra::OrthogonalizationStrategy::delayed_classical_gram_schmidt (the default case) could run into a division by zero in the rare case when residual vectors became exactly zero. This invalid operation is now avoided, and the lucky breakdown is handled gracefully.
   (Martin Kronbichler, 2026/06/30)

4. Added: get_divergence() and submit_divergence() have been added to Portable::FEEvaluation.
   (Ryan Moulday, 2026/06/29)

5. Fixed: DoFTools::extract_dofs_with_support_contained_within() previously returned DoFs as contained within when running in parallel that are actually not contained within.
   (Torsten Schmid, 2026/06/23)

6. New: parallel::CellWeights can now work with pre-computed weights. This requires that the weights are determined only by information about finite elements.
   (Marc Fehling, 2026/06/19)

7. Improved: The matrix-free framework now stores Dirichlet-constrained indices as index numbers::invalid_unsigned_int, rather than as a separate constraint that needs to be resolved from a list. This leads to slightly better machine code on most machines, thus speeding up matrix-free codes.
   (Martin Kronbichler, 2026/06/18)

8. Improved: The functions VectorizedArray::gather() and VectorizedArray::scatter() are now able to filter out indices with value numbers::invalid_unsigned_int, indicating a mask for the vector access. This is useful for indirect index access.
   (Martin Kronbichler, 2026/06/18)

9. Improved: Functions in Utilities::MPI no longer compress and decompress their input arguments. This makes, e.g., Utilities::MPI::gather() about twice as fast.
   (David Wells, 2026/06/12)

10. New: diagonal_operator() function returns a LinearOperator representing the action of a diagonal matrix with entries given by a vector.
    (Quang Hoang, 2026/06/12)

11. New: Added a DoFRenumbering::component_wise() overload that accepts FEValuesExtractors, where the ordering is defined by the order of the passed extractors. Convenience alias AnyExtractor is introduced for a variant type holding any of the supported FEValuesExtractors (scalar, vector, tensor, symmetric tensor).
    (Gordan Segon, 2026/06/11)

12. Changed: The step-39 tutorial program has been rewritten to use MeshWorker::mesh_loop() instead of the removed MeshWorker::loop(), MeshWorker::DoFInfo, MeshWorker::IntegrationInfo, and MeshWorker::IntegrationInfoBox interfaces.
    (Wolfgang Bangerth, 2026/06/11)

13. Deprecated: The class MeshWorker::Assembler::Functional has been marked as deprecated and will be removed in a future release.
    (Wolfgang Bangerth, 2026/06/10)

14. Deprecated: The classes Algorithms::Event, Algorithms::OperatorBase, Algorithms::OutputOperator, Algorithms::Newton, Algorithms::ThetaTimestepping, Algorithms::TimestepControl, and Algorithms::DoFOutputOperator have been marked as deprecated.
    (Wolfgang Bangerth, 2026/06/10)

15. New: Added output in NetCDF using CF/UGRID conventions to DataOut.
    (Daniel Abele, 2026/06/09)

16. Improved: The function vectorized_load_and_transpose() now produces more efficient remainder code for sizes 1, 2, 3 on x86.
    (Martin Kronbichler, 2026/06/09)

17. New: Add NetCDF as an optional dependency (to be used for output in an upcoming feature).
    (Daniel Abele, 2026/06/08)

18. New: Add new preconditioner class: PreconditionFROSch, which adds a wrapper for the FROSch preconditioner, that is part of Trilinos.
    (Sebastian Kinnewig, 2026/06/07)

19. New: Extended the TimeStepping namespace by the adaptive Tsitouras 5(4) explicit Runge-Kutta method (TimeStepping::TSITOURAS5).
    (Jalil Khan, 2026/06/06)

20. Improved: FilteredIterator now re-uses the provided predicate object between different iterators instead of copying it (which required an allocation). This lowers the number of allocations in step-32 by about 15%.
    (David Wells, 2026/05/25)

21. Fixed: FEEvaluation::distribute_local_to_global() would produce a segmentation fault if initialized with DoFHandler::active_cell_iterator and used with LinearAlgebra::distributed::Vector. This is now fixed.
    (Martin Kronbichler, 2026/05/22)

22. New: Improve VTK dataset import/export utilities by supporting conversion of generic VTK datasets to unstructured grids while preserving attached data arrays, adding XML .vtu reading support, and propagating optional material, boundary, and manifold id field names through read_tria() and read_vtk().
    (Luca Heltai, 2026/05/21)

23. Fixed: The SolverFIRE class assumed that the matrix object has a residual() function, but this function is not part of the required interface for all matrix types that can be passed to linear solvers. This is now fixed by instead relying on vmult() functionality.
    (Wolfgang Bangerth, 2026/05/21)

24. Fixed: Fix multigrid W- and F-cycles. Previously, intermediate solutions were overwritten between cycles, effectively resulting in a V-cycle.
    (Peter Munch, 2026/05/18)

25. Improved: The arrays inside a Triangulation now use strides which depend on the present ReferenceCell objects, rather than the maximum values over all possible ReferenceCell objects. For example, a Triangulation containing only tetrahedra now only stores four face orientations per cell instead of six. This lowers memory consumption for tetrahedral Triangulations by about 20%.
    (David Wells, 2026/05/16)

26. New: Extended the PETScWrappers::MPI namespace by a full matrix (PETScWrappers::MPI::FullMatrix).
    (Jonas Plank, 2026/05/15)

27. Moved: The function ReferenceCell::n_vertices_to_type() has been deprecated. Its replacement is ReferenceCells::n_vertices_to_reference_cell().
    (Wolfgang Bangerth, 2026/05/12)

28. Fixed: The default mapping provided to FEFieldFunction only worked for hypercube meshes. This is now fixed by introducing a second constructor that determines what the appropriate linear mapping for a given mesh is, and then using this mapping.
    (Wolfgang Bangerth, Sam Scheuerman, David Wells, 2026/05/12)

29. Improved: DynamicSparsityPattern's internal allocation scheme was rewritten to use about 50% fewer allocations and be about 10% faster for scalar problems. In some cases, such as FESystem<3>(FE_Q<3>(2), 3), the new allocation scheme is about 50% faster. This scheme uses about 50% more memory, but since the creation of a DynamicSparsityPattern is usually followed by creation of a SparsityPattern and a SparseMatrix, each of which is about the same size as the original DynamicSparsityPattern, the maximum memory usage of a process is the the same and hence the added memory cost of the DynamicSparsityPattern is negligible.
    (David Wells, 2026/05/06)

30. Improved: TimeStepping::ExplicitRungeKutta now also supports TimeStepping::HEUN_EULER.
    (Peter Munch, 2026/05/05)

31. Improved: VTU output is now about 5% faster on large meshes and no longer allocates memory for every processed cell.
    (David Wells, 2026/05/03)

32. New: Add a new signed distance function for an infinite cylinder (Functions::SignedDistance::InfiniteCylinder). It supports calculation of its values and gradients.
    (Magdalena Schreter-Fleischhacker, Julian Brotz, Bruno Blais, 2026/04/30)

33. New: There is now a version of GridGenerator::cheese() that allows the creation of meshes based on true/false masks for pixelized/voxelized data.
    (Wolfgang Bangerth, 2026/04/28)

34. Fixed: Despite its name, the GridGenerator::cheese() function in 3d did not actually create any holes. It just produced a solid volume. This is now fixed.
    (Wolfgang Bangerth, 2026/04/28)

35. Fixed: TimerOutput::print_wall_time_statistics() no longer requires all processes to enter the same sections when the TimerOutput is constructed without an MPI communicator. Sections that are not entered on a process are now reported with zero timing. Previously, this could trigger an assertion or lead to a deadlock.
    (Torsten Schmid, 2026/04/20)

36. Fixed: When configuring for using both MPI and VTK, then VTK's CMake scripts unset information about the MPI version. As a consequence, the variables DEAL_II_MPI_VERSION_MAJOR and DEAL_II_MPI_VERSION_MINOR were left blank, and we always fell back to using MPI 3 functionality even if the MPI installation would have supported newer MPI functions.
    (Wolfgang Bangerth, Matthias Maier, 2026/04/13)

37. Improved: The order by which a MatrixFree object passes through cells is now using the order implied by the categorization specified by MatrixFree::AdditionalData::cell_vectorization_category, if the number of categories equals the number of locally owned active cells in case the flag MatrixFree::AdditionalData::cell_vectorization_categories_strict is set to false, or if at least a quarter of cells is given for the flag set to true. By setting a one-to-one numbering of cells, one can now inject a fixed ordering of cells.
    (Martin Kronbichler, 2026/04/07)

38. Fixed: The function FEValuesViews::Vector::curl() computed the wrong value for dim==2 and spacedim==3, i.e., for the case of a two-dimensional manifold embedded in 3d. In that case, it assumed that we are dealing with a two-dimensional vector field, for which the curl is a scalar, when what is meant is the curl of a three-dimensional vector field defined on a surface.
    (Wolfgang Bangerth, 2026/03/18)

39. Fixed: Initializing FEEvaluation with a Mapping, FiniteElement, and Quadrature object would leave some data pointers unset, leading to problems e.g. when evaluating elements of type FE_RaviartThomasNodal. This is now fixed.
    (Martin Kronbichler, 2026/03/30)

40. Extended: parallel::distributed::Triangulation::copy_triangulation() now allows to control whether to copy also the triangulation settings or to use a developer provided setting. This can be useful for multigrid computations. (Vivienne Ehlert, Martin Kronbichler, 2026/03/27)

41. Changed: Serialization of Table and AlignedVector objects storing "trivial" data types (things such as double or int) now do this by serializing a binary blob of bits, rather than individual array members. This has no effect for binary archives (as one should use for checkpointing, for example), but makes text-based archives substantially smaller.
    (Wolfgang Bangerth, 2026/03/20)

42. Fixed: If FEFaceValues::reinit() and FESubfaceValues::reinit() were used on objects that remained valid after a change in the triangulation and used the same cell, they could sometimes produce wrong results for the metric terms. This is now fixed.
    (Martin Kronbichler, 2026/03/19)

43. Fixed: The function AlignedVector::load() function did not work correctly if the AlignedVector object on which it was called had non-zero size and the object being deserialized had zero size.
    (Wolfgang Bangerth, 2026/03/18)

44. Improved: Triangulation::pack_data_serial() previously had quadratic complexity in the preparation of cell relations, which had a negative impact on runtime when refining a serial Triangulation in combination with SolutionTransfer. This has been improved.
    (Peter Munch, Martin Kronbichler, Lukáš Lejdar, 2026/03/17)

45. Fixed: Deserialization of an AlignedVector now works correctly with types which are not trivially copyable.
    (David Wells, 2206/03/15)

46. Fixed: When using the PETSc solver through PETScWrappers, the original code will use the l2 norm of the preconditioned residual. This is not consistent with deal.II expectations and example usage. This PR fixes the issue by using the unpreconditioned residual norm.
    (Yiliang Wang, 2026/03/05)

47. Fixed: The function AlignedVector::replicate_across_communicator() could not deal with tables that took up more than about 2GB because of an integer overflow. This is now fixed.
    (Wolfgang Bangerth, 2026/02/25)

48. Fixed: NonMatching::MappingInfo::reinit() would leak a small amount of memory in each call. This is now fixed. This indirectly affects the usage of FEPointEvaluation.
    (Timo Heister, 2026/02/24)

49. Improved: CellAccessor::child_iterators() return vector size now depends on the constexpr function ReferenceCells::max_n_children<dim>().
    (Andreas Steger, 2026/02/23)

50. New: VTKWrappers::unstructured_grid_to_dealii_triangulation() and VTKWrappers::dealii_triangulation_to_unstructured_grid() allow translations of a Triangulation from and to vtkUnstructuredGrid.
    (Luca Heltai, 2026/02/19)

51. Fixed: FEPointEvaluation::get_gradient() would return wrong results if a mesh consisted of both non-affine and affine elements and several points were evaluated on the cells of affine shape. This also affected the step-19 tutorial program. This is now fixed.
    (Martin Kronbichler, Zdeněk Bonaventura, 2026/02/13)

52. New: A new class DataOutPoints to produce graphical output in a set of points specified by the user.
    (Timo Heister, 2026/02/04)

53. New: RemotePointEvaluation::CellData::get_data_view() now supports cases with more than one component via an optional third argument.
    (Timo Heister, 2026/01/28)

54. Fixed: Various minor issues with algorithms operating on large problems with DEAL_II_WITH_64BIT_INDICES=ON have been addressed.
    (Timo Heister, 2026/01/27)

55. Fixed: The function VectorTools::project_boundary_values_div_conforming() would previously allocate an array of length equal to the global number of degrees of freedom. This is now fixed, making sure that also large-scale parallel programs can fit into memory.
    (Martin Kronbichler, 2026/01/26)

56. New: step-7 now has extensive sections on comparing numerical methods via cost-accuracy diagrams.
    (Wolfgang Bangerth, 2026/01/26)

57. Improved: Added an overload of DoFAccessor::get_interpolated_dof_values() which takes an ArrayView, instead of a Vector, as an argument. This function enables callers like FEValues to avoid allocating memory for many low-order elements.
    (David Wells, 2026/01/25)

58. Fixed: MappingFEField::get_vertices() correctly works with threads again.
    (David Wells, 2026/01/25)

59. New: The GridGenerator::uniform_channel_with_sphere() function creates the three-dimensional mesh of a channel with a sphere inside. The mesh created is conformal.
    (Quentin Viville, 2026/01/24)

60. New: LinearAlgebra::TpetraWrappers::PreconditionAMGMueLu has been added as preconditioner for TpetraWrappers::SparseMatrix.
    (Jan Philipp Thiele, Daniel Arndt, 2026/01/08)

61. New: VTKWrappers::read_vtk() allows to read all content of a vtk file (grid and data) into a Triangulation, DoFHandler, and Vector.
    (Luca Heltai, 2025/12/30)

62. New: Make NonMatching::MeshClassifier handle the case where the zero contour of a level set function aligns perfectly with a face in the mesh, by adding a new entry, "aligned", in the enum LocationToLevelSet.
    (Simon Sticko, Magdalena Schreter-Fleischhacker, 2025/12/25)

63. New: The new function VTKWrappers::read_all_data() loads a VTK unstructured grid file (optionally cleaning overlapping points) and concatenates every point and cell data array it finds into the provided output vector.
    (Luca Heltai, 2025/12/24)

64. New: The function GridTools::parallel_to_serial_vertex_indices() returns a vector mapping each vertex of a parallel Triangulation to the corresponding vertex index in the originating serial Triangulation.
    (Luca Heltai, 2025/12/23)

65. New: Implemented a new RTreeFunctionalVisitor class and corresponding visit_rtree() function that allow to visit (read only) a boost RTree data structure, executing a user provided function for each node, leaf, or element of the tree.
    (Luca Heltai, 2025/12/19)

66. Changed: step-42 used to create output of the solid object in the deformed configuration by deforming the mesh with the solution before output, creating output in the deformed configuration, and then undoing the mesh deformation. But we can do all of this without deforming the mesh at all: The MappingQEulerian class can do that more easily, and step-42 has been changed to use this approach now.
    (Wolfgang Bangerth, 2025/12/17)

67. Add: Add support for LinearAlgebra::distributed::Vector to the SparseDirectMUMPS class.
    (Marco Feder, 2025/12/14)

68. Added: FE_Hermite has now a new function FE_Hermite::get_dofs_corresponding_to_outward_normal_derivatives() that returns those cell unknowns that have a particular derivative index nonzero on all faces, which helps with the implementation of boundary conditions.
    (Ivy Weber, Martin Kronbichler, 2025/12/11)

69. Enable Taskflow-based parallelization of parallel::apply_to_subranges(). This functionality is missed in the current code, which only supports TBB and sequential execution.
    (Qingyuan Shi, 2025/12/10)

70. New: The new function VTKWrappers::vtk_to_finite_element() generates a FiniteElement object from a VTK supported file. The generated FiniteElement can be used to create a field that is compatible with the field data contained in the file.
    (Luca Heltai, 2025/12/09)

71. Improved: The Taskflow based WorkStream::run using graph coloring has been improved to be significantly more performant in the cases where work units are very cheap.
    (Ryan Moulday, Timo Heister, 2025/12/08)

72. New: A nodal variant of Nedelec elements, FE_NedelecNodal, has been added.
    (Natalia Nebulishvili, Martin Kronbichler, Katharina Kormann, 2025/12/05)

73. Add: Introduce a fully vectorizable function to approximate the exponential function. The function offers faster computation than std::exp while maintaining high accuracy and supports SIMD/vectorized operations.
    (Julian Brotz, 2025/12/02)

74. New: A new overload of MatrixFree::initialize_dof_vector() for BlockVector creates a block for each DoFHandler passed to MatrixFree::reinit().
    (Timo Heister, 2025/11/29)

75. New: The function VTKWrappers::read_cell_data() allows to read cell data contained in a VTK file using the VTK library.
    (Luca Heltai, 2025/11/25)

76. New: The function VTKWrappers::read_vertex_data() allows to read vertex data from vtk files using the VTK library.
    (Luca Heltai, 2025/11/25)

77. New: VTKWrappers::read_vtk() can now read any unstructured vtk file using the native VTK library. This includes binary vtk files, and any format supported by vtkUnstructuredGridReader.
    (Luca Heltai, 2025/11/25)

78. Fix: Shorten documentation of ParsedFunction that is printed to parameter files.
    (Luca Heltai, 2025/11/21)

79. New: You can now mask vector elements in TrilinosWrappers::ROLAdaptor to reduce the size of the optimization space. This is useful for excluding constrained degrees of freedom from the optimization process.
    (Marc Fehling, 2025/11/20)

80. Fixed: TrilinosWrappers::ROLAdaptor::reduce() now also works on parallel.
    (Marc Fehling, 2025/11/19)

81. New: In Portable::MatrixFree the method get_cell_iterator() has been added.
    (Michał Wichrowski, 2025/11/11)

82. Changed: Time step information is saved for pvtu output. In addition the default value of VtkFlags::cycle is changed to numbers::invalid_unsigned_int and VtkFlags::time to std::numeric_limits<double>::lowest() to ensure it is added to the output at the first time step (cycle=0).
    (Florian Schulze, 2025/11/08)

83. Fixed: Move constructor and assignment operator of Triangulation<dim> did not move the data member cell_data_attached_data. This led to failures when trying to use a moved to Triangulation e.g. for refinement.
    (Alexander Reinhold, 2025/11/07)

84. New: Portable::MatrixFree is now able to support actions on multigrid levels to support local smoothing multigrid.
    (Michał Wichrowski, 2025/11/05)

85. New: FEPointEvaluation can now evaluate from a list of values that represent multiple components of a scalar FiniteElement.
    (Martin Kronbichler, 2025/10/29)

86. New: SegmentDataOut — adds a DataOut-style interface for exporting data on 1D segments.
    (Michał Wichrowski, 2025/10/27)

87. Changed: The ParticleHandler class now provides references to the underlying triangulation and mapping through member functions get_triangulation() and get_mapping(). In addition, the member functions get_particle_positions( VectorType &) and get_particle_positions(std::vector<Point<spacedim>> &) are marked as const member functions, so that they can be called from const ParticleHandler objects.
    (Yimin Jin, 2025/10/27)

88. New: The GridGenerator::convert_simplex_to_hypercube_mesh() function splits all cells of a simplex mesh into hypercubes, producing a mesh with cells of only the latter kind.
    (Wolfgang Bangerth, Dominik Still, 2025/09/25)

89. New: Added variadic template overloads for FullMatrix::kronecker_product() to compute the Kronecker product of multiple matrices in a single call.
    (Michał Wichrowski, 2025/10/21)

90. New: Added FullMatrix::permute() method to permute rows and columns of a matrix.
    (Michał Wichrowski, 2025/10/20)

91. Improved: The various all_zero() functions (e.g., Vector::all_zero()) now consistently use std::all_of() to detect nonzero entries instead of norms or ad-hoc loops.
    (David Wells, 2025/10/20)

92. New: FEEvaluationData::read_cell_data now is also able to fetch data from Table
    (Michał Wichrowski, 2025/09/27)

93. Fixed: MGTransferMatrixFree::initialize_dof_vector() optionally forces the target vector to have the same partitioner as stored in the transfer operator. This fixes a bug where the two partitioners were assumed to be the same in MGTwoLevelTransfer::restrict_and_add(), triggering an assertion in debug mode for block-based systems.
    (Michele Bucelli, 2025/10/01)

94. New: A safety factor that multiplies the maximum eigenvalue estimate for PreconditionChebyshev and PreconditionRelaxation can now be provided via AdditionalData.
    (Michał Wichrowski, 2025/09/27)

95. Fixed: Resolved an access violation when using a DataOut object that has been copied or moved.
    (Daniel Abele, 2025/09/26)

96. New: The GridIn::read_ugrid() function now reads mesh files written in ugrid format.
    (Wolfgang Bangerth, Jerett Cherry, 2025/09/25)

97. Changed: The TimerOutput class now reports CPU time spent in sections as the sum over all processes in the given MPI communicator. Previously, it would only report for each section the CPU time on the current process. This meant the time spent in sections would not add up to the total CPU time, which was always reported as the sum over all MPI processes.
    (Rene Gassmoeller, 2025/09/24)

98. Added the MatrixScaling class. The class implements various known matrix scaling algorithms.
    (Davide Polverino, 2025/09/17)

99. New: Added bundled version of magic_enum.
    (Marc Fehling, 2025/09/17)

100. Improved: TimeStepping::LowStorageRungeKutta now also supports TimeStepping::FORWARD_EULER and TimeStepping::HEUN_EULER.
     (Peter Munch, 2025/09/10)

101. Changed: We now require Kokkos 4.0 or newer when device support is enabled (CUDA, HIP, SYCL).
     (Timo Heister, 2025/09/02)

102. Fixed: Polynomials derived from the class PolynomialsVectorAnisotropic would previously not overwrite all previous content in the values, grads and higher derivative fields that are designated as output. The behavior has been fixed, making sure that all content is explicitly written in the function.
     (David Wells, Martin Kronbichler, 2025/08/19)

103. New: GridIn used to support vtk meshes with version 3.0 only. Now it supports vtk meshes with version 5.1.
     (Mohamad Ghadban, 2025/08/09)

104. New: The ClosestSurfacePoint class in the Tools Shifted Boundary Method computes the closest point on a surface defined by a level set function.
     (Michał Wichrowski, 2025/07/25)

105. New: Integration of Gmsh api utilities for parallel distributed mesh handling: the function GridIn::read_partitioned_msh() can now be used to read partitioned mesh files in parallel.
     (Raksha Devi, Luca Heltai, 2025/07/25)

106. Improved: MappingFEField now stores which DoFs are nonzero in each component, which makes subsequent calculations about 30-50% faster.
     (David Wells, 2025/07/14)

107. Fixed: PetscWrappers::SparseMatrix::memory_consumption() previously always returned 0. This is now fixed.
     (Anna Long, 2025/07/11)