Open CASCADE Technology 8.0.0 Release

[dpasukhi]

Open Cascade is delighted to announce the final release of Open CASCADE Technology version 8.0.0 to the public.

This is the largest single-version step in OCCT in many years. The cycle covered five Release Candidates and three Beta builds and accumulated more than 500 changes since 7.9.0. The notes below describe what is different in 8.0.0 final compared to 7.9.0. Per-stage notes remain available for anyone tracking individual increments.

Migration guidance is published separately on the developer portal: https://dev.opencascade.org/doc/overview/html/occt__upgrade.html. The page may take a short time to refresh after the tag.

Per-stage release notes

• Release Candidate 1
• Release Candidate 2
• Release Candidate 3
• Release Candidate 4
• Release Candidate 5
• Beta 1
• Beta 2
• Beta 3

---

Project layout, language baseline and tooling

The minimum C++ standard is now C++17. The codebase uses if constexpr, std::optional, std::variant, std::string_view, std::shared_mutex, structured bindings and fold expressions throughout. Compilers below the C++17 line are no longer supported.

The source tree was reorganized to follow src/Module/Toolkit/Package/File. Resources moved to a top-level /resource directory. Documentation generation moved from the legacy Tcl harness to CMake. Inspector and ExpToCas were extracted into their own repositories. The samples/ directory contains a top-level README pointing to the external samples repository and the browsable site.

CMake support was reworked. The build is validated on CMake 3.10 and above. ARM64 is a first-class target on both macOS and Windows. VCPKG support is comprehensive: a share/-compliant layout, the OCCT_PROJECT_NAME parameter for directory customization, and the upstream opencascade port with TclTk and GTest. VTK 9 is supported, with conditional linkage of vtkRenderingGL2PSOpenGL2 so Android, iOS and GLES builds do not require it. VTK is no longer enabled by default: configurations that depend on TKIVtk and the VTK-based viewer must set USE_VTK=ON explicitly.

GTest is the unit-testing framework for OCCT. New tests were added across every module, and many legacy QADraw test cases were migrated to GTest.

Foundation Classes

Exceptions and threading

Standard_Failure now inherits from std::exception. OCCT errors can be caught through catch (const std::exception&) or catch (const Standard_Failure&). The class exposes what() and ExceptionType(). The static helpers Raise(), Throw() and Instance() are gone; exceptions are raised with the C++ throw keyword. Standard_ErrorHandler::Catches() and LastCaughtError() are also removed.

The error-handler stack is thread_local. There is no global mutex on the error-handler path, so OCCT exception handling scales linearly with thread count. OCC_CATCH_SIGNALS was updated accordingly.

Standard_Mutex and TopTools_MutexForShapeProvider were retired. Code uses std::mutex, std::lock_guard, std::unique_lock and, where ownership is optional, std::unique_ptr<std::mutex>. Standard_Condition was rebuilt on top of standard primitives. Foundation-level globals use std::atomic. Windows host initialization uses std::call_once. Several global mutable statics in TKBool were converted to thread_local. Concurrent operations in the BRep checker and several Foundation paths are race-free.

Transfer_TransferDeadLoop is deprecated. Dead-loop detection now uses local status flags rather than a thrown exception; the class is retained for binary compatibility but should not be used by new code.

Math

The OCCT global math wrappers (ACos, ASin, ATan, ATan2, Sin, Cos, Tan, Cosh, Sinh, Tanh, ACosh, ASinh, ATanh, Sqrt, Log, Log10, Exp, Pow, Abs, Sign, Floor, Ceiling, Round, IntegerPart, Min, Max, NextAfter, ACosApprox) are deprecated. Code should use the matching std:: functions.

Solver and matrix code received broad updates:

• MathPoly_Laguerre provides general polynomial root finding with Laguerre iteration plus deflation, including specialized helpers for quintic, sextic and octic polynomials.
• The 2D, 3D and 4D Newton solvers were refactored onto a unified fixed-size API.
• A coordinate-wise polishing phase based on Brent line search (MathUtils_LineSearch::BrentAlongCoordinate, MathUtils_Random) was added to the PSO and DE solvers. On separable functions it improves component-level precision from around 1e-4 to 1e-8 and better.
• The modern MathRoot, MathSys and MathLin packages were aligned with the legacy math_* results so callers can switch without behavioural drift.
• math_Matrix::Multiply() uses an i-k-j loop order matching the row-major storage.
• math_VectorBase::Norm() and Norm2() use four-way unrolling with pairwise partial sums.
• math_Matrix and math_Vector are movable. math_Vector::Resize() was added.
• math_DoubleTab is built on NCollection. math_DirectPolynomialRoots was refactored. math_FunctionRoot no longer raises StdFail_NotDone when iteration count is queried after a failed root search.
• Compile-time sqrt constants and a constexpr Pascal allocator for PLib::Bin are available. Jacobi coefficients are precomputed.
• PLib_Base and PLib_DoubleJacobiPolynomial were removed. PLib_JacobiPolynomial and PLib_HermitJacobi are value types and their evaluation methods are const.
• Polynomial evaluation in PLib was optimized along the hot path.
• EigenValuesSearcher was tightened.

TKMath was reorganized: the modern MathRoot, MathSys, MathLin, MathPoly, MathUtils packages own the new solver, root-finder and utility code, while the legacy math_* headers continue to compile.

Collections

Several new containers entered the foundation:

