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.