# LightGBM

> Source: https://aiwiki.ai/wiki/lightgbm
> Updated: 2026-10-28
> Fact-checked: 2026-11-02
> Categories: Algorithms, Machine Learning, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "LightGBM." aiwiki.ai, 28 Oct 2026. https://aiwiki.ai/wiki/lightgbm
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**LightGBM** (short for *Light Gradient-Boosting Machine*) is a free and open-source [gradient boosting](https://aiwiki.ai/wiki/gradient_boosting) framework that trains ensembles of [decision trees](https://aiwiki.ai/wiki/decision_tree) on tabular data, originally developed at [Microsoft Research](https://aiwiki.ai/wiki/microsoft_research) by Guolin Ke and colleagues and first released on [GitHub](https://aiwiki.ai/wiki/github) in October 2016. Its defining contributions, the *Gradient-based One-Side Sampling* (GOSS) and *Exclusive Feature Bundling* (EFB) techniques introduced in the 2017 [NeurIPS](https://aiwiki.ai/wiki/neurips) paper *LightGBM: A Highly Efficient Gradient Boosting Decision Tree*, let it, in the authors' words, "speed up the training process of conventional GBDT by up to over 20 times while achieving almost the same accuracy" [1]. The framework is designed for distributed and high-performance training, and is widely used for [classification](https://aiwiki.ai/wiki/classification), [regression](https://aiwiki.ai/wiki/regression), ranking, and many other [supervised learning](https://aiwiki.ai/wiki/supervised_learning) tasks. LightGBM is one of the three dominant gradient boosting libraries in modern practice, alongside [XGBoost](https://aiwiki.ai/wiki/xgboost) and [CatBoost](https://aiwiki.ai/wiki/catboost), and it is consistently one of the most-used algorithms in [Kaggle](https://aiwiki.ai/wiki/kaggle) competitions and in production [machine learning](https://aiwiki.ai/wiki/machine_learning) systems for tabular data.

<figure class="w-56">
<img src="/images/site-2026-10-28-lightgbm-logo-c68b5e1adb70-tile.png" alt="LightGBM logo" width="480" height="159" />
<figcaption>LightGBM logo, from the official website <a href="https://lightgbm.readthedocs.io/">lightgbm.readthedocs.io</a>. Trademark of its owner.</figcaption>
</figure>

LightGBM differs from earlier gradient boosting implementations through four interlocking design choices: a *histogram-based* split-finding algorithm that bins [continuous feature](https://aiwiki.ai/wiki/continuous_feature)s into a small number of integer buckets, a *[leaf](https://aiwiki.ai/wiki/leaf)-wise* (best-first) tree growth strategy that grows whichever leaf will most reduce the loss, GOSS, which subsamples training rows by gradient magnitude, and EFB, which fuses sparse, mutually exclusive features into denser bundles. Together these techniques cut training time by roughly an order of magnitude relative to pre-2017 implementations of [gradient boosted decision trees (GBT)](https://aiwiki.ai/wiki/gradient_boosted_decision_trees_gbt) at comparable accuracy. The original NeurIPS paper reports per-iteration speedups of 21x, 6x, 1.6x, 14x, and 13x over a histogram-based LightGBM baseline without GOSS and EFB on the Allstate, Flight Delay, Microsoft LETOR, KDD CUP 2010, and KDD CUP 2012 datasets respectively, with no measurable loss in test accuracy [1].

## What is LightGBM used for?

LightGBM is a general-purpose supervised learning library for *tabular* (structured, row-and-column) data. It is applied to ranking (search relevance, recommendation reranking), binary and multiclass classification (fraud detection, churn, click-through-rate prediction), and regression (demand forecasting, pricing, risk scoring). It is not used directly on raw images, audio, or free text, which are the domain of [deep neural network](https://aiwiki.ai/wiki/deep_neural_network)s, although LightGBM is frequently trained on engineered features derived from those modalities. Its combination of fast training, low memory use, native [categorical](https://aiwiki.ai/wiki/categorical_data) handling, and competitive accuracy makes it a default first model for tabular problems and a workhorse in Kaggle competition pipelines.

## History

LightGBM began as an internal Microsoft Research Asia project around 2015, motivated by the limitations of existing GBDT implementations on the very large click-through-rate, search ranking, and [advertising](https://aiwiki.ai/wiki/advertising) datasets that [Microsoft](https://aiwiki.ai/wiki/microsoft) was running in production. The lead author, Guolin Ke, was at the time a researcher at Microsoft Research Asia working with Tie-Yan Liu's group on machine learning for search and recommendation. The first public release on GitHub was made in October 2016, initially under the [microsoft/LightGBM](https://github.com/microsoft/LightGBM) repository as part of Microsoft's *Distributed Machine Learning Toolkit* (DMTK) umbrella project [2].

Key early milestones:

- **October 2016:** First public commits on GitHub.
- **December 2016:** Native categorical feature support added (no [one-hot encoding](https://aiwiki.ai/wiki/one-hot_encoding) required).
- **December 2016:** First Python package beta release.
- **January 2017:** First R package beta release.
- **April 2017:** First tagged release (v1) on GitHub.
- **December 2017:** *LightGBM: A Highly Efficient Gradient Boosting Decision Tree* by Ke et al. presented at the 31st Conference on Neural Information Processing Systems (NIPS 2017, later renamed NeurIPS), published in *Advances in Neural Information Processing Systems 30*, pages 3146-3154 [1].

The paper formalized the GOSS and EFB algorithms and provided the first peer-reviewed benchmarks against XGBoost. It has since been cited tens of thousands of times and is one of the most cited applied machine learning papers of the late 2010s. The project subsequently grew well beyond its DMTK origin and became one of Microsoft's most popular open source projects. In March 2026 it was transferred from `microsoft/LightGBM` to a community-governed `lightgbm-org/LightGBM` organization, after Microsoft's Open Source Conduct Team told the maintainers it was considering archiving `microsoft/LightGBM` and offered them the chance to move the repository first; it remains MIT-licensed, with Microsoft still one of the copyright holders and continues under the same core maintainers, including the project's creator [9].

## Algorithmic Innovations

LightGBM combines four core ideas. None of them was, strictly speaking, invented for LightGBM, but the engineering combination is what gives the library its characteristic speed-vs-accuracy profile. The paper frames the central problem as follows: in conventional GBDT, "for each feature, they need to scan all the data instances to estimate the [information gain](https://aiwiki.ai/wiki/information_gain) of all possible split points, which is very time consuming," so both GOSS and EFB attack that scan by shrinking either the number of rows or the number of features [1].

### Histogram-based Split Finding

Like pre-sorted GBDT implementations, LightGBM looks for the best split point on each feature at each node. Unlike the classical pre-sorted algorithm, it first bins each continuous feature into a fixed number of integer buckets (controlled by `max_bin`, default 255). Histograms of gradients and Hessians are then accumulated per bin per leaf. Finding the best split becomes an O(#bins) scan rather than an O(#data) scan, and the histograms can be built in O(#data) total per level. The histograms also use far less memory than per-row sorted indices, which is one of the reasons LightGBM has substantially lower memory footprints than pre-sorted XGBoost. A subtler but important optimization is *histogram subtraction*: LightGBM builds histograms only for the child leaf with fewer data points and derives its sibling's histogram by subtracting it from the parent's histogram, roughly halving the work at each split [3].

### Leaf-wise (Best-first) Tree Growth

Most earlier GBDT implementations grow trees *level-wise* (also called *depth-wise*): every leaf at the current depth is split before moving on to the next depth. LightGBM instead grows trees *leaf-wise*: at every step, it picks whichever leaf in the entire tree will yield the largest loss reduction when split, and grows only that leaf. The official documentation states the underlying guarantee directly: "Holding #leaf fixed, leaf-wise algorithms tend to achieve lower loss than level-wise algorithms" [3]. The downside is a propensity to overfit on small datasets, since leaf-wise growth can produce very deep, unbalanced trees. LightGBM mitigates this with the `max_depth`, `num_leaves`, and `min_data_in_leaf` parameters, which together cap tree complexity [3].

### Gradient-based One-Side Sampling (GOSS)

GOSS is the first of the two novel techniques introduced in the LightGBM paper. The intuition is that data points with large gradients (in absolute value) carry more information about where the model is currently [underfitting](https://aiwiki.ai/wiki/underfitting) than points with small gradients. Rather than discard the small-gradient points entirely, GOSS retains the top *a* fraction of points (by gradient magnitude) and randomly subsamples *b* fraction of the remaining points, then upweights those random samples by `(1 - a) / b` so that the data distribution remains approximately unbiased. The paper proves that "since the data instances with larger gradients play a more important role in the computation of information gain, GOSS can obtain quite accurate estimation of the information gain with a much smaller data size" [1]. In the paper's own experiments the sampling rates were set to `a = 0.05`, `b = 0.05` for the Allstate, KDD10, and KDD12 datasets and `a = 0.1`, `b = 0.1` for Flight Delay and LETOR, and the authors report that GOSS alone delivers nearly a 2x speedup while remaining more accurate than ordinary Stochastic Gradient Boosting at the same sampling ratio [1].

### Exclusive Feature Bundling (EFB)

EFB targets *high-dimensional sparse* feature spaces, the kind that arises after one-hot encoding categorical variables in click logs or text data. The observation is that in such data, many features are *mutually exclusive*: they almost never take nonzero values on the same row. EFB greedily groups such features into *bundles*, mapping each bundle to a single new feature whose values are computed by offsetting each member feature's values into a unique subrange, which reduces the complexity of histogram building from O(#data x #feature) to O(#data x #bundle) [1]. The paper proves that "finding the optimal bundling of exclusive features is NP-hard, but a greedy algorithm can achieve quite good approximation ratio," reducing it to a graph-coloring problem [1]. LightGBM therefore uses a graph-coloring heuristic that allows a small *conflict ratio* (the fraction of rows on which two bundled features are both nonzero). EFB reduces feature count, and therefore histogram-construction time, by roughly the bundling factor, often with negligible loss in accuracy [1].

### Native Categorical Feature Handling

LightGBM was one of the first major GBDT libraries to support categorical features without one-hot encoding. When a feature is declared categorical, LightGBM uses an algorithm based on Fisher (1958) to find the optimal partition of categories into two subsets at each split. Internally, it sorts the histogram of categories by `sum_gradient / sum_hessian` and then walks down the sorted order, which gives O(k log k) split finding rather than the O(2^k) of brute-force category partitioning [4]. This typically produces better trees than one-hot encoding, especially for high-cardinality categories such as user IDs, ZIP codes, or product SKUs [4].

## Architecture and Supported Tasks

LightGBM is implemented in C++ for performance, with thin language bindings for Python, R, C, and an Intel-maintained daal4py inference interface. Trees are stored compactly as integer-bin split conditions. The library supports the boosting modes below (`boosting`, alias `boosting_type`); since v4.0.0 GOSS is selected through the separate `data_sample_strategy` parameter rather than as a boosting type [12]:

| boosting_type | Algorithm | Notes |
|---|---|---|
| `gbdt` | Standard [gradient boosting](https://aiwiki.ai/wiki/gradient_boosting) (default) | Highest accuracy in most benchmarks. |
| `dart` | Dropouts meet Multiple Additive Regression Trees | Adds dropout-style regularization to the boosting ensemble. |
| `goss` (legacy) | Gradient-based One-Side Sampling, now set via `data_sample_strategy=goss` | Faster training; small accuracy hit. |
| `rf` | [Random Forest](https://aiwiki.ai/wiki/random_forest) mode | Bagged trees instead of boosted. |

[Objective function](https://aiwiki.ai/wiki/objective_function)s cover the standard supervised tasks:

- *Regression*: `regression` (L2), `regression_l1`, `huber`, `fair`, `poisson`, `quantile`, `mape`, `gamma`, `tweedie`.
- *[Binary classification](https://aiwiki.ai/wiki/binary_classification)*: `binary` with logistic loss.
- *Multiclass classification*: `multiclass` ([softmax](https://aiwiki.ai/wiki/softmax)), `multiclassova` (one-vs-all).
- *[Cross-entropy](https://aiwiki.ai/wiki/cross-entropy)*: `cross_entropy`, `cross_entropy_lambda`.
- *Ranking*: `lambdarank`, `rank_xendcg`.

Custom objectives can be supplied as Python callables returning gradient and Hessian arrays.

## Performance and Benchmarks

The original NeurIPS 2017 paper benchmarked LightGBM against XGBoost on five public datasets, listed below with the row and feature counts reported in the paper [1]:

| Dataset | Rows | Features | Task | Metric |
|---|---|---|---|---|
| Allstate | 12M | 4,228 | [Binary classification](https://aiwiki.ai/wiki/binary_classification) | AUC |
| Flight Delay | 10M | 700 | [Binary classification](https://aiwiki.ai/wiki/binary_classification) | AUC |
| LETOR (Microsoft LTR) | 2M | 136 | Ranking | NDCG |
| KDD CUP 2010 | 19M | 29M | [Binary classification](https://aiwiki.ai/wiki/binary_classification) | AUC |
| KDD CUP 2012 | 119M | 54M | [Binary classification](https://aiwiki.ai/wiki/binary_classification) | AUC |

All experiments ran on a Linux server with two Intel E5-2670 v3 CPUs (24 cores total) and 256GB of memory, with the thread count fixed at 16 [1]. On these datasets, LightGBM with GOSS and EFB enabled was the fastest method tested: on Allstate, for example, it averaged 0.28 seconds per training iteration versus 10.85 seconds for XGBoost's pre-sorted (`xgb_exa`) algorithm and 2.63 seconds for XGBoost's histogram (`xgb_his`) algorithm, and the paper reports up to a 9x speedup over `xgb_his` where the latter could run, while achieving almost the same test accuracy as the baselines [1]. The histogram version of XGBoost ran out of memory on both KDD CUP datasets, whereas LightGBM completed them, which the paper attributes to histogram-based split finding and EFB lowering memory consumption [1].

Later independent benchmarks have largely confirmed the original results in the regimes the paper targeted. A 2023 benchmarking study by Florek and Zagdanski on a broad suite of tabular classification problems compared GBM, XGBoost, LightGBM and CatBoost on twelve datasets and found LightGBM to be consistently the fastest; after hyperparameter tuning it also had the best average rank, while untuned XGBoost and CatBoost performed very well out of the box [5]. The general pattern that has emerged from years of experimentation is:

- **LightGBM** wins on training speed, especially on large, sparse, high-dimensional data.
- **XGBoost** is often the strongest *single-shot* accuracy on small to medium dense datasets, and has the most mature distributed and DMatrix-based deployment story.
- **CatBoost** wins on raw categorical handling (without preprocessing) and tends to be the most robust to default [hyperparameter](https://aiwiki.ai/wiki/hyperparameter)s.

### How does LightGBM differ from XGBoost and CatBoost?

The table below summarizes the rough comparison reported across multiple benchmark studies:

| Property | [LightGBM](https://aiwiki.ai/wiki/lightgbm) | [XGBoost](https://aiwiki.ai/wiki/xgboost) | [CatBoost](https://aiwiki.ai/wiki/catboost) |
|---|---|---|---|
| Training speed (large data) | Fastest | Medium | Fast |
| Memory footprint | Lowest | Medium-High | Medium |
| Default-hyperparameter accuracy | Good | Good | Best |
| Categorical features (native) | Yes (integer-coded) | Yes (since v1.5) [11] | Yes (ordered target encoding) |
| Missing value handling | Yes | Yes | Yes |
| GPU training | Yes (OpenCL + [CUDA](https://aiwiki.ai/wiki/cuda)) | Yes (CUDA) | Yes (CUDA) |
| [Distributed training](https://aiwiki.ai/wiki/distributed_training) | Yes (Dask, MPI, Spark via SynapseML) | Yes (Dask, Spark via XGBoost4J-Spark) | Yes (Spark) |
| Trees grown | Leaf-wise | Level-wise (also leaf-wise option) | Symmetric (oblivious) |
| First public release | 2016 | 2014 | 2017 |
| License | MIT | Apache 2.0 | Apache 2.0 |

No single library dominates on every benchmark, and choice of framework is usually a function of dataset size, sparsity, categorical cardinality, and deployment constraints. In practice, many teams test all three and pick whichever performs best on their [validation set](https://aiwiki.ai/wiki/validation_set).

## Hyperparameters

LightGBM exposes more than a hundred parameters, but only about a dozen are routinely tuned in practice. The official tuning guide recommends adjusting `num_leaves`, `min_data_in_leaf`, and `max_depth` to control tree complexity, and `learning_rate` together with `num_iterations` to control the boosting trajectory [3].

| Parameter | Default | Purpose | Typical tuning range |
|---|---|---|---|
| `num_leaves` | 31 | Max leaves per tree (the primary complexity knob in leaf-wise growth) | 15-255 |
| `max_depth` | -1 (no limit) | Cap on tree depth; useful guardrail against [overfitting](https://aiwiki.ai/wiki/overfitting) | 6-12 |
| `learning_rate` | 0.1 | Shrinkage applied to each tree's contribution | 0.01-0.3 |
| `n_estimators` / `num_iterations` | 100 | Number of boosting rounds | 100-10000 (with [early stopping](https://aiwiki.ai/wiki/early_stopping)) |
| `min_data_in_leaf` | 20 | Minimum samples per leaf; prevents tiny leaves | 5-200 |
| `feature_fraction` | 1.0 | Fraction of features sampled per tree (column subsampling) | 0.6-1.0 |
| `bagging_fraction` | 1.0 | Fraction of rows sampled per iteration | 0.6-1.0 |
| `bagging_freq` | 0 | How often to re-sample rows (0 = never) | 1-10 |
| `lambda_l1` | 0.0 | [L1 regularization](https://aiwiki.ai/wiki/l1_regularization) on leaf weights | 0-10 |
| `lambda_l2` | 0.0 | [L2 regularization](https://aiwiki.ai/wiki/l2_regularization) on leaf weights | 0-10 |
| `min_gain_to_split` | 0.0 | Minimum loss reduction to make a split | 0-1 |
| `max_bin` | 255 | Histogram bin count; lower = faster, less precise | 63-512 |
| `cat_smooth` | 10 | Smoothing applied to categorical splits | 5-100 |
| `early_stopping_round` | 0 | Stop if validation metric does not improve for N rounds | 10-100 |
| `boosting_type` | gbdt | Choice of boosting algorithm (gbdt, dart, rf; GOSS via `data_sample_strategy`) | depends on task |
| `objective` | regression / binary / multiclass | [Loss function](https://aiwiki.ai/wiki/loss_function) | task-dependent |

A typical tuning recipe is to start from defaults, fix `learning_rate` at 0.05 and `n_estimators` to a large number with [early stopping](https://aiwiki.ai/wiki/early_stopping), then sweep `num_leaves` (often jointly constrained as `num_leaves <= 2^max_depth`), `min_data_in_leaf`, and the bagging and feature fractions. [Bayesian optimization](https://aiwiki.ai/wiki/bayesian_optimization) tools such as Optuna and Hyperopt have first-class LightGBM integrations for this loop.

## Python and scikit-learn API

LightGBM ships two parallel Python APIs: a native `lightgbm.train` function operating on `lightgbm.Dataset` objects, and a [scikit-learn](https://aiwiki.ai/wiki/scikit_learn)-compatible API in the `lightgbm.sklearn` module. The scikit-learn API exposes three estimator classes:

- `LGBMClassifier`, with default objective `binary` or `multiclass` depending on the target.
- `LGBMRegressor`, with default objective `regression`.
- `LGBMRanker`, with default objective `lambdarank`.

These classes implement `fit`, `predict`, and `predict_proba` and can therefore be dropped into scikit-learn `Pipeline`, `GridSearchCV`, `RandomizedSearchCV`, and similar utilities. A minimal training example:

```python
import lightgbm as lgb
from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)

model = lgb.LGBMClassifier(
    n_estimators=2000,
    learning_rate=0.05,
    num_leaves=63,
    feature_fraction=0.9,
    bagging_fraction=0.8,
    bagging_freq=5,
)
model.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    callbacks=[lgb.early_stopping(50)],
)
preds = model.predict_proba(X_val)
```

The native `Dataset` API gives finer control over categorical features and weights. It is the API used by most of the LightGBM examples in the official documentation [6].

## Distributed and GPU Training

LightGBM was designed with [distributed training](https://aiwiki.ai/wiki/distributed_training) in mind from the start, which is one of the reasons it sits under the DMTK umbrella. The library supports three modes of distributed parallelism:

- **[Data parallelism](https://aiwiki.ai/wiki/data_parallelism)** partitions rows across workers. Each worker computes local histograms on its slice; histograms are then aggregated via an all-reduce. Best when feature count is small relative to row count.
- **Feature parallelism** partitions features across workers. Each worker finds the best local split on its features; the best global split is then chosen via communication. Best when feature count is large relative to row count.
- **Voting parallelism** combines local top-k splits across workers for very large data, reducing communication volume to O(k) per iteration. Introduced for the kind of CTR-prediction workloads that motivated the original library [7].

For practical deployment, LightGBM integrates with Dask through `lightgbm.dask`, with Apache Spark via Microsoft's *SynapseML* library, with Ray via `lightgbm-ray`, and with raw MPI for HPC environments. Distributed training is one area where LightGBM remains differentiated from its competitors: feature-parallel training and voting parallelism are first-class concepts.

GPU training is supported via OpenCL (the original GPU backend, contributed by Huan Zhang and others) and via [CUDA](https://aiwiki.ai/wiki/cuda) (added in v3.x and substantially expanded in v4.x). The OpenCL backend works on AMD, [Intel](https://aiwiki.ai/wiki/intel), and NVIDIA GPUs; the CUDA backend is faster on NVIDIA hardware, and as of v4.6 supports NVIDIA's Blackwell architecture [8][9]. The official tuning guide recommends `max_bin = 63` and single-precision arithmetic (`gpu_use_dp = false`) on GPUs, since most consumer GPUs have weak double-precision throughput. The guide's benchmarks found that GPU training can achieve impressive acceleration on large, dense datasets such as Higgs and Epsilon, and that even a budget GPU could beat a 28-core Haswell server on smaller, sparse datasets [8].

## Language Bindings and Ecosystem

LightGBM provides first-class bindings for a wide range of environments:

| Binding | Maintainer | Notes |
|---|---|---|
| C++ core | LightGBM team | The reference implementation. |
| Python (`lightgbm`) | LightGBM team | Native and [scikit-learn](https://aiwiki.ai/wiki/scikit_learn) APIs; Dask integration. |
| R (`lightgbm`) | LightGBM team | CRAN package; full feature parity for tabular tasks. |
| C API | LightGBM team | Used by all language bindings as the FFI surface. |
| Daal4py | [Intel](https://aiwiki.ai/wiki/intel) | Optimized inference path on Intel CPUs. |
| .NET (`Microsoft.ML.LightGbm`) | [Microsoft](https://aiwiki.ai/wiki/microsoft) | Part of the ML.NET package family. |
| SynapseML | [Microsoft](https://aiwiki.ai/wiki/microsoft) | Spark and Synapse Analytics integration. |
| Treelite | DMLC | Cross-platform compiled inference for LightGBM models. |
| ONNX Runtime | Community + [Microsoft](https://aiwiki.ai/wiki/microsoft) | Convert LightGBM models to ONNX for portable inference. |

This broad surface area is part of the reason LightGBM is so widely adopted in production: a model trained in Python on a workstation can be exported to ONNX or compiled with Treelite and served from a C++ inference server, an ML.NET application, or a Spark batch job without retraining.

## Industry and Competition Use

*Microsoft*. LightGBM is used internally for ranking, advertising, and CTR prediction across Bing search, Microsoft Advertising, and Microsoft 365 features that touch tabular signals. The library was originally driven by these workloads and continues to be maintained, in part, against them.

*Kaggle*. Since roughly 2017, LightGBM has been one of the two most-used algorithms on tabular Kaggle competitions, alongside XGBoost. Its combination of training speed and competitive accuracy makes it especially attractive for the rapid iteration that competition workflows require.

*Industry adoption*. LightGBM is widely deployed in industry, including at many financial services and ad-tech firms, typically for ranking, fraud detection, churn prediction, demand forecasting, and credit scoring. Its low-memory inference, support for large categorical cardinalities, and easy integration with Spark and Dask are usually cited as the reasons for adoption.

## Comparison with Other Gradient Boosting Libraries

The practical decision among LightGBM, XGBoost, and CatBoost typically comes down to data shape and operational constraints rather than absolute accuracy:

- For *very large datasets* (tens of millions of rows or more) with many features, LightGBM is usually the first choice on speed and memory grounds.
- For *small to medium dense data* (under a million rows) with no high-cardinality categoricals, XGBoost is often as fast as LightGBM and slightly more accurate at default settings.
- For datasets with many *high-cardinality categorical features* (user IDs, ZIP codes, product SKUs), CatBoost's ordered target encoding tends to outperform both LightGBM's integer-coded categorical splits and any one-hot encoding pipeline.
- For *minimal [hyperparameter tuning](https://aiwiki.ai/wiki/hyperparameter_tuning)*, CatBoost is often the most forgiving; LightGBM's leaf-wise growth requires more careful regularization to avoid [overfitting](https://aiwiki.ai/wiki/overfitting) on small data.
- For *real-time inference* with strict latency budgets, LightGBM and CatBoost both compile to compact, fast model files; XGBoost models can be served via Treelite or ONNX with similar latency.

It is common in practice to train all three and ensemble or stack them, since their errors are sufficiently uncorrelated to give a small accuracy lift even when each individual model is well-tuned.

## Version Timeline

The table below summarizes major releases. Patch versions are omitted for brevity.

| Version | Release Date | Highlights |
|---|---|---|
| Initial commits | Oct 2016 | First public release on [GitHub](https://aiwiki.ai/wiki/github) under microsoft/LightGBM. |
| Categorical features | Dec 2016 | Native integer-coded categorical splits added (no one-hot needed). |
| Python beta | Dec 2016 | First Python package release. |
| R beta | Jan 2017 | First R package release. |
| v1.0 | Apr 2017 | First tagged release (`v1`) on GitHub [9]. |
| v2.0 | May 2017 | Second major release; its release notes describe it as "a release before GPU support" [9]. |
| [NeurIPS](https://aiwiki.ai/wiki/neurips) paper | Dec 2017 | Ke et al. paper formally introduces GOSS and EFB. |
| v2.1 | Jan 2018 | Feature release in the 2.x series. |
| v2.2 | Sep 2018 | Feature release in the 2.x series. |
| v2.3 | Sep 2019 | Predefined bin thresholds, among other changes [9]. |
| v3.0 | Sep 2020 | Major release (release candidate in August 2020); Python 3.8 support; first version of the R package published on CRAN [9]. |
| v3.1 | Nov 2020 | CUDA-based GPU backend added; Python 3.5 support dropped [9]. |
| v3.2 | Mar 2021 | Initial Dask integration (`lightgbm.dask`), trees with linear models at leaves, Python 3.9 support [9]. |
| v3.3 | Oct 2021 | Dask support for evaluation sets and custom evaluation functions; deprecations ahead of v4.0 [9]. |
| v4.0 | Jul 2023 | Major release: totally rewritten [CUDA](https://aiwiki.ai/wiki/cuda) implementation, OpenCL-enabled Linux wheels, Python 3.10 and 3.11 support, PEP 517 builds replacing `setup.py`, removal of several deprecated APIs [9]. |
| v4.1 | Sep 2023 | Position-bias treatment via GAM in LambdaMART [9]. |
| v4.2 | Dec 2023 | Apache Arrow input in the Python package, CUDA 12 support (CUDA 10 dropped), first CRAN release of the R package in over two years [9]. |
| v4.3 | Jan 2024 | [CUDA](https://aiwiki.ai/wiki/cuda) architecture 8.9 (RTX 40 series) support; CMake 3.18+ required [9]. |
| v4.4 | Jun 2024 | NumPy 2.0 support, arm64 macOS wheels, Python 3.12 support (Python 3.6 dropped) [9]. |
| v4.5 | Jul 2024 | `feature_names_in_` attribute for scikit-learn estimators; HDFS support removed [9]. |
| v4.6 | Feb 2025 | Python 3.13 support, NVIDIA Blackwell [CUDA](https://aiwiki.ai/wiki/cuda) support, linear tree on GPU, and Bagging by Query for lambdarank [9]. |
| v4.7 | Jul 2026 | Latest stable release as of November 2026: first ROCm (AMD GPU) builds, multi-GPU [CUDA](https://aiwiki.ai/wiki/cuda) training via NCCL, CUDA 13 and Python 3.14 support, Python 3.7 and 3.8 dropped [9]. |

The project was transferred from `microsoft/LightGBM` to `lightgbm-org/LightGBM` in March 2026, after Microsoft's Open Source Conduct Team said it was considering archiving the Microsoft-hosted repository, while remaining MIT-licensed and continuing under the same core team [9].

## Limitations

LightGBM inherits the general limitations of gradient boosted decision trees (GBT): it is a tabular-only method, it does not extrapolate beyond the range of training data, and it requires meaningful [feature engineering](https://aiwiki.ai/wiki/feature_engineering) on raw signals such as text or images. In addition, LightGBM has some library-specific quirks:

- *Overfitting risk on small data.* Leaf-wise growth produces deeper, more skewed trees than level-wise growth at the same leaf count; on datasets with fewer than a few thousand rows, the same hyperparameters that work for XGBoost can severely overfit in LightGBM. Lower `num_leaves` and stronger `min_data_in_leaf` are the standard fixes.
- *Sensitivity to categorical encoding.* LightGBM's native categorical handling expects integer codes; passing the same categorical column as one-hot will silently disable the optimal-split algorithm and often degrade accuracy.
- *Less mature than XGBoost on some accelerators.* As of 2026, the CUDA backend matches CPU accuracy but still lags slightly behind XGBoost's on a few corner-case objectives; OpenCL is functional but is no longer the recommended GPU backend.
- *Documentation density.* The official docs are comprehensive but assume familiarity with GBDT terminology. The parameter reference is long and the interaction between `num_leaves`, `max_depth`, and `min_data_in_leaf` is a frequent source of confusion for newcomers.

## See Also

- [Gradient Boosting](https://aiwiki.ai/wiki/gradient_boosting)
- [Gradient boosted decision trees (GBT)](https://aiwiki.ai/wiki/gradient_boosted_decision_trees_gbt)
- [XGBoost](https://aiwiki.ai/wiki/xgboost)
- [CatBoost](https://aiwiki.ai/wiki/catboost)
- [Decision Tree](https://aiwiki.ai/wiki/decision_tree)
- [Random Forest](https://aiwiki.ai/wiki/random_forest)
- [Ensemble Learning](https://aiwiki.ai/wiki/ensemble_learning)
- [Boosting](https://aiwiki.ai/wiki/boosting)
- [Scikit-Learn](https://aiwiki.ai/wiki/scikit-learn)
- [NeurIPS](https://aiwiki.ai/wiki/neurips)
- [Microsoft Research](https://aiwiki.ai/wiki/microsoft_research)
- [Machine Learning](https://aiwiki.ai/wiki/machine_learning)

## References

1. Ke, G., Meng, Q., Finley, T., Wang, T., Chen, W., Ma, W., Ye, Q., & Liu, T.-Y. (2017). *LightGBM: A Highly Efficient Gradient Boosting Decision Tree.* In Advances in Neural Information Processing Systems 30 (NIPS 2017), pp. 3146-3154. [Paper PDF](https://proceedings.neurips.cc/paper/2017/hash/6449f44a102fde848669bdd9eb6b76fa-Abstract.html).
2. Microsoft / LightGBM project page on Microsoft Research. https://www.microsoft.com/en-us/research/project/lightgbm/.
3. LightGBM documentation, Features and Parameters Tuning sections. https://lightgbm.readthedocs.io/en/latest/Features.html and https://lightgbm.readthedocs.io/en/latest/Parameters-Tuning.html.
4. LightGBM documentation, Advanced Topics: Categorical Feature Support. https://lightgbm.readthedocs.io/en/latest/Advanced-Topics.html.
5. Florek, P. & Zagdanski, A. (2023). *Benchmarking state-of-the-art gradient boosting algorithms for classification.* arXiv preprint 2305.17094. https://arxiv.org/abs/2305.17094.
6. LightGBM documentation, Python API. https://lightgbm.readthedocs.io/en/latest/Python-API.html.
7. LightGBM documentation, Distributed Learning Guide. https://lightgbm.readthedocs.io/en/latest/Parallel-Learning-Guide.html.
8. LightGBM documentation, GPU Tuning Guide. https://lightgbm.readthedocs.io/en/latest/GPU-Performance.html.
9. LightGBM GitHub repository, Releases (v4.6.0, February 15, 2025; v4.7.0, July 18, 2026) and the lightgbm-org/LightGBM organization transfer (Issue #7187, March 2026). https://github.com/microsoft/LightGBM/releases and https://github.com/lightgbm-org/LightGBM/issues/7187.
10. *LightGBM* on Wikipedia. https://en.wikipedia.org/wiki/LightGBM.
11. XGBoost documentation, Categorical Data. https://xgboost.readthedocs.io/en/stable/tutorials/categorical.html.
12. LightGBM documentation, Parameters. https://lightgbm.readthedocs.io/en/latest/Parameters.html.