• NCollection_FlatMap and NCollection_FlatDataMap are open-addressing hash tables with Robin Hood probing. Pairs are inline in a contiguous array, sizing is power-of-two with bitwise modulo, and hash codes are cached.
• NCollection_OrderedMap and NCollection_OrderedDataMap preserve insertion order through an intrusive doubly linked list. Lookup, append and removal are O(1).
• NCollection_KDTree is a header-only static balanced KD-tree supporting nearest-neighbour, k-NN, range, axis-aligned-box and sphere queries, plus a callback-based range query for custom filtering during spatial searches. It works out of the box with gp_Pnt, gp_Pnt2d, gp_XYZ and gp_XY, with optional per-point radii and weighted nearest queries through compile-time template parameters.
• NCollection_LinearVector is a contiguous flat-buffer dynamic array. Trivially copyable types grow through Standard::Reallocate; non-trivial types grow through move construction. Iterator invalidation is documented in the header.
• NCollection_DynamicArray was rebuilt on top of NCollection_LinearVector<T*> with fixed-size blocks, power-of-two block sizing, and a precomputed shift and mask for O(1) indexed access. InsertBefore() and InsertAfter() helpers are available with element-shift semantics.
• NCollection_ForwardRange is a lightweight non-owning forward-range adapter. It supports range-based for over index spans.

The whole map family received an API pass:

• Contained() is available on every map type and returns std::optional<std::reference_wrapper<T>>.
• TryEmplace() and TryBind() are available on every map type.
• Items() and IndexedItems() views allow for (auto [k, v] : map.Items()) { ... } over DataMap, FlatDataMap, IndexedDataMap and IndexedMap.
• Emplace methods (EmplaceAppend, EmplacePrepend, EmplaceBefore, EmplaceAfter) are present on List, Sequence, DynamicArray, Array1 and Array2.
• NCollection_List has a std::initializer_list constructor, an Exchange() method, an optimized move constructor and improved const-correctness.
• NCollection_UBTree and NCollection_EBTree traverse iteratively through an explicit stack (the recursive variant could overflow on deep trees) and have move semantics.
• NCollection_LocalArray works with non-trivial types through placement-new and explicit destruction, has move semantics and Reallocate(), so it can be used as a growable stack.
• NCollection_CellFilter has proper move semantics.
• The NCollection_IncAllocator fast path is lock-free: a std::shared_mutex plus CAS bump allocation on an atomic available-size means existing-block allocations never contend.
• NCollection_BaseMap iterators were unified under size_t through a findFirst() helper.
• Size() returns size_t on Map, DataMap, IndexedMap, IndexedDataMap, Sequence, Array1, Array2 and List. Length() keeps the int contract for callers that feed sizes into int-typed APIs.
• NCollection_Array1 and Array2 have zero-based constructors and size_t-based Resize() overloads. Assign() and operator= now overwrite the destination bounds (matching std::vector); the previous element-wise copy with size-mismatch throw is preserved as CopyValues().
• Standard_Transient reference counting uses explicit memory ordering (relaxed increment, release decrement with an acquire fence at zero).
• Sun WorkShop and Borland compiler workarounds were removed.
• NCollection_SparseArrayBase no longer carries a vtable: virtual dispatch was replaced with function pointers, fixing the long-standing pure-virtual call that could trigger during destruction.
• NCollection_BasePointerVector was removed. NCollection_Vector, OSD_MAllocHook, QANCollection, PLib_DoubleJacobiPolynomial and the Standard_Mutex-based code paths were removed or deprecated. TColGeom, TColGeom2d, Geom2dLProp and LProp3d typedef-only packages were retired (aliases are preserved where they used to ship).

Strings

TCollection_AsciiString and TCollection_ExtendedString gained EmptyString() accessors, AssignCat/Cat overloads for int and double, wchar_t* append/concatenate helpers, and std::u16string_view interop on the extended string. The pre-defined-string fast path is in place. Multi-byte UTF-8 sequences are now correctly handled in UsefullLength().

Draw_Interpretor::Append() and operator<< now have size_t overloads.

Geometric primitives

gp_Vec, gp_Vec2d, gp_XY and gp_XYZ use direct data-member access in performance-critical sections. Matrix inversion, transposition and power are faster.

Many geometric primitives became constexpr/noexcept (circles, cones, cylinders, axes, planes). gp_Pln was refactored.

gp_Dir::D and gp_Dir2d::D enumerations express the standard X, Y, Z, NX, NY, NZ directions for gp_Dir, and X, Y, NX, NY for gp_Dir2d.

Bnd, BVH, Quantity, TopLoc

Bnd_Box::Add, Bnd_Box::IsOut, Bnd_Box::Distance, Bnd_Range::Common, Bnd_Sphere::SquareDistances and several Bnd_OBB degenerate cases were fixed. Early-return fast paths were added on IsOut. Contains() and Intersects() wrappers are available. Center(), Min(), Max(), Get() return std::optional. Bnd_Range::IsIntersected returns the new Bnd_Range::IntersectStatus enum instead of a magic integer. Bnd_Box::CornerMax returns the correct corner. [[nodiscard]] and noexcept were applied where appropriate. Bnd_B2 and Bnd_B3 were rebuilt on a single template implementation. Bnd_BoundSortBox::Compare no longer fails on certain inputs.

The BVH layer accepts generic vector types in its boxes and rays. TopLoc_Location::HashCode is faster, and TopLoc_Location::Predivided short-circuits the identity and equal-location cases. The Quantity package and TopExp were optimized. CSLib and Extrema were refactored, with new GTests added.

