Repository navigation
Releases
Releases · DiamonDinoia/treeweave
treeweave v0.0.7
[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 off.
Available in the C API and every binding as
TREEWEAVE_RELATIVE_POINTWISE/"relative_pointwise".options::filename(C:treeweave_opts.filename,filenamein 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,toland options, the fit loads from the file and does not
callf. Otherwise the fit runs and writes the file. The file keeps only
the coefficient digits thattolneeds: forrelative_maxand the
absolute kinds a load moves the fit by at mosttol * 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 identifyf.fitaccepts 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_evalover six specifics that
dispatch on the rank and kind ofx: a scalar or a rank-1xreturns the
point or batch result directly; a rank-2x(input_dim, n)returns
y(output_dim, n). The old single-point subroutine is renamed to
treeweave_eval_c; the f32 twin keeps the nametreeweavef_eval(see
### Changed). guru::LaneQuantizer<T, Arch>: the SIMD lane-level twin of
Function::leaf_idfor a single-subtree fit with a live leaf table.
in_domain(x)andids(x)classify onexsimd::batchinto the lane mask
and the lane-matched integer ids, identical lane for lane toleaf_id, so
a multi-regime caller folds its combined key withxsimd::selectin
registers. Pure xsimd, no ISA gate;tests/test_guru.cpppins 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(therank-driven writeback, prefetch owned),for_each_run
(fn(id, begin, count), the same callback shape asfor_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),
andfor_each_sorted_run(the sorted-run walk).Functiongains
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_1dwalk and the samefill_out_of_domaindefinition
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++fitwithout<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 attol = 1e-10measured, 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 oncosover[1, 1001)attol = 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_defaultssets its value. This applies to C++, the C ABI and
every binding. Code that sets these fields to a number must change:tol_kindvalues are renumbered:RELATIVE_MAX0,ABSOLUTE_MAX1,
RELATIVE_L22,ABSOLUTE_L23,RELATIVE_POINTWISE4,RELATIVE_TAIL5,
ABSOLUTE_TAIL6. Code that uses the enum names needs no change.max_depth = 0is auto (50). A negative value fits the root panel only,
which was0before.max_memory_mib = 0is auto (the dimension-scaled budget). A negative
value disables the cap, which was0before;-1was 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 attol = 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_optshas a new last field,filename. Code that fills the
struct withtreeweave_default_optsor designated initializers needs no
change. The struct size changes, so a rebuild against the new header is
necessary.fittakesconst options &instead ofoptionsby value.- polyfit is pinned to v0.0.6. It adds
poly_eval::fromCoeffs, and
poly_eval::hornertakes anxsimd::batchargument. xsimd comes from the
DiamonDinoia/xsimdfork at6351cd2, which adds the vector double -> int64
fast_castand the u32 -> i64 wideninggatherthatLaneQuantizer::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, wheremax|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,NULLand 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_mibin 3D.exp(-|x|^2)on[-1, 1]^3attol = 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 raisedstd::bad_caston 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 anint32,logicalorsinglereturn as rawdoublebits;
they now convert it todouble. 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
RelativePointwiseconvergence 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-degreeRelativeTailfallback (NCOEFFS <= 2) uses
RelativeMaxon the same grids.Function::leaf_id's descent-mode OOD gate used negative logic, letting
NaNfall through toget_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=erroron every filteredctest -Rcall in the workflow tree.
bf53bf7added it to the three multiarch legs only, leaving nine calls
across seven files that would turn into silent passes on a test rename.TolKind::RelativeTailnow scales the tail estimate by the largest panel
coefficient; previously it behaved as `Absol...
treeweave stable
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
[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 insidetreeweave_fitat 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 withllvm-objcopy --redefine-syms, leaving only themake_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=hiddenhas 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-objcopysupports 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_MULTIARCHunder 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 requiresllvm-nm
andllvm-objcopyon PATH and fails at configure time without them, rather
than producing an artifact whose rungs silently share code.ci.ymlgates 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 filteredctestcall in that leg passes
--no-tests=error, sincectestexits 0 when a-Rregex 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,
arun_portable_benchmarkoverload,getAlignmentandcountr_zero) and
force-inlines thehorner_implcompile-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 asinline constexpr ret (*name) args = ⌖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, andci.ymlgates both. LLVM stays
installed on those runners because the rename runsllvm-nmand
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()andtreeweave_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, wherexsimd::best_archis 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_abifails whenTREEWEAVE_FORCE_ARCHnames a rung the host reports
available andtreeweave_active_arch()returns a different one, and fails
when it names no rung at all.force_selectignores an unavailable rung and
falls back to default dispatch, so the per-rung CI loops used to print
RUNG_OKfor a rung they never ran.
treeweave v0.0.5
[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)xdiscards in the C ABI eval shims became
[[maybe_unused]]parameters, and two Python forwarding shims that only
calledfit_implwere replaced by bindingfit_impldirectly. - 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 throughKernelSetfunction 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-onlyInlineKernelspolicy: 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_symbolsctest (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 andcheck_isa_leak.shcannot see a leak.TREEWEAVE_VERIFY_RUNGSCMake option: runs the same gate as a build step
beforetreeweave_c/treeweave_c_staticlink. 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_depthexceeded and memory
budget exceeded must fail the fit and settreeweave_last_error().
Fixed
Node::fitbound the freshly appended evaluator by value
(auto polyfit = polyfits.emplace_back(...)), copying a wholeFuncEval
on every node of every fit.emplace_backreturns a reference, so the
tolerance checks now bind it.- The Julia module docstring said a
dim > 1function receives an
NTuple{dim,T}and named the handle typeTreeweave{T}.fitcalls
f(coords...), so the arguments arrive asdimscalars, and the type is
TreeweaveFn{T}. tail_error_exceeds_tolread two coefficients from a degree-1 fit, which
holds one. ASan reports aREAD of size 8past theFuncEvalforfit<1>
with a TailTolKind; the read is now bounded byPolyfit::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-boundsunder-march=native).- clang 23 moved
-Wunused-templateinto-Wunused, which the warning set
enables, so every consumer building the C ABI with clang 23 failed: the
kernels arestatictemplates 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::depthis value-initialized by default, so a
default-constructed panel no longer carries an indeterminate depth.check_isa_leak.shdecides 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_symbolsgates 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
[0.0.4] - 2026-08-25
Added
- Python:
treeweave.fitdoubles as a decorator when the callable is omitted.
@treeweave.fit(a, b, tol)above adefreplaces the function with its
fitted approximation, thefunctools.cachespelling. Every keyword option of
the direct call applies unchanged, and the original callable stays reachable
as__wrapped__. .github/scripts/check_isa_leak.shfails 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.israor
.constpropclone 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 seedsCMAKE_BUILD_TYPE_INITwithDebug, so
the variable is never empty afterproject()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_TYPEstill 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 = ⌖. clang-cl rejects that: under
the MSVC ABI the address of adllimportfunction 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_MULTIARCHcompiles 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 inlibtreeweave_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_treeweaveagainst the staged MEX bundle on
every platform, and refuses to package a Windows MEX that imports the debug
CRT.matlab.ymladditionally builds onwindows-2022and 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 thanDebugnow prints a
warning that names clang-cl. -Werrorno 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-Werrorby 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
Full Changelog: v0.0.2...v0.0.3
treeweave v0.0.2
[0.0.2] - 2026-08-13
Changed
- Vendored dependency pins updated to the current releases: xsimd 14.2.0 →
14.3.0 and POETb55580f→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 ofxsimd/poettargets in one build. The xsimd checkout
is still verified against its pinned commit SHA at configure time to catch a
moved tag. Debugbuilds now default to-Ograther than CMake's-O0. Thedebug-og
preset already did this —-O0leaves 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'sFetchContentbuild
gets, did not. The default now applies to everyDebugbuild including
coverage, where line attribution becomes slightly coarser wherever the
optimizer inlines but the instrumented run stops being the slowest job in CI.
An explicitCMAKE_CXX_FLAGS_DEBUGstill 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,
defaultOFF, 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 isON— GCC ICEs on these
templates and MSVC/LTCGtook over an hour to link one executable. clang-cl
still gives Windows a ThinLTO path.
treeweave v0.0.1
[0.0.1] - 2026-07-20
Fixed
- Julia bindings
Project.tomlcarriedversion = "0.0.0", which Julia's Pkg
rejects as an invalid version (Pkg.addfails). Bumped to0.0.1. - The Windows N-API prebuild now builds: the workflow fetches the node C headers
(absent from the Windows node install) andnode.libfrom the node dist, and
the addon delay-loadsnode.exeto resolvenapi_*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
mipand direct release-bundle
curl/wgetinstalls. - Added runtime ISA dispatch documentation for MSVC ABI compilers. MSVC x86
builds use theSSE2 -> AVX -> AVX2 -> AVX-512ladder because there is no
/arch:SSE4.2. - Added the Practical HPC NUFFTs talk link to the acknowledgements/background
material. - Post-publish
release-install.ymlnow verifies the published binaries on a
full matrix:pip install treeweavefrom PyPI (linux/macOS/windows × py3.9 +
py3.12), each per-platform C-ABI release tarball viafind_package
(linux-x86_64/-aarch64, macOS-arm64, windows-x64), and a new
npm install @flatironinstitute/treeweavejob (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/wgetcommands, JuliaPkg.add, and
CPMAddPackage("gh:DiamonDinoia/treeweave@stable")for C++. conda/recipe/meta.yaml+conda/README.md: a conda-forge recipe prepared for
submission toconda-forge/staged-recipes(manual follow-up).- The raw
treeweave.wasm+treeweave.mjsloader 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 bynode-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 byrelease.yml'sbuild-jsjob.
Deferred (roadmap — not yet implemented)
- conda-forge: submit
conda/recipetoconda-forge/staged-recipes; then
conda install -c conda-forge treeweaveis 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 bespokebuild.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)
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
[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 prebuiltlibtreeweave_c
from the Release onPkg.add.