Skip to content

Releases

treeweave v0.0.7

Choose a tag to compare

@github-actions github-actions released this 16 Nov 06:16

[0.0.7] - 2026-11-13

Added

  • TolKind::RelativePointwise, an opt-in tolerance kind that accepts a panel
    when |p - f| <= tol * |f| at every sample. A zero reference sample
    converges iff its error is 0, so the kind fails near zeros of f.
    Available in the C API and every binding as
    TREEWEAVE_RELATIVE_POINTWISE / "relative_pointwise".
  • options::filename (C: treeweave_opts.filename, filename in every
    binding) names a plain-text fit file. When the file exists and its header
    matches the treeweave and polyfit versions, the value type, dimensions,
    degree, domain, tol and options, the fit loads from the file and does not
    call f. Otherwise the fit runs and writes the file. The file keeps only
    the coefficient digits that tol needs: for relative_max and the
    absolute kinds a load moves the fit by at most tol * S / 10 (S is
    max|f|, or 1 for absolute kinds). The other kinds keep every digit and
    load bit for bit. The file does not identify f.
  • fit accepts an array domain with a scalar result, for example
    fit([](std::array<double, 2> x) { return x[0] * x[1]; }, a, b, tol).
    Before, the result had to be a one-element array.
  • The Fortran binding gains a generic treeweave_eval over six specifics that
    dispatch on the rank and kind of x: a scalar or a rank-1 x returns the
    point or batch result directly; a rank-2 x(input_dim, n) returns
    y(output_dim, n). The old single-point subroutine is renamed to
    treeweave_eval_c; the f32 twin keeps the name treeweavef_eval (see
    ### Changed).
  • guru::LaneQuantizer<T, Arch>: the SIMD lane-level twin of
    Function::leaf_id for a single-subtree fit with a live leaf table.
    in_domain(x) and ids(x) classify one xsimd::batch into the lane mask
    and the lane-matched integer ids, identical lane for lane to leaf_id, so
    a multi-regime caller folds its combined key with xsimd::select in
    registers. Pure xsimd, no ISA gate; tests/test_guru.cpp pins the parity on
    f64, f64 1D->4D and f32 fits including the OOD, endpoint and non-finite
    lanes.
  • <treeweave/guru.hpp> (treeweave::guru): the guru interface (after
    FFTW's) — the batch pipeline as public stages with caller-owned scratch and
    no per-call allocation. counting_sort/histogram/exclusive_scan/
    scatter (counting sort over caller-produced u32 keys, span-based),
    gather (the rank-driven writeback, prefetch owned), for_each_run
    (fn(id, begin, count), the same callback shape as for_each_sorted_run),
    eval_leaf_aos/eval_leaf_soa (per-leaf SIMD eval through the polyfit
    kernels), fill_out_of_domain (the out-of-domain bucket's NaN writeback),
    and for_each_sorted_run (the sorted-run walk). Function gains
    out_of_domain_id(), the sentinel id for points the fit cannot evaluate.
    Function::sorted's kernel dispatch runs on the canonical
    for_each_sorted_run_1d walk and the same fill_out_of_domain definition
    the guru entry points forward to — one implementation for library and
    callers.
  • check_rung_symbols_selftest, a positive control for the gate above,
    registered wherever the gate itself is. It builds fixture objects with the
    project's own C compiler and asserts the gate exits 1 on differing bodies
    and on the local-reference stub, 0 on identical bodies and on disjoint
    symbol sets, and 2 on misuse. A gate that has only ever passed cannot be
    distinguished from a gate that cannot fail; this one had never been proven
    to fail, and the control found the defect above on its first run.

Changed

  • The default leaf degree in 1D is 6 coefficients, down from 7. 2D and 3D
    keep 7. This applies to C++ fit without <N> (the default is now
    fit<0>), the C ABI and every binding. A 1D single-point evaluation is 6
    FMAs: 5 Horner steps and 1 for the domain map. A sweep of degrees 4 to 16
    over 6 functions at tol = 1e-10 measured, for degree 7 over degree 6,
    1.05x to 1.07x single-point latency on x86-64-v3, x86-64-v4 and Apple M2.
    Batch time is equal on x86-64-v4 and M2, and 4% lower with degree 7 on
    x86-64-v3. Degree 5 is faster still, but needs more than 3x the memory of
    degree 6 on cos over [1, 1001) at tol = 1e-13. A 1D fit file
    written with degree 7 refits once.
  • A zero-filled treeweave_opts (memset 0, or = {0}) and a value-initialised
    treeweave::options{} are the defaults. A zero numeric field means auto, and
    detail::init_defaults sets its value. This applies to C++, the C ABI and
    every binding. Code that sets these fields to a number must change:
    • tol_kind values are renumbered: RELATIVE_MAX 0, ABSOLUTE_MAX 1,
      RELATIVE_L2 2, ABSOLUTE_L2 3, RELATIVE_POINTWISE 4, RELATIVE_TAIL 5,
      ABSOLUTE_TAIL 6. Code that uses the enum names needs no change.
    • max_depth = 0 is auto (50). A negative value fits the root panel only,
      which was 0 before.
    • max_memory_mib = 0 is auto (the dimension-scaled budget). A negative
      value disables the cap, which was 0 before; -1 was auto.
  • The MATLAB/Octave 'tol_kind' option takes the names in the docs
    ('absolute_max', ...). Before, it took only the number, and a name failed.
  • The auto memory budget is 4 / 32 / 256 MiB for
    1D / 2D / 3D, up from 4 / 8 / 16. With the budget check fixed (see
    ### Fixed), 16 smooth test functions at the default degrees need up to
    1.4 / 14.2 / 176 MiB at tol = 1e-13.
  • The docs no longer say that the C ABI picks the degree per CPU. It never
    did: the degree is baked in.
  • treeweave_opts has a new last field, filename. Code that fills the
    struct with treeweave_default_opts or designated initializers needs no
    change. The struct size changes, so a rebuild against the new header is
    necessary.
  • fit takes const options & instead of options by value.
  • polyfit is pinned to v0.0.6. It adds poly_eval::fromCoeffs, and
    poly_eval::horner takes an xsimd::batch argument. xsimd comes from the
    DiamonDinoia/xsimd fork at 6351cd2, which adds the vector double -> int64
    fast_cast and the u32 -> i64 widening gather that LaneQuantizer::ids
    relies on.
  • The nanobind build requirement now excludes only 3.0.0
    (nanobind>=2.0,!=3.0.0) instead of the full 3.0 line. nanobind 3.0.1 has
    the clang-cl fix (wjakob/nanobind#1421), so 3.0.1 and later are allowed.
  • TolKind::RelativeMax, the default, now accepts a panel when
    max|p - f| <= tol * max|f| on its sample grid, where max|f| is the
    largest |f| sampled so far over the whole domain, instead of pointwise
    relative. Functions with zeros now fit; leaf counts change.

Fixed

  • No filename, None, NULL and an empty string all mean no file: no
    load, no save and no error. When a fit-file save stops with an error, no
    temporary file stays behind.
  • The fit checks the memory budget after the last tree level too. Before, the
    leaves of that level were never counted, so a fit could end with up to 8x
    max_memory_mib in 3D. exp(-|x|^2) on [-1, 1]^3 at tol = 1e-12
    finished with 88 MiB under the 16 MiB auto budget.
  • A fit callback can return any shape that the output-dimension probe
    accepts. Python 0.0.6 raised std::bad_cast on a shape-(1,) array for a
    scalar output, on a list or tuple for a vector output, and on a (k, 1)
    array. Julia failed on a 1-element vector for a scalar output. MATLAB and
    Octave read an int32, logical or single return as raw double bits;
    they now convert it to double. A return with the wrong number of values
    now raises "callback returned N values, expected M" in Python, Julia,
    MATLAB, Octave and JavaScript. Before, MATLAB, Octave and JavaScript
    silently used the first values.
  • The WASM build has C++ exceptions on (-fwasm-exceptions). Before, an
    error in the fit, for example a memory budget or a malformed fit file,
    aborted the module instead of throwing the error message in JavaScript.
  • TolKind::RelativeMax, AbsoluteMax, RelativeL2, AbsoluteL2, and
    RelativePointwise convergence checks now gate on the open 8-point
    midpoint grid and, independently, on the closed 9-point grid per axis
    (both endpoints and the 7 interior cell vertices). The check now also
    samples cell vertices and panel boundaries; a feature narrower than the
    grid spacing that falls between all sampled points can still pass, in any
    dimension. Fixes silently wrong fits on such functions, in 1D and ND, at
    (8^d + 9^d) / 8^d the convergence-check f-evals (2.13x for d=1, 2.42x for
    d=3). Tail kinds (RelativeTail, AbsoluteTail) do not run these sample
    checks; the low-degree RelativeTail fallback (NCOEFFS <= 2) uses
    RelativeMax on the same grids.
  • Function::leaf_id's descent-mode OOD gate used negative logic, letting
    NaN fall through to get_linear_bin(NaN) (a UB narrowing conversion plus
    an out-of-bounds subtree index; segfaults observed). The descent gate is now
    the same positive logic the table path has always used, matching the
    documented sentinel semantics.
  • check_rung_symbols.sh's local-reference rule was inert for the shape it
    exists to catch. A call or jump to a TU-local symbol in the same section
    carries no relocation, and the rule read targets only from relocation
    entries, while the normalization that makes the byte-compare robust
    (<...> collapsed to <>) erased the callee name from the instruction
    stream. Two rungs whose shared function was byte-identical but called
    different private helpers therefore compared equal and passed. The rule now
    also records the symbolic target objdump prints for a direct branch.
  • --no-tests=error on every filtered ctest -R call in the workflow tree.
    bf53bf7 added it to the three multiarch legs only, leaving nine calls
    across seven files that would turn into silent passes on a test rename.
  • TolKind::RelativeTail now scales the tail estimate by the largest panel
    coefficient; previously it behaved as `Absol...
Read more

treeweave stable

Choose a tag to compare

@DiamonDinoia DiamonDinoia released this 06 Oct 21:22

Rolling release tracking the newest tagged treeweave release (issue #50). Assets are the v release files renamed to treeweave-stable-*. Pin a version with a vX.Y.Z tag instead.

treeweave v0.0.6

Choose a tag to compare

@github-actions github-actions released this 28 Aug 13:30

[0.0.6] - 2026-08-28

Changed

  • Windows ships multi-arch. The wheel, the C ABI tarball and the node prebuild
    all built single-arch, so Windows ran the SSE2 baseline while every other
    platform dispatched by ISA at runtime. Only the wheel recorded a reason: the
    multi-arch C ABI static-linked into the extension faulted with an illegal
    instruction inside treeweave_fit at every level, because the ISA rungs
    shared symbols and the linker kept one arbitrary copy.
  • Every ISA rung of a multi-arch Windows build gets private symbol names
    (.github/scripts/rename_rung_symbols.sh, run per rung from
    cmake/treeweave_c_dispatch.cmake). COFF has no visibility control: both
    cl.exe and clang-cl emit every inline function, template instantiation, RTTI
    record, EH descriptor and float-pool entry as an external COMDAT, so the same
    header compiled at four /arch: levels defines the same symbol four times
    with four different instruction streams, and which copy the linker keeps
    depends on link order. The rung's copies are renamed with llvm-objcopy --redefine-syms, leaving only the make_kernels_for<Arch, …> factory
    callable from the baseline TUs, so each rung reaches its own code. ELF needs
    none of this, where the rungs already build with hidden visibility.
    -fvisibility=hidden has no effect on COFF. clang-cl was never clean either:
    it defines 14 to 39 external symbols per rung, against cl.exe's 3379 to 3487,
    and passed the gate only because none of its duplicates happened to diverge.
    That is a property of the optimizer's inlining decisions, not a guarantee any
    compiler or dependency bump preserves.
  • The rename does not localize. llvm-objcopy supports only --redefine-sym
    on COFF, and localizing is the wrong tool on ELF anyway: it leaves the
    section in its COMDAT group, the linker still discards the group, and the
    local reference then points into a discarded section. GNU ld rejects that;
    mold accepts it, so the breakage would appear on only some linkers. Renaming
    keeps the symbol external, so no group is merged away.
  • TREEWEAVE_C_MULTIARCH under cl.exe is supported again, so Windows keeps
    compiling with the MSVC ABI's own toolset. Build time was the old objection
    and it no longer holds. A multi-arch Windows configure now requires llvm-nm
    and llvm-objcopy on PATH and fails at configure time without them, rather
    than producing an artifact whose rungs silently share code.
  • ci.yml gates the multi-arch Windows build under both cl.exe and clang-cl
    (multiarch-windows): configure, build, check_rung_symbols, then the C ABI
    suite once per rung so the throwing paths cross a renamed rung boundary.
    Neither toolset was gated in this configuration before, which is how the
    collision survived a release. Every filtered ctest call in that leg passes
    --no-tests=error, since ctest exits 0 when a -R regex selects nothing
    and a renamed test would otherwise reduce the gate to a silent pass.
  • The polyfit pin moves to v0.0.5, which drops dead code (referenceHorner,
    a run_portable_benchmark overload, getAlignment and countr_zero) and
    force-inlines the horner_impl compile-time-path lambda for consistency with
    the rest of that function family.
  • The nanobind build requirement excludes the 3.0 line
    (nanobind>=2.0,!=3.0.*) instead of capping below 3.0, so a later 3.x is
    allowed once its slot aliases are clang-cl safe. nanobind 3.0 aliases its
    Python slots as inline constexpr ret (*name) args = &target; with target a
    CPython API function, which is __declspec(dllimport) under the MSVC ABI,
    and the address of a dllimport function is not a constant expression, so
    clang-cl rejects the header and only the Windows wheel breaks.
  • Every Windows release artifact compiles with cl.exe instead of clang-cl: the
    wheel, the C ABI tarball, the node prebuild, the MEX, the Julia leg and the
    install smoke test. MSVC is the toolchain Windows consumers already have, so
    the shipped binary matches what they compile against. clang-cl stayed the
    default only because the multi-arch fan-out used to need it; the per-rung
    symbol rename made both toolsets sound, and ci.yml gates both. LLVM stays
    installed on those runners because the rename runs llvm-nm and
    llvm-objcopy. cl.exe defines no [[gnu::flatten]] equivalent, so the hot
    eval methods lose recursive force-inlining there; an interleaved A/B of that
    attribute under clang-19 put every benchmark inside the resolution floor of
    an unchanged control arm, so the cost is unresolved rather than measured.

Added

  • treeweave_active_arch() and treeweave_arch_available() report which ISA
    rung the library runs and whether the host can run a named rung. The name is
    recorded inside the rung's own object, where xsimd::best_arch is that
    rung's arch, so a reported name the caller did not select proves the linker
    resolved one rung's kernels to another rung's code. check_rung_symbols
    catches that at link time; these two catch it at run time.
  • test_c_abi fails when TREEWEAVE_FORCE_ARCH names a rung the host reports
    available and treeweave_active_arch() returns a different one, and fails
    when it names no rung at all. force_select ignores an unavailable rung and
    falls back to default dispatch, so the per-rung CI loops used to print
    RUNG_OK for a rung they never ran.

treeweave v0.0.5

Choose a tag to compare

@github-actions github-actions released this 27 Aug 16:22

[0.0.5] - 2026-08-27

Changed

  • Comments across the headers, benchmarks and tests no longer carry
    benchmark receipts or development history ("Phase N", "previously", cycle
    latencies, speedup ratios); that evidence belongs in the logbook, not in
    the source. (void)x discards in the C ABI eval shims became
    [[maybe_unused]] parameters, and two Python forwarding shims that only
    called fit_impl were replaced by binding fit_impl directly.
  • Multi-arch C ABI restructured: only the hot loops compile per ISA rung.
    One new TU (src/capi/kernels_arch.cpp) compiles once per rung and
    exports one Arch-mangled kernel-table factory per (dtype, dim, output)
    shape; the factory TUs — fit, tree build, pipeline glue, exception
    plumbing — compile once at the family baseline and reach the selected
    rung through KernelSet function pointers. This removes the latent ISA
    leak (every rung previously emitted weak copies of global-scope
    instantiations with rung-specific code, and the linker kept one arbitrary
    copy) and cuts the multi-arch TU count from 6 per rung to 1.
    Single-arch builds keep the header-only InlineKernels policy: kernels
    inline into the pipeline, zero indirection, unchanged code.
  • Factory-TU granularity follows the build mode: one external
    make_eval_one<T, IN, OUT> symbol per shape, generated by CMake from one
    template. Single-arch builds (kernels inlined into the pipelines) split
    into 18 one-pipeline TUs, cutting the slowest TU — the bound on every
    parallel build — by a third; multi-arch factory TUs are KernelSet-thin and
    header-dominated, so the three output_dim pipelines keep sharing one TU
    per (dtype, dim).
  • The fit degree is a single constant (chosen_degree = 7,
    arch_degree_table.hpp); the per-arch degree table is gone.

Added

  • check_rung_symbols ctest (multi-arch builds): every external text symbol
    that more than one rung defines must disassemble identically in all rungs
    and reference no TU-local symbol (a shared stub jumping into a rung-local
    clone disassembles identically yet executes the keeper rung's code).
    Runs on the object files, which keep symbol tables on ELF and COFF alike,
    so it also covers Windows artifacts, where the linked DLL strips the
    symbol table and check_isa_leak.sh cannot see a leak.
  • TREEWEAVE_VERIFY_RUNGS CMake option: runs the same gate as a build step
    before treeweave_c / treeweave_c_static link. Every release pipeline
    (C-ABI tarballs, wheels, node prebuilds, MEX bundles) sets it on its
    multiarch legs: those trees build with tests off, so the ctest never
    registered there, the Windows MEX had no rung gate at all, and the
    cibuildwheel build tree is unreachable from workflow steps.
  • C ABI tests for the throwing error paths: max_depth exceeded and memory
    budget exceeded must fail the fit and set treeweave_last_error().

Fixed

  • Node::fit bound the freshly appended evaluator by value
    (auto polyfit = polyfits.emplace_back(...)), copying a whole FuncEval
    on every node of every fit. emplace_back returns a reference, so the
    tolerance checks now bind it.
  • The Julia module docstring said a dim > 1 function receives an
    NTuple{dim,T} and named the handle type Treeweave{T}. fit calls
    f(coords...), so the arguments arrive as dim scalars, and the type is
    TreeweaveFn{T}.
  • tail_error_exceeds_tol read two coefficients from a degree-1 fit, which
    holds one. ASan reports a READ of size 8 past the FuncEval for fit<1>
    with a Tail TolKind; the read is now bounded by Polyfit::NCOEFFS. The
    same change reads the coefficients through a pointer, so GCC 16 no longer
    folds this body across degrees and charges one degree's array extent to
    another object (-Werror=array-bounds under -march=native).
  • clang 23 moved -Wunused-template into -Wunused, which the warning set
    enables, so every consumer building the C ABI with clang 23 failed: the
    kernels are static templates in a header and a TU that uses one shape
    instantiates none of the others. Suppressed for clang only, since GNU has no
    such flag and rejects an unknown -Wno- once any other diagnostic fires.
  • NonConvergedPanel::depth is value-initialized by default, so a
    default-constructed panel no longer carries an indeterminate depth.
  • check_isa_leak.sh decides attributability from the symbol table instead of
    a label-count threshold: an artifact with no local text symbols is reported as
    unattributable and skipped. The rungs build with hidden visibility, so once a
    strip removes the local names objdump charges each export the instructions of
    whatever follows it, and the macOS x86_64 wheel was reported as leaking
    AVX-512 out of its module entry point. check_rung_symbols gates those trees.
  • The Static Analysis CI leg pins cppcheck 2.21 from conda-forge instead of
    taking the distribution 2.13: 2.13 and 2.17 both segfault on a generated
    dispatch TU, which pairs explicit instantiations with an
    anonymous-namespace include.

treeweave v0.0.4

Choose a tag to compare

@github-actions github-actions released this 25 Aug 22:50

[0.0.4] - 2026-08-25

Added

  • Python: treeweave.fit doubles as a decorator when the callable is omitted.
    @treeweave.fit(a, b, tol) above a def replaces the function with its
    fitted approximation, the functools.cache spelling. Every keyword option of
    the direct call applies unchanged, and the original callable stays reachable
    as __wrapped__.
  • .github/scripts/check_isa_leak.sh fails a build whose shipped artifact
    contains a symbol that no ISA level owns yet holds instructions above the
    family baseline. A level owns a symbol when the mangled name carries the
    level, or when the symbol survives once per level: GCC emits an .isra or
    .constprop clone privately in each level, and an ELF-local reference
    cannot bind outside its own object, so every level reaches its own copy.
    The check runs on the installed C ABI library and on the packaged MEX. It
    reports and skips an artifact it cannot decide: one built for a non-x86
    family, and a Windows DLL, whose COFF symbol table is empty in a linked
    image so that objdump labels every internal function with the export that
    precedes it.

Fixed

  • The Windows MATLAB MEX in v0.0.1, v0.0.2 and v0.0.3 was built without
    optimization and linked against the debug C runtime (MSVCP140D.dll,
    VCRUNTIME140_1D.dll, ucrtbased.dll). Those DLLs ship only with Visual
    Studio, so that MEX could not load on a machine without it. The assets on
    those three tags have been rebuilt and replaced. Two defects produced it:
    CMake's MSVC platform module seeds CMAKE_BUILD_TYPE_INIT with Debug, so
    the variable is never empty after project() on Windows and treeweave's
    default-to-Release guard could never fire there; and nothing in the release
    path ever loaded the MEX it packaged. The default is now decided before
    project() and holds on every platform, and an explicit
    -DCMAKE_BUILD_TYPE still wins.
  • The Python build requires nanobind>=2.0,<3. nanobind 3.0.0, released
    2026-08-22, declares its Python slot aliases as
    inline constexpr ret (*name) args = &target;. clang-cl rejects that: under
    the MSVC ABI the address of a dllimport function is not a constant
    expression. The Windows wheel builds with clang-cl, so an unpinned nanobind
    broke it three days after the 3.0 release while every other platform kept
    building.
  • The multi-arch C ABI proves that no ISA level's code reaches a CPU that
    cannot run it. TREEWEAVE_C_MULTIARCH compiles the same sources once per ISA
    level. Symbols the fan-out names carry the level in their mangled name and
    never collide.
    Symbols instantiated from headers at global scope do collide: every level
    emits the same weak name holding different code, and the linker keeps one
    arbitrary copy. Keep a copy from a higher level and it runs on every CPU that
    loads the binary, including CPUs that trap the instruction. Measured on the
    six variant translation units: 35 weak symbols per unit share a mangled name
    between the baseline and AVX-512 objects, 18 differ in code, and 17 instances
    across the six carry AVX-512 in the AVX-512 copy. One of them is
    poly_eval::detail::newtonToMonomial<7>, which is numeric work rather than
    an error path. The levels are emitted baseline-first, so a linker that keeps
    the first copy it sees keeps the baseline one. No linker promises that rule,
    so the check above decides the question on the linked artifact rather than on
    the order: of 1595 symbols in libtreeweave_c.so, the 201 that carry AVX-512
    registers all belong to a level that owns them by name.

Changed

  • The packaging job now runs test_treeweave against the staged MEX bundle on
    every platform, and refuses to package a Windows MEX that imports the debug
    CRT. matlab.yml additionally builds on windows-2022 and runs the test
    under several MATLAB releases.
  • The Windows MEX builds with clang-cl instead of cl.exe. cl.exe spends over 40
    minutes in its back end on a single dispatch translation unit at /O2, and
    the multi-arch fan-out is 24 of them, so an optimized cl.exe MEX is not
    reachable inside a CI job. clang-cl compiles the same target in 161 seconds
    and targets the same MSVC ABI, so the binaries stay interchangeable.
    Configuring the C ABI with cl.exe at anything other than Debug now prints a
    warning that names clang-cl.
  • -Werror no longer applies under clang-cl: its MSVC-like driver enables an
    -Weverything-family set (c++98-compat, pre-c++17-compat,
    unsafe-buffer-usage) that the plain clang driver leaves off. Warning
    hygiene stays enforced under -Werror by the Linux clang rows.
  • The multi-arch fan-out no longer shares a precompiled header and no longer
    enables IPO. A precompiled header is built with one target's flags; IPO
    widens what the optimizer may merge across the objects. Both exclusions are
    precautionary.

treeweave v0.0.3

Choose a tag to compare

@github-actions github-actions released this 19 Aug 01:42

Full Changelog: v0.0.2...v0.0.3

treeweave v0.0.2

Choose a tag to compare

@github-actions github-actions released this 15 Aug 05:01

[0.0.2] - 2026-08-13

Changed

  • Vendored dependency pins updated to the current releases: xsimd 14.2.0 →
    14.3.0 and POET b55580f → v0.0.1. Both are now on the same refs consumers
    are most likely to already have, so a project that already provides either
    dependency satisfies treeweave's copy instead of ending up with two
    incompatible sets of xsimd / poet targets in one build. The xsimd checkout
    is still verified against its pinned commit SHA at configure time to catch a
    moved tag.
  • Debug builds now default to -Og rather than CMake's -O0. The debug-og
    preset already did this — -O0 leaves the header-only, deeply-inlined code
    un-inlined and the compute-heavy tests slow to a crawl — but a preset-less
    -DCMAKE_BUILD_TYPE=Debug, which is what a consumer's FetchContent build
    gets, did not. The default now applies to every Debug build including
    coverage, where line attribution becomes slightly coarser wherever the
    optimizer inlines but the instrumented run stops being the slowest job in CI.
    An explicit CMAKE_CXX_FLAGS_DEBUG still takes precedence, so
    -DCMAKE_CXX_FLAGS_DEBUG='-O0 -g' restores the strictest line data.
  • Link-time optimization is now the opt-in option TREEWEAVE_ENABLE_IPO,
    default OFF, where it was on for every non-GCC compiler. The C++ API is
    header-only, so IPO changes nothing for a consumer that only includes the
    headers, and the C ABI objects feed the installed static archive as well as
    libtreeweave_c.so — IPO fills that archive with compiler IL only one
    toolchain version can link. Every binding preset turns it back on, because a
    binding ships one shared artifact and no archive; the Emscripten preset stays
    excluded, as do GCC and MSVC even when the option is ON — GCC ICEs on these
    templates and MSVC /LTCG took over an hour to link one executable. clang-cl
    still gives Windows a ThinLTO path.

treeweave v0.0.1

Choose a tag to compare

@github-actions github-actions released this 20 Jul 19:10

[0.0.1] - 2026-07-20

Fixed

  • Julia bindings Project.toml carried version = "0.0.0", which Julia's Pkg
    rejects as an invalid version (Pkg.add fails). Bumped to 0.0.1.
  • The Windows N-API prebuild now builds: the workflow fetches the node C headers
    (absent from the Windows node install) and node.lib from the node dist, and
    the addon delay-loads node.exe to resolve napi_* under MSVC (the node-gyp /
    cmake-js approach). Windows Node users get the native backend, not just the
    WASM fallback.

Added

  • Documentation now defaults to released/prebuilt install paths, with source
    builds moved to the end of each language guide for development or unreleased
    changes.
  • Added a CMake guide covering the minimal CPM/FetchContent usage, user-facing
    presets, user-facing CMake options, and targets by language.
  • Added MATLAB/Octave install docs for both mip and direct release-bundle
    curl/wget installs.
  • Added runtime ISA dispatch documentation for MSVC ABI compilers. MSVC x86
    builds use the SSE2 -> AVX -> AVX2 -> AVX-512 ladder because there is no
    /arch:SSE4.2.
  • Added the Practical HPC NUFFTs talk link to the acknowledgements/background
    material.
  • Post-publish release-install.yml now verifies the published binaries on a
    full matrix: pip install treeweave from PyPI (linux/macOS/windows × py3.9 +
    py3.12), each per-platform C-ABI release tarball via find_package
    (linux-x86_64/-aarch64, macOS-arm64, windows-x64), and a new
    npm install @flatironinstitute/treeweave job (WASM-only, all three OSes).
  • One-liner installs surfaced in the README and install guide: pip install treeweave, npm install @flatironinstitute/treeweave, release tarball
    curl/wget commands, Julia Pkg.add, and
    CPMAddPackage("gh:DiamonDinoia/treeweave@stable") for C++.
  • conda/recipe/meta.yaml + conda/README.md: a conda-forge recipe prepared for
    submission to conda-forge/staged-recipes (manual follow-up).
  • The raw treeweave.wasm + treeweave.mjs loader are attached to each GitHub
    Release, so a web page can fetch them from a stable URL without npm.
  • The npm package now ships prebuilt native N-API binaries (Linux x64/arm64,
    macOS arm64/x64, Windows x64), resolved by node-gyp-build, so Node consumers
    get the fast native backend automatically; the bundled WASM build remains the
    browser backend and the fallback for any unmatched host. Built by the new
    reusable _build-node-prebuilds.yml (Linux in manylinux_2_28, same as wheels)
    and bundled into the package by release.yml's build-js job.

Deferred (roadmap — not yet implemented)

  • conda-forge: submit conda/recipe to conda-forge/staged-recipes; then
    conda install -c conda-forge treeweave is the one-liner (add a conda badge).
  • Julia General registry: register so Pkg.add("Treeweave") works (needs a
    tagged release + Registrator/JLL, or keep the bespoke build.jl).
  • vcpkg / Conan: C/C++ ports.
  • MATLAB File Exchange / Add-On packaging.
  • Fortran / Octave remain build-from-source (Octave has no stable MEX ABI).

treeweave unstable (main)

Pre-release

Choose a tag to compare

@github-actions github-actions released this 02 Jul 15:54
85aafa4

Rolling C++ headers bundle built from the latest green main CI. Unstable — for a pinned/stable build use a tagged release (see docs/install.rst).

treeweave v0.0.0

Choose a tag to compare

@github-actions github-actions released this 16 Jun 16:17

[0.0.0] - 2026-06-11

  • Initial public release of treeweave: an adaptive polynomial-tree function
    approximator with a header-only C++ API (treeweave::treeweave), a relocatable
    C ABI (libtreeweave_c, find_package(treeweave)), and Python, Julia,
    Fortran, MATLAB/Octave, and JavaScript/TypeScript wrappers.
  • Prebuilt distributions: Python wheels on PyPI (x86-64 wheels dispatch
    SSE4.2 / AVX2 / AVX-512 at runtime; aarch64 + Apple-silicon wheels), and
    relocatable C-ABI tarballs attached to the GitHub Release for every supported
    OS/arch. The Julia package downloads the matching prebuilt libtreeweave_c
    from the Release on Pkg.add.