Other

Precision.hxx exposes additional precision-related methods. Angle normalization was reworked in ElCLib and ElSLib. AdvApp2Var was modernized. AppCont_ContMatrices is now a private namespace, and an out-of-bounds read for classe=26 was fixed by adding three missing data entries. Unit conversion (Units_Measurement, Units::Convert) prints the offending unit on failure and no longer crashes when the first unit is unknown. Standard_DEPRECATED_STD expands to standard [[deprecated("...")]] (or to nothing under OCCT_NO_DEPRECATED).

Host name resolution is self-contained. Linux signal handling is GLIBC-compatible. MallInfo is detected before use. WinAPI resource leaks were fixed. HashUtils is noexcept on the hot path.

Modeling Data

Geometry evaluation

The evaluation hierarchy across the 32 leaf curve and surface classes in Geom* and Geom2d* was redesigned. EvalD0, EvalD1, EvalD2, EvalD3 and EvalDN are the primary virtual methods. They return POD result structs (Geom_CurveD1/D2/D3, Geom_SurfD1/D2/D3, Geom2d_CurveD1/D2/D3). The original D0/D1/D2/D3/DN and Value() methods are retained as non-virtual inline wrappers that delegate to Eval*. Subclasses that override evaluation must override the Eval* entry points.

All 29 concrete leaf classes in the Geom_* and Geom2d_* hierarchies are marked final. Code that needs to extend a concrete shape must inherit from the abstract bases (Geom_BoundedCurve, Geom_ElementarySurface, etc.).

Adaptor dispatch on the elementary path is devirtualized. gp_* primitives are stored directly inside std::variant in adaptors and dispatched by switch and enum into ElCLib and ElSLib. Compilers can devirtualize the entire elementary evaluation chain.

EvalRep decouples geometry identity from evaluation strategy. A geometry can carry a side descriptor that is dispatched in place of its native evaluator (Geom_OffsetSurface, for example, can carry an equivalent non-offset surface and bypass the offset evaluation cost). The API supports full, derivative-bounded and parameter-mapped descriptors.

GeomEval and Geom2dEval host evaluation-focused implementations of T-Bezier and AHT-Bezier curves and surfaces, sine waves, Archimedean and logarithmic spirals, circle involutes, circular helices, ellipsoids, hyperboloids, paraboloids, hyperbolic paraboloids and circular helicoid surfaces. GeomGridEval and Geom2dGridEval provide batch evaluation for 3D and 2D curves with specialized analytical evaluators for conics and cache-based evaluators for BSpline and Bezier.

Adaptor Bezier cache validity checks were removed for single-span Beziers. The grid-eval threshold was tightened so cache-based evaluation is selected more aggressively.

Differential properties

Three new packages replace the legacy macro-based LProp family:

• Geom2dProp for 2D curve differential properties.
• GeomProp for 3D curve and surface differential properties.
• BRepProp for BRep edges and faces, including BRepProp::Continuity.

Each package dispatches through std::variant to per-geometry evaluators (Line, Circle, Ellipse, Hyperbola, Parabola, BezierCurve, BSplineCurve, OffsetCurve, plus the equivalent surface set). Tangent, curvature, normal, centre of curvature, curvature extrema and inflection points come back as result structs with IsDefined flags rather than exceptions. Surface curvatures are computed from the Weingarten map with the correct sign convention. Per-parameter derivative caching is built in. Construction is direct from geometry handles, bypassing adaptor creation, and class identity is tested through DynamicType() instead of IsKind(). Domain structs carry trimmed-geometry bounds. Two-step Initialize() is gone: the classes are valid after construction. BRepProp_Curve continuity mapping covers GeomAbs_G2 and higher, matching GeomProp_Curve.

Bounding boxes

GeomBndLib replaces the monolithic switch-based BndLib approach with per-type evaluators dispatched through std::variant:

• GeomBndLib_Curve, GeomBndLib_Curve2d and GeomBndLib_Surface dispatchers expose Box()/BoxOptimal() (return-by-value) and Add()/AddOptimal() (mutate-by-reference) APIs.
• Analytical solutions exist for Line, Circle, Ellipse, Hyperbola, Parabola, Plane, Sphere, Cylinder, Cone and Torus, including tilted tori and revolution and extrusion surfaces with circle-arc bounding at extremal positions.
• BSpline and Bezier use a knot-span FillBox with convex-hull reduction, with pole indices selected through BSplCLib::Hunt so no Copy() or Segment() allocation is needed.
• BoxOptimal runs PSO followed by per-coordinate Powell minimization for tight bounds.

BndLib_Add3dCurve, BndLib_AddSurface and BndLib_Add2dCurve are thin wrappers that forward to GeomBndLib. The public BndLib API is unchanged.

TopoDS and TShape

TopoDS_TShape carries its state in a bit-packed uint16_t field: the shape type lives in the low four bits and the eight boolean flags (Free, Modified, Checked, Orientable, Closed, Infinite, Convex, Locked) live in the next eight, leaving four bits reserved. ShapeType() reads from this field inline rather than dispatching through a virtual call. TopAbs::Compose, Reverse and Complement are inline noexcept static functions. TopoDS_Iterator exposes begin()/end() through NCollection_ForwardRange so sub-shapes can be visited with range-based for.

