What's been cooking — October 2026

39 merged PRs across 4 repos

October was mostly a Falcata month, with a long run of CUDA perf wins paired with an even longer run of "how did this ever work?" bug fixes. Elsewhere in GPU land, cuml, cuvs, and raft got a scattering of leak plugs, precision cleanups, and one Java OpenMP footgun defused.

MechaFauna-ai/Falcata

The CUDA training path got noticeably faster this month without changing a single trained model. A tiled 4-bit compact fill landed in Falcata#47 (+10.2% on numerai-deep), followed by a warp-per-task quantized split finder in Falcata#48 (+6–23% on training) and a batched quantized histogram construct loop in Falcata#49 that issues 8 rows per thread before hitting shared atomics (+26–46%). All three are bit-identical, which is the kind of free lunch you want.

The bug backlog is where things get interesting. Falcata#77 discovered that NaN split gains were never mapped to -inf because the code tested gain == NAN, which is of course always false; a NaN "best" split could therefore stick around indefinitely. Falcata#84 found ShuffleReduceMinGlobal seeding its running minimum with 0, so any all-positive input reduced to zero. Falcata#82 fixed SortForPair writing the sorted suffix back at the wrong offset whenever start > 0. Falcata#81 caught leaf-partitioned quantized LeafSplits::Init indexing the packed int16 gradient/hessian word by loop position instead of through data_indices_, which quietly summed the wrong rows on bagged roots. Falcata#75 straightened out a CSR single-row predict call that was passing predict_type and iteration args in the wrong order.

CUDA kernels had their own share. Falcata#79 fixed a rank_xendcg zeroing loop that walked one element too far and clobbered the next query's first item; Falcata#131 fixed the same objective crashing on queries of 65536+ items because the per-thread max was stored as uint16_t. Falcata#83 promoted multiclass objective row/class offsets to 64-bit before they overflowed. Falcata#132 fixed columns with more bins than one shared histogram corrupting the previous partition. Falcata#135 made the categorical extra_trees threshold draw deterministic by doing it on one thread instead of racing warps.

The I/O layer was equally generous with bugs. Falcata#78 fixed a data race in multi-column .init parsing where a single std::vector<std::string> was shared across OpenMP threads. Falcata#88 stopped label-only libsvm rows from being counted as feature indices (hello, phantom columns). Falcata#85 noticed that FLC_DatasetGetSubset was bounding its query-copy loop by the subset's own zero query count, so no query was ever matched. Falcata#80 rounded up three loader bugs around sparse rows and multi-chunk two_round. Falcata#86 fixed binary model/pickle truncating categorical split indices above 255 because the dtype was sized only from the numeric threshold dictionary. And Falcata#87 rewrote the weighted cross_entropy_lambda gradient path, which was going negative or NaN for large |score| because z = 1 - exp(-w*hhat) rounded to 1.

Build and dev experience also got attention. Falcata#134 split the two slowest CUDA translation units (118 s and 58 s) so nvcc can actually parallelize them. Falcata#133 wired up ccache when it's present. Falcata#139 moved the FeatureHistogram numerical dispatch out of the header so every pool consumer stops re-instantiating the whole template. Falcata#140 fixed an explicit CMAKE_CUDA_ARCHITECTURES=75 being silently ignored when it matched nvcc's default (the README's own example, naturally), and Falcata#141 documented what dev builds actually target.

The test suite got a sweep too: Falcata#89 fixed tests that passed no matter what the code did (one of which was hiding a real dask._train bug), Falcata#136 made test collection independent of the string-hash seed, Falcata#137 restored the registered logger after the logger tests stopped squatting on it, and Falcata#138 documented running the CUDA suite under pytest-xdist. Rounding it out, Falcata#76 stopped import falcata from failing when falcata.sklearn couldn't import, Falcata#74 cleaned up misspelled #undefs and duplicate dump blocks, Falcata#145 deleted 219 lines of code nothing calls, and Falcata#73 added a README link to the blog post.

NVIDIA/cuml

A small but useful trio. cuml#8565 warp-aggregates the attractive-force atomics in both the Barnes-Hut and FFT t-SNE kernels, which were doing one atomicAdd per non-zero into attr_forces[row]. cuml#8758 plugs a device memory leak in DBSCAN's RBC path, where the cuVS ball_cover::index was new'd and never deleted on every fit. And cuml#8757 fixes a batch of docstring and comment typos, mostly inherited from sibling classes via copy-paste.

NVIDIA/cuvs

cuvs#2531 is a one-character fix with real teeth: the expanded L2 distance in nn-descent was multiplying by a 2.0 double literal and promoting the whole expression to fp64. cuvs#2505 drops a duplicate bitset/bitmap→CSR conversion that was happening twice per search on the SDDMM brute-force path. On the Java side, cuvs#2844 scopes OpenMP thread counts to each build (libgomp keeps nthreads-var per thread, so a global omp_set_num_threads was leaking across callers) and fixes builds that get called without index parameters.

NVIDIA/raft

raft#3133 hunts down three device-code sites that were silently promoting float kernels to fp64 arithmetic. On consumer GPUs that runs at 1/64 the fp32 rate, so each promotion dominated the kernel it hid in. Found by just compiling a lot of things and looking at what shouldn't be there.

That's the month. Mostly: fewer FP64 promotions, fewer NaN-shaped landmines, and faster builds to compile the fixes with.