Falcata 1.0.3

Patch release. pip install falcata now resolves to 1.0.3.

Multi-GPU works from the prebuilt wheel

num_gpu > 1 used to require building from source with USE_NCCL=ON, and a wheel install silently fell back to a single GPU. (--config-settings has no effect on a wheel install — pip only passes it to source builds, so the flag looked like it worked and didn't.)

NCCL is now loaded at runtime rather than linked at build time, so the stock wheel can do multi-GPU:

pip install 'falcata[multigpu]'    # pulls nvidia-nccl-cu12

then pass num_gpu=2. Without NCCL present you get a warning naming the fix instead of a silent single-GPU fallback. The base install is unchanged in size and gains no hard dependency.

What two GPUs buy you, measured on 2×T4 with Numerai v5.3 (30k trees, depth 10, 1024 leaves; hours extrapolated from 300-round runs):

	1×T4	2×T4
train split (2.75M × 3555)	3.0 h	2.8 h
full data (6.86M × 3555)	out of memory	9.2 h

Two effects, and which one you get depends on the card. Rows are split across ranks, so VRAM pools: datasets that don't fit on one card train on two. Speed is the smaller story — histogram building parallelizes but the all-reduce doesn't, so multi-GPU wins only where compute dominates communication. On slower cards like the T4 it does. On fast cards (A100/H100/5090) a single GPU is still the faster choice, and 2 GPUs land at roughly 0.65× of one; use multi-GPU there for capacity, not throughput.

Thanks to the user who reported this from a Kaggle 2×T4 notebook.

Fixed

• gpu_device_id no longer reports its own default as invalid. The default is -1, documented as "the default device", but multi-GPU startup warned Invalid gpu_device_id = -1 before doing the right thing anyway. -1 now selects the master silently; an explicitly chosen device that is out of range still warns.

Falcata 1.0.2

Patch release. pip install falcata now resolves to 1.0.2.

Fixed

• Source builds on Kaggle/Colab images — the build died with Target "CUDA::cuda_driver" not found on images that ship the driver's libcuda.so.1 in a nonstandard path with no toolkit stubs. The build now locates the driver library directly. (Reported from a Kaggle P100 notebook — thanks!)
• CUDA 13 toolkits — CUDA 13 removed compilation for pre-sm_75 GPUs; the build now fails at configure time with the remedy spelled out (use a CUDA 12.x toolkit) instead of dying cryptically mid-compile, and no longer silently targets sm_75 on older GPUs via nvcc 13's injected default.
• Saved models are device-portable — an automatically chosen device is no longer written into the model file, and save/load round-trips are bit-identical again.
• The "sparse features not supported" warning no longer fires on dense data; it appears (as an Info about memory) only when a column would actually have used sparse storage.

Changed

• device_type unset now means auto: a CUDA build with a usable GPU trains on it (one Info line says so); no GPU or an unsupported one falls back to CPU. Pass device_type explicitly to pin either choice.
• The prebuilt wheel now covers the P100 — the Pascal slot ships sm_60 cubins (which every Pascal card runs) instead of sm_61, at no size cost. Wheel coverage: sm_60 through sm_120.

Falcata 1.0.0

Falcata is a CUDA-native gradient boosted decision tree library. First stable release.

2.4× faster than XGBoost. 14× faster than LightGBM. 4.7× faster than CatBoost. Geometric mean over seven deep workloads (the gbm-bench suite plus Numerai v5.3), every engine training on the same GPU, at matched-or-better held-out quality — and falcata is the fastest library on every single one of them. On the flagship workload (numerai-deep: 6.8M×3555, 30k trees) it finishes in 12.4 min where XGBoost needs 1 h 57 m at equal correlation. Full method, per-dataset numbers, time-to-quality curves and the competitor failure ledger: docs/performance.md.

Not a simple fork

Falcata began as a LightGBM fork and keeps the familiar train() API and model format. Underneath, the GPU path was rebuilt, not patched — 441 commits beyond upstream, +27k/−4k lines in the core, 18k of them in the CUDA learner:

• Hybrid level-batched leaf-wise growth — whole levels of sibling pairs scored and applied in one launch each instead of one split at a time, with leaf-wise-identical trees.
• CUDA-graph level loops — the per-level launch sequence is captured once and replayed by a device-side controller, removing host round-trips from the inner loop.
• NVRTC runtime JIT — construct kernels specialized at runtime to the actual data shape, self-tested against the ahead-of-time kernel and promoted only if bit-identical.
• GPU-native dataset construction — dense binning, row-data build and EFB pre-checking on the device; CuPy and __cuda_array_interface__ inputs ingested with no host round-trip.
• Per-tree compact column view — with feature_fraction < 1, only sampled columns are materialized for histogram construction (up to ~3.4× end-to-end on wide data).
• Quantized training, two ways — stochastic 4-bin packing for speed, fixedpoint for near-lossless; both bit-reproducible across GPU models (the same seed trains the bit-identical model on sm_89 and sm_120).
• An execution planner — shape-conditional kernel choices resolved once (cuda_plan=auto), each individually overridable.
• GPU inference via NVIDIA FIL — Booster.predict() transparently runs on cuML's Forest Inference Library; device arrays stay on-device end to end.
• Infrastructure upstream doesn't have — a cross-engine benchmark harness, nightly model-file fuzzing, cross-GPU bit-reproducibility locks, and frozen model fixtures every future release must reproduce. Every optimization proved bit-identical to its reference or discarded.

Install

pip install falcata

On Linux x86_64 that's a prebuilt CUDA wheel — no compilation, no CUDA toolkit — covering sm_61 through sm_120 (GTX 10xx → RTX 50xx / B200). Everywhere else pip builds from source and compiles only for the GPUs actually present.

Compatibility

• Loads LightGBM model files; saves both the LightGBM text format and FALB, a compact binary format (~10× smaller than model text). Model files written today are a compatibility promise: every future release is gated on loading them and reproducing their predictions exactly.
• Imports XGBoost and CatBoost models (falcata.importers) with exact prediction parity — unsupported constructs refuse loudly instead of converting approximately.
• The Python API is the familiar lgb.train-style surface: import falcata as flc; flc.train(params, dataset).

Scope

Python + Linux x86_64 wheels in this release; source builds elsewhere. The library targets NVIDIA GPUs (CUDA 11+); a CPU fallback exists but is not the point.

Contributing

Falcata is built to be hacked on by agents. Point your coding agent at the repo and tell it to benchmark on your hardware (benchmarks/), hunt for bugs (tests/gates/ — fuzzers and gates will tell it when it found one), or optimize a kernel: every optimization has to prove itself bit-identical to the reference or win on a measured benchmark, so an agent can verify its own work before you ever look at it. Send the PR — small and focused lands fastest, and review here is quick. Bug reports with a repro are just as welcome.

Falcata is a fork of LightGBM (MIT); see NOTICE for attribution.