TopExp_Explorer uses NCollection_LocalArray with an explicit top index for its stack. Clear() resets live TopoDS_Iterator slots in place from myStackTop down to zero, keeping the array allocation, so reuse skips reallocation.

BSpline and Bezier

Curve and surface members in Geom_BSplineCurve, Geom_BSplineSurface, Geom_BezierCurve, Geom_BezierSurface, Geom2d_BSplineCurve, Geom2d_BSplineSurface, Geom2d_BezierCurve and Geom2d_BezierSurface are direct value-typed NCollection_Array1/Array2 members rather than handle-wrapped heap arrays. Reference counting and heap indirection on the evaluation path are gone.

Weights are always populated. Non-rational geometries point at a static unit-weights buffer through a non-owning view, so there is no allocation. WeightsArray() returns a valid reference unconditionally, eliminating the previous nullable Weights() pattern across roughly a hundred call sites. Copy-out accessors are deprecated in favour of const-reference returning versions; for example, Poles() returns a const NCollection_Array1<gp_Pnt>&.

BSplCLib interpolation and blend evaluation are faster: the GeomFill convertor matrices are statically initialized, small matrices and arrays live on the stack, hot loops use raw pointers without bounds-check accessor chains, and solver instances and NbPoles() results are cached.

Several long-standing bugs were corrected: the Pole0 < 3 typo in Hermit.cxx (should have been Pole0 < Pole3), Geom_BSplineCurve::IsEqual skipping knot comparison, Geom_BSplineSurface::SetUNotPeriodic and SetVNotPeriodic invoking the wrong constructor, Geom_BezierSurface::Increase self-referencing Init, undefined behaviour in BSplCLib::NbPoles, and span out-of-range access in BSplCLib_Reverse.

IsClosed, IsPeriodic, geometry hashing

IsClosed() on curves and surfaces compares against Precision::Computational() (close to DBL_EPSILON) instead of gp::Resolution() (around 1e-290), so the check is actually meaningful. Trimmed curve and surface IsClosed()/IsPeriodic() detect integer-period spans through std::remainder().

GeomHash and Geom2dHash provide hash functions for geometric curves and surfaces, with configurable CompTolerance and HashTolerance fields and constructors instead of the previous hardcoded 1e-12.

Adaptors

GeomAdaptor_TransformedCurve is the new base class for BRepAdaptor_Curve. It wraps a GeomAdaptor_Curve or Adaptor3d_CurveOnSurface together with a gp_Trsf. GeomAdaptor_TransformedSurface caches transformed data, rebuilt on construction, Load or SetTrsf. Original and transformed surface accessors are exposed; the legacy GeomSurface() accessor is deprecated. GeomAdaptor_Surface exposes ToleranceU() and ToleranceV(). EvalD* is the primary virtual evaluation method across Adaptor3d_Curve and Adaptor3d_Surface subclasses, and 15+ adaptor classes were updated.

gce and GC builders were hardened: perpendicular-direction fallback branches in gce_MakeCone and gce_MakeCylinder were corrected, status from delegated builders is propagated in GCE2d_MakeCircle and GC_MakePlane, hardcoded tolerances were replaced with Precision::Confusion(), near-zero guards were added to gce_MakeElips and gce_MakeHypr, and the over-constraining hyperbola direction check was removed (with collinear-point validation added to the three-point constructor). Documentation across GC and gce was harmonized and trivial wrappers were inlined.

Handle-returning APIs

Methods that used to return handles through an output parameter now return them by value across ApplicationFramework, DataExchange, ModelingAlgorithms, ModelingData and Visualization. The old out-parameter signatures are kept as deprecated overloads that route through the new versions, and [[nodiscard]] was applied where appropriate. Copy-out single-element accessors in the Convert package (one pole at a time, one weight at a time) are deprecated in favour of batch const-reference accessors that hand back the underlying NCollection_Array directly; the package itself replaces handle-based heap storage with direct array members.

BRepGraph

BRepGraph is a graph-based representation of topology and BRep geometry, complementary to TopoDS_Shape. It is split into a public layer (BRepGraph) and an internal incidence-table layer (BRepGraphInc), with roundtrip conversion to and from TopoDS_Shape.

The public API exposes typed identifiers (BRepGraph_NodeId, BRepGraph_RefId, BRepGraph_RepId), multiple Views (TopoView, RefsView, CacheView, EditorView), bidirectional traversal (ChildExplorer, ParentExplorer, WireExplorer, RefsIterator, ReverseIterator, RelatedIterator, CacheKindIterator, LayerIterator, DefsIterator), an extensible Layer and Cache system with deferred or immediate event propagation through LayerRegistry, mutation guards (MutGuard), history tracking (History), deduplication (Deduplicate), compaction (Compact), deep copy and validation. BRepGraph_Tool is the centralized geometry access API for curves, surfaces, locations, tolerances and flags, analogous to BRep_Tool.

EditorView is the single programmatic mutation surface. It owns both structural creation (Add*, Remove*) and field-level RAII-scoped mutation (Mut*()) with automatic OwnGen and SubtreeGen propagation. Programmatic graph construction is done through BRepGraph_Builder::Add(), with BRepGraph::Clear() as the canonical rebuild boundary. Product and occurrence editing is in Editor().Occurrences() (CreateEmptyProduct, LinkProducts).

