Open-source project
VowpalWabbit/vowpal_wabbit avatar
VowpalWabbit/vowpal_wabbit

vowpal_wabbit's Python package is a build wherever no prebuilt wheel fits

Vowpal Wabbit is a machine learning system which pushes the frontier of machine learning with techniques such as online, hashing, allreduce, reductions, learning2search, active, and interactive learning.

8,740 stars1,919 forksC++NOASSERTION

At a glance

What is it?
Vowpal Wabbit is an online machine learning system which by its own account is fast but whose scalability rests on a memory footprint bounded independently of the data. The packaging is where the sharp edges are. Installing the Python bindings without a matching prebuilt wheel is a compile that needs a build system and a generator tool, the legacy setup script imports distutils modules that recent interpreters no longer ship, a whole end-to-end test directory is excluded from continuous integration for a named reason, and the wheel test step retries the same install three times.
Who is it for?
Vowpal Wabbit fits a team learning from a stream rather than a fixed set, working on ranking or contextual-bandit problems where the feature space cannot be enumerated and the training data cannot be held in memory. It does not fit a pipeline that needs the Python package to install like an ordinary wheel, because on an interpreter without a prebuilt wheel you need a compiler and two build tools.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 31 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • VowpalWabbit/vowpal_wabbit8,740 ★ · +21
Star history
Repository2026-09-132026-11-13
VowpalWabbit/vowpal_wabbit8.7k8.7k

21 Stars in the last 61 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Installing the Python bindings is a compile

The wheel configuration declares its build requirements as the packaging tools, the bindings generator, and two build tools:

code
requires = [
    "setuptools",
    "wheel",
    "cmake",
    "ninja",
    "pybind11",
]

Consequence: on any interpreter where no prebuilt wheel matches, installing this package compiles native code and needs a C++ toolchain plus two build programs that have nothing to do with Python. That is a far heavier install than a package with a Python extension usually implies, and the wheel configuration does not build for two platform combinations: everything that is not the main Linux flavour, and thirty-two-bit Windows, because one of its own test dependencies has no prebuilt wheel for that target. On those platforms the install becomes a build whether you wanted one or not. The backend is setuptools, and a setup.py sits beside the configuration.

The legacy setup script cannot run on recent interpreters

The older packaging script imports several modules that were removed from the standard library when it was slimmed down, including the directory utilities, the system configuration helper and a command class it subclasses to override cleaning behaviour. The wheel configuration builds for five interpreter versions from three point ten to three point fourteen, with setuptools as its backend. The older script defines its own build options: a Windows-only path to the vcpkg root, one to enable boost-cmake, one to pass extra semicolon-separated options through to CMake, one to choose a CMake generator, and one for a debug build.

An entire end-to-end test directory is excluded from continuous integration

The wheel test command carries an exclusion and a comment explaining it. The comment says a particular executor uses a multiprocessing pool with a single worker, which hangs in the containerised environment because of a fork-safety interaction with the bindings layer, and that the tests pass locally. Consequence: the project's own release gate skips the suite that exercises the tool most end to end, for a reason precise enough to be checked. It is an honest exclusion rather than a hidden one, and it is also the reason a failure you hit locally is one that continuous integration would never have caught, which inverts the usual relationship between the two. The exclusion is written as a single ignore path on the test command rather than as a marker inside the suite, so a developer running the tests directly does not get it for free.

The wheel test step retries the same install three times

The step that prepares the test environment installs a group of packages and then, joined by a shell or, repeats the identical command twice more:

code
before-test = "pip install pytest pyclean setuptools scipy scikit-learn || pip install pytest pyclean setuptools scipy scikit-learn || pip install pytest pyclean setuptools scipy scikit-learn"

A comment above it says large packages go in before-test with retry to handle transient SSL errors during download, so repeating the identical command is the retry: a transient failure gets up to three attempts. A separate comment explains that vw-executor depends on vowpalwabbit, so it must be in test-requires, which runs after the wheel install.

The Makefile wraps a build system and adds one target per profiler

Five near-identical configuration steps exist, differing only in a build type and a set of compiler flags, one for coverage, one for a profiler, one for a memory checker and one for a static link. Pattern rules then map each output name to its configuration step and its compile step. Consequence: adding a build mode means adding a target and a rule, and the profiler and memory-checker flags are passed as one quoted string through CMAKE_CXX_FLAGS, while coverage and static linking use named options (VW_GCOV, STATIC_LINK_VW). It is a workable arrangement for a project that has grown many build modes over years, and it is the kind of indirection that makes a build failure hard to trace to the flag that caused it. The default target builds the command-line binary alone, while the aggregate target adds the library example, the Java binding, a spanning-tree binary and the Python library.