References use a typed RefId model (inline refs were removed), with an OccurrenceRef type. Node, ref and rep identifiers are 32-bit unsigned integers; history indices are size_t. Roots are accessed through RootProductIds(), which returns product roots only. Layers cover parameters (BRepGraph_LayerParam) and regularity (BRepGraph_LayerRegularity). Mesh storage is two-tier: BRepGraph_MeshCache for algorithm-derived caches, BRepGraph_MeshView for persistent definition triangulations, with cache freshness keyed on FaceDef.OwnGen. Cache writes do not mutate the model.

The package ships with a comprehensive GTest suite covering build, explore, copy, deduplicate, history, events, geometry, polygons, transforms, validation, version stamps, views, fuzzing, mutation guards, layer iterators, mesh cache, replace-vertex, scenario matrix, typed-id dispatch and the wire explorer.

Modeling Algorithms

New constructions

GeomFill_Gordon and GeomFill_GordonBuilder implement transfinite interpolation from N x M curve networks through the Boolean sum formula S = S_profiles + S_guides - S_tensor, generalizing GeomFill_Coons to arbitrary curve grids. GeomFill_GordonBuilder is a low-level kernel that accepts pre-compatible BSpline curves with known intersection parameters; it builds three intermediate surfaces (skin profiles, skin guides, tensor product) and then computes the Boolean sum, with C2-continuous periodic interpolation for closed networks. GeomFill_Gordon is the high-level wrapper: it accepts arbitrary Geom_Curve inputs, detects intersections automatically, sorts and orients the network, reparametrizes through a constrained least-squares B-spline approximation with kink preservation, applies scale-relative tolerances, detects closedness and runs in parallel through OSD_Parallel. Approx_BSplineApproxInterp is the underlying constrained-least-squares solver, which uses a KKT saddle-point system for exact interpolation constraints.

TKHelix is a new toolkit. It provides a geometric helix curve adaptor and topological builders, with a B-spline approximation algorithm for high-quality helix representation, plus a TCL command interface.

ExtremaPC is a point-to-curve extrema package. It dispatches through std::variant to specialized evaluators (ExtremaPC_Line, ExtremaPC_Circle, ExtremaPC_Ellipse, ExtremaPC_Hyperbola, ExtremaPC_BezierCurve, ExtremaPC_BSplineCurve, ExtremaPC_OffsetCurve). ExtremaPC_Curve is the aggregator. ExtremaPC_GridEvaluator provides grid-based bracketing and ExtremaPC_DistanceFunction handles root-finding refinement.

TopClass_FaceClassifier and TopClass_Classifier2d were ported from .gxx generic templates to .pxx private utilities, with BRepClass and Geom2dHatch updated as wrappers. The _0.cxx generator glue files are gone. Downstream code that included the .gxx files directly to instantiate a classifier will need to use the BRepClass or Geom2dHatch entry points.

HLRBRep algorithms replaced raw Standard_Address parameters with typed pointers, so the public signatures of HLRAlgo_PolyData, HLRBRep_Algo and the surrounding helpers carry concrete types. HLRAlgo_PolyData::Box returns Bnd_Box rather than the legacy private box type.

Performance

IntPatch_PolyhedronBVH wraps IntPatch_Polyhedron as a BVH_PrimitiveSet<double, 3> built with BVH_LinearBuilder. IntPatch_BVHTraversal does dual-tree traversal yielding candidate triangle pairs. IntPatch_InterferencePolyhedron::Interference() is built on top of these and uses O(log n) queries instead of pairwise triangle scans.

BSpline span location has a non-periodic fast path in countSpanSize() based on a next-knot boundary comparison, with span reuse in curve and surface grid loops driven by the cached span end-knot value.

BOPAlgo_PaveFiller uses const references where it previously copied four IndexedMaps in SubShapesOnIn(), with explicit allocator choices. Memory accumulation across stages is reduced. BOPDS was refactored. IntTools box calculation was optimized. Bnd_BoundSortBox was tightened.

BRepGProp for solids no longer double-counts shared subshapes with the same placement under SkipShared, and shared solids no longer cause free faces and shells to be dropped. Edge pcurve lookup composes fewer TopLoc_Location objects, and BRepGProp_Face caches the face surface and location.

BOPAlgo_Builder performs fewer redundant lookups and copies, and BOPTools_Set uses NCollection_Vector storage. Ray tracing state uses NCollection_DataMap and NCollection_Map instead of std::map and std::set.

AIS_ColoredShape::dispatchColors defers EmptyCopied() and BRep_Builder::Add() to avoid redundant shape construction; the compound is built only when required.

Bug fixes

• ChFi3d_Builder::IntersectMoreCorner no longer crashes when topology map lookups fail on shapes from prior boolean or chamfer operations because of stale TShape pointers; failure now produces IsDone() == false.
• IntAna_QuadQuadGeo adds a near-parallel criterion based on axis deviation across cylinder face height, removing false non-parallel classifications for small-height faces.
• The cylinder-cylinder tangent-along-line analytical case is detected and reroutes through implicit-implicit intersection.
• IntWalk_PWalking has a 3D-distance-based closure check that closes intersection lines that return near the starting point.
• IntCurveSurface and HLRBRep intersection share polyhedron code completely. IntAna_IntQuadQuad::NextCurve array indexing was corrected. Singularity flag mixups, swapped bounds and off-by-one indices in TKGeomAlgo were fixed. TopTrans_SurfaceTransition is instance-safe (it used static state).
• Bnd_Box::Add weight output array is fully zero-initialized.
• BRepFill_PipeShell::MakeSolid no longer crashes: IsSameOriented() iterates over face edges and selects one present in the shell's edge-to-faces map, with a Contains guard before FindFromKey(). BRepFill_PipeShell now has an option to skip building history.
• GeomFill_ConstrainedFilling and GeomFill_CoonsAlgPatch correctly use SetFunc() to install law functions and pass the right parameter into CoonsAlgPatch::Value().
• GeomFill_CorrectedFrenet no longer hangs on certain inputs.
• BRepFilletAPI_MakeFiller no longer segfaults with two curves and a rim. BRepFilletAPI_MakeFillet::Add no longer hangs. BRepFilletAPI_MakeChamfer no longer crashes. Chamfer and fillet no longer crash when approaching an ellipse. BRepOffsetAPI_MakePipeShell no longer crashes. BRepBuilderAPI_GTransform no longer crashes on face stretch.
• Boolean fuse no longer segfaults on lofts. The simplifying fuse infinite loop was eliminated. Memory consumption in BOPAlgo_PaveFiller_6 was reduced.
• ShapeAnalysis_Curve no longer reports a projected-point versus parameter mismatch.
• BRepBndLib::AddOptimal handles faces without PCurves and the void bounding box case. Periodic BSpline curve bounding works with the corrected tolerance.
• BRepLib::BuildCurve3d does not perform an unused loop iteration.
• Curve concatenation uses actual endpoints. Partial torus creation handles inverted V range. BRep_Tool::CurveOnSurface is invoked with a one-based index. ComputePolesIndexes() no longer returns out-of-bounds indices.
• The thickness operation no longer regresses on circle-to-polygon lofts.
• ShapeUpgrade_UnifySameDomain no longer crashes; the inverted-revolved-shape regression on STEP import was fixed.
• fixshape no longer crashes on null surfaces.
• BRepFilletAPI_MakeFillet periodic-curve handling in ChFi3d_Builder was improved.
• BSplCLib_Reverse no longer reads out of range. BRepFill_PipeShell::MakeSolid retains its history option flag.
• IntPatch_Polyhedron triangle-pair container is NCollection_DynamicArray.
• Degenerate thin solids are no longer misclassified: FillSameDomainFaces uses the parent solid rather than the shell when mapping same-domain faces.
• BRepBlend_AppFuncRoot tolerance settings were corrected after the BSplCLib interpolation change.

Shape Healing

Replacement chains in ShapeBuild_ReShape could form cycles when the same TShape was rewritten through differently oriented entry points. ValueLeaf() resolves the chain leaf, Replace() rejects cycles, and DFS in-flight guards stop recursive descent loops. Wire-fixing cost is no longer quadratic on shapes with shared subshapes, and progress cancellation checkpoints are observed across ShapeFix.

ShapeUpgrade_FaceDivide::Perform() lazily initializes a ShapeBuild_ReShape context if none is supplied. ShapeConstruct_ProjectCurveOnSurface::insertAdditionalPointOrAdjust no longer assigns into a smaller buffer; it uses move assignment instead.

ShapeUpgrade_UnifySameDomain removes edges from the working map during face unification. ShapeFix_GlueEdgesWithPCurves validation was corrected. Unstable PCurve processing in shape healing was fixed. Wire fixing reuses surface analysis results. PCurve projection is faster. FixFaceOrientation is faster.

Mesh

Mesh algorithms register through BRepMesh_DiscretAlgoFactory, an abstract base with a static registry. BRepMesh_IncrementalMeshFactory registers the FastDiscret algorithm; XBRepMesh_Factory registers the XBRepMesh extended algorithm. The legacy DISCRETPLUGIN/DISCRETALGO symbol-based plugin system, BRepMesh_PluginMacro.hxx, BRepMesh_PluginEntryType.hxx, BRepMesh_FactoryError.hxx and the Draw commands mpsetfunctionname, mpgetfunctionname and mperror were removed. TKMesh and TKXMesh can be loaded together without symbol collisions.

BRepMesh_BaseMeshAlgo registers used nodes in registerNode() instead of initDataStructure(), so nodes inserted later in the algorithm are tracked consistently. Stack overflow during meshing and a STEP-file import crash visualizing boundary curves were fixed. BRepMesh_Delaun correctly handles point-in-polygon for CCW polygons.

Visualization

Grids

V3d_RectangularGrid and V3d_CircularGrid are unified onto a single shader path. The grid is infinite by default with sub-pixel line antialiasing through fwidth-based AA. Per-axis Nyquist fade prevents bright haze at grazing angles when the grid period drops below one pixel. Lines mode uses max() of per-axis alphas; points mode uses the product so only intersections light up. A background mode pins gl_FragDepth to 1.0 - 1e-5. Bounded clipping (rectangular SizeX/SizeY, circular Radius, optional arc range) uses smoothstep so the clip edge is a single screen pixel transition rather than a binary staircase. Stable-reference rebasing keeps fract() arguments bounded at far world offsets without changing the visible line pattern. The privileged plane is an arbitrary gp_Ax3 exposed through uPlaneOrigin/uPlaneX/uPlaneY/uPlaneN. Pan and rotate compensation in background mode is derived from the view-matrix delta, so no Graphic3d_Camera API change was needed. The shader path requires GL 3.2 or GLES 3.0.

The classical CPU grid backend is preserved alongside the shader path for legacy GL profiles and embedded targets. Snap math is unchanged. The two backends are mutually exclusive per view; activating one erases the other on the same view.