The defining claim is bounded memory, not speed

The readme separates two ideas explicitly and says scalability is not the same as fast. What it claims is that the memory footprint is bounded independently of the data, that the training set is never loaded into main memory before learning starts, and that the size of the feature set is bounded independently of the amount of training data by using a hashing trick. Consequence: the guarantee is about memory rather than throughput, and it is what makes the system usable on a stream. The trade the hashing introduces is that two distinct features can collide, and the readme does not spell that out, so it is worth understanding before you rely on it with a feature space you cannot enumerate. Feature pairing is described separately as the way to keep the algorithm linear in the cross-product of two subsets of features, which is what makes ranking problems tractable without expanding the input.

Nine language ecosystems are built from one repository

The top level holds bindings directories for several languages, a directory for a managed package format, a WebAssembly target, a cluster directory, a container definition and a third-party notices file. Consequence: one commit can break a binding in a language nobody touches daily, and the wheel configuration already shows the shape of that problem, since an architecture's testing was only enabled by removing an exclusion after a migration in the bindings layer. The alternative, separate repositories per language, trades that for version skew across the set, and this project has chosen the former. The wheel configuration also carries a comment about vendoring a compression library specifically so the published wheels are self-contained rather than linked against the system copy.

The library requirements predate every interpreter the project supports

The requirements file asks for a numeric library at one point six and one, a scientific library at zero point nine, a machine learning library at zero point seventeen and a data frames library at zero point two four point two, all with lower bounds only. The wheel configuration builds for interpreters from three point ten upward. Consequence: the floors describe a world that ended before the earliest interpreter this project targets, so they constrain nothing in practice and function as documentation rather than as resolution. That matters mostly when someone tries to work out which library version a release was written against, because the answer is not in the file.

Editorial conclusion

Vowpal Wabbit fits a team learning from a stream rather than a fixed set, working on ranking or contextual-bandit problems where the feature space cannot be enumerated and the training data cannot be held in memory. It does not fit a pipeline that needs the Python package to install like an ordinary wheel, because on an interpreter without a prebuilt wheel you need a compiler and two build tools. It also does not fit anyone who relies on the project's continuous integration as evidence that the end-to-end path works, because that suite is excluded there. Before adopting it, check whether a prebuilt wheel exists for your interpreter, and treat the excluded tests as something you have to run yourself.

Frequently asked questions

what is vowpal wabbit

An online machine learning system focused on learning from a stream rather than a fixed dataset, with a particular emphasis on reinforcement learning and contextual bandits. Its input is flexible text interpreted as bags of words, optionally in several namespaces, and its distinguishing property is a memory footprint bounded independently of the size of the data and of the feature space, the latter through a hashing trick.

What is the contextual bandits algorithm and how does it work?

The repository does not explain the algorithm in the readme; it states that there is a specific focus on reinforcement learning with several contextual bandit algorithms implemented, and that the online nature of the system suits that problem. What the readme does explain in detail is the input format, the optimisation options with sparse gradient descent as the baseline, and the pairing of feature subsets so the algorithm stays linear in their cross-product.

What are the two types of reinforcement learning?

The repository does not classify them. It describes itself as covering online techniques, hashing, distributed reduction, learning to search, active learning and interactive learning, and it separates scalability from speed when arguing why the system is worth using.

Is RL the future of AI?

The readme makes a narrower claim, that the system pushes the frontier with those online techniques and is a destination for implementing and maturing state-of-the-art algorithms with performance in mind. It does not make a prediction about the field, and this repository gives no evidence either way about one.

vowpal wabbit alternative

The readme names none. It links its own wiki for getting started, for building and for a tutorial, and points at two directories of examples, one of command-line demonstrations organised by feature and one of notebooks and tutorials for the Python interface. It also describes the system as similar to the few other online algorithm implementations, without naming any.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. VowpalWabbit/vowpal_wabbit on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/vowpalwabbit-vowpal-wabbit.svg)](https://hysenlabs.com/projects/vowpalwabbit-vowpal-wabbit)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/vowpalwabbit-vowpal-wabbit.svg)](https://hysenlabs.com/projects/vowpalwabbit-vowpal-wabbit)

Was this useful?