Aspect_GridParams is a POD carrying shader-only appearance knobs. Aspect_RectangularGrid exposes SizeX, SizeY, ZOffset. Aspect_CircularGrid exposes Radius, ZOffset, AngleStart, AngleEnd, IsArc(). Graphic3d_CView::GridDisplay(Aspect_GridParams, gp_Ax3) and GridErase() are virtuals with no-op defaults. OpenGl_ShaderManager::BindGridProgram() lazily creates and caches the program. The renderer binds a dedicated VAO and saves and restores program, depth state, blend state and depth-clamp. vgrid accepts -type {rect|circ|gpu}, -color R G B, -scale N, -lineThickness T, -background {0|1}, -drawAxis {0|1}, -viewAdaptive {0|1}, alongside the legacy -origin, -step, -rotAngle, -zoffset, -size, -radius, -mode flags.

Selection

AIS_TextLabel and PrsDim_Dimension use Graphic3d_Group::SetFlippingOptions so labels stay upright relative to the camera. The selection pipeline is now flip-aware. Graphic3d_Flipper is the CPU-side analogue of OpenGl_Flipper and reproduces the render-time flip matrix, which is self-inverse because each branch is a 180-degree rotation involution. Graphic3d_CStructure exposes HasGroupFlipping() and SetGroupFlipping(). Select3D_SensitiveEntity carries the same flipping metadata. SelectMgr_SensitiveEntitySet tracks myNbEntityWithFlipping. SelectMgr_SelectableObjectSet::appropriateSubset() routes flipped presentations into the 3D-persistent BVH subset. BVHBuilderAdaptorPersistent merges flipping and transform persistence in a single pass. SelectMgr_ViewerSelector::traverseObject() folds the flip matrix into the inverse-transform chain before frustum overlap testing.

SelectMgr_TriangularFrustumSet::OverlapsBox now does a real inside test: it probes every frustum for any overlap, then projects the eight AABB corners onto the near plane and applies a ray-cast inside test against the polyline loop. OverlapsPoint is no longer a stub returning false. Strict-inclusion polyline selection works for Select3D_SensitiveTriangle, SensitivePoly, SensitiveTriangulation, SensitivePrimitiveArray, MeshVS_CommonSensitiveEntity and MeshVS_SensitiveQuad.

Select3D_SensitivePrimitiveArray::GetVertex(index) returns the three vertex positions of the indexed triangle as std::array<NCollection_Vec3<float>, 3>. Sub-owner bounding boxes apply the SelectMgr_SelectableObject transformation.

The mouse-click handler distinguishes double clicks reliably; selection schemes can use HandleMouseClick. AIS_ViewCube no longer moves unexpectedly. AIS_Shape recomputes its bounding box correctly.

AIS_ColorScale and shading

The two triangles of each color-scale rectangle now share the same diagonal with consistent CCW orientation. The rectangle helper uses Graphic3d_ArrayOfPrimitives::AddQuadTriangleEdges() so face culling does not drop vertices.

The implicit optimization that forced UNLIT shading when material had no reflection properties was removed; this used to break PBR materials, interior color and texture modulation. Code that relies on UNLIT shading must call SetShadingModel(Graphic3d_TypeOfShadingModel_Unlit) explicitly.

Graphic3d_ShaderProgram accepts mat3 and mat4 uniforms (PushVariableMat3, PushVariableMat4). The Draw vshader command exposes -vec2, -vec3, -vec4, -mat3, -mat4. Detection of full cylinder and cone parameters was improved. OpenGl_View AABB transformation was corrected.

IVtk

IVtkTools_ShapePicker and IVtkOCC_ShapePickerAlgo expose SetPixelTolerance(int) and PixelTolerance(). The dead SetTolerance(float)/GetTolerance() API and the unused stored tolerance value were removed. IVtkOCC_ViewerSelector no longer caches tolerance fields locally, and myTolerances.Tolerance() is applied on every Pick().

FFmpeg, image, immediate-mode

The FFmpeg compatibility layer was extended and the video recorder updated. Image_AlienPixMap writes valid PPM image comments. Immediate-mode rendering methods on AIS_InteractiveContext are deprecated. Graphic3d_Aspects::PolygonOffsets documentation was clarified. The font manager has a flag to suppress unsupported-font warnings.

Data Exchange

DE_Wrapper, plugins

DE_Wrapper has stream-based read and write methods for STEP, STL, VRML and the other supported formats, with validation utilities. The plugin system was reorganized: configuration nodes have Register/UnRegister methods, and DE_MultiPluginHolder allows multiple registrations. The DE Wrapper no longer mixes file and system coordinate systems for mesh formats.

STEP

Concurrent operation: STEP read and write are safe under the contract of one reader or writer per thread (default parameter set). Two libmalloc double-free crashes under concurrent STEPControl_Writer::Transfer and intermittent crashes in concurrent STEP readers were fixed.

STEP type recognition uses std::string_view end to end, with a custom hasher in RWStepAP214. StepData_ReadWriteModule::StepType() returns const std::string_view& instead of TCollection_AsciiString. StepData_StepReaderData and the entity graph evaluator are faster. The Direction entity has a smaller memory footprint.

Export side: STEP General Attributes are exported as property_definition entities. Coordinate system connection points are imported. Duplicate-entity removal cuts file size by approximately 20% on average. Control directives are preserved on export. Scaling transformations are applied on export. The dot in AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF was removed. Vis Material support covers SurfaceStyleReflectanceAmbientDiffuse and SurfaceStyleReflectanceAmbientDiffuseSpecular. Tessellation export ignores unit factors. Datum extraction no longer crashes.

Import side: STEP imports report missing GDT values correctly. STEPCAF dimension-value conversion recognizes StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI and StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI (PMI measurement scaling between m and mm is handled). XSControl_Reader::OneShape() skips null shapes when building the result compound. CheckSRRReversesNAUO no longer segfaults: null checks were added around SDR->Definition().PropertyDefinition() for both the rep1/pd1 and rep2/pd2 paths. STEP import no longer crashes on empty lists. STEPCAFControl_Reader no longer hangs.

STEPControl_Writer::SetShapeFixParameters has a convenience overload.

IGES read is not safe under concurrent use; serialize calls.

IGES

IGES export preserves model curves in the transfer cache. The schema name and short-label loop in IGESData_IGESWriter::DirPart were corrected.

GLTF

GLTF import handles non-uniform scaling. Edges are saved when Merge Faces is enabled. Line types export as LINE_STRIP. The JSON parser supports streams for lines and points. Indices parsing during array processing was corrected.

OBJ, VRML, XCAF

RWObj_Reader handles facets with empty normals. XCAFDoc_Editor::RescaleGeometry rescales the translation of root references. VrmlData_Node macros use nullptr instead of 0L. STEP geometrical and visual enumeration conversion utilities are available.

Application Framework

OCAF-related packages were cleaned up. TNaming_NamedShape returns null early when TNaming_UsedShapes is missing. Inspector and ExpToCas live in their own repositories. TPrsStd_ConstraintTools was tightened. TObj_Persistence macro casts use static_cast<const TObj_Persistence*>(nullptr).

Documentation

The user-facing documentation was rewritten for 8.0.0: GitHub-native workflow, vcpkg build instructions, the C++17 baseline, and a complete upgrade guide. Obsolete pages for Mantis, Gitolite, Inspector and DFBrowser were removed. Code examples were aligned with OCCT conventions and modern macros and types (occ::handle, nullptr, M_PI), and many incorrect API and enum references in snippets were corrected. Method documentation in HLRBRep_HLRToShape and Graphic3d_Aspects::PolygonOffsets was filled in. TCollection documentation was updated.

---

Acknowledgments

We thank all contributors who helped make this release possible through their code contributions, bug reports, and testing.

New Contributors

• @sshutina made their first contribution in Add flag for font mgr to avoid error message #392
• @jboissy-mediasofts made their first contribution in Refactor mouse click handling logic for improved double-click detection #385
• @Xargas made their first contribution in fixed: Degenerated curves were not handled by Arrange function. With … #396
• @iosdevzone made their first contribution in Configuration - Fix link errors on macOS when not building using vcpkg #609
• @sander-adamson-cloudnc made their first contribution in 0033894: fix null surface crash in unifysamedom #624
• @petrasvestartas made their first contribution in 0033896 - STEP Write - General Attributes #634
• @Rodrigo-BLyra made their first contribution in Visualization - Fix method to transform AABB #735
• @gsegon made their first contribution in Coding - Add RTTI support for TFunction_Logbook class #741
• @Andrej730 made their first contribution in Foundation classes - remove pragma lib comment in OSD_Host.cxx #902
• @VladislavVitalievichRomashko made their first contribution in Foundation Classes, math_FunctionRoot - Constructor exception #1121
• @Lokestrom made their first contribution in Modeling, Hyperbola - Fixing over constraining direction errors #1100
• @Harishmcw made their first contribution in Testing - Add Windows ARM64 build and test support #1135
• @winzlebee made their first contribution in Visualization - Include shape transformation in sub-owner bounding box calculation #1164
• @soilSpoon made their first contribution in Configuration - Only link TKIVtk against RenderingGL2PSOpenGL2 when VTK provides it #1214
• @gsdali made their first contribution in Modeling - Fix null context crash in ShapeUpgrade_FaceDivide::Perform() #1203
• @jijinbei made their first contribution in Coding - Apply modernize-* and readability-* clang-tidy checks #1207

Full Changelog: V7_9_0...V8_0_0

---

This discussion was created from the release V8_0_0.

[dpasukhi]

A small note from my side: this release took us 13.5 months instead of the 11 we originally planned. 7.9.0 went out at the end of February, and 8.0.0 is landing now. The extra month was not free, but I hope it shows in the product. More time on the RC cycle meant more bugs caught before tagging, and more room to land things like the BRepGraph foundation, the evaluation rework across Geom*, and the math/solver cleanup without rushing them.

Please keep the ideas and issue reports coming. A large share of what made it into 8.0.0 started as a community report or a discussion thread. We are continuing to improving large pieces of the codebase, and that feedback is what tells us which corners are actually load-bearing for real users.

Looking ahead, 8.1.0 is shaping up around three main themes:

• Visualization restructuring: an overall rework of the visualization layer.
• Data Exchange rework: a deep architectural rework of the Data Exchange layer.
• Deeper BRepGraph integration into modeling: using the graph as a first-class representation inside modeling algorithms, not just alongside TopoDS_Shape.

Thanks again to everyone who contributed code, filed bugs, tested RCs, or just told us when something felt wrong. See you in 8.1.0.

[ssg-aero]

Congratulation! I am looking forward to trying the new Gordon surfaces.