google/tf-quant-finance: a TensorFlow quant library that is now archived

What tf-quant-finance actually provides

TF Quant Finance is a Python library that expresses quantitative finance math as TensorFlow operations, so the same code can run on CPU or GPU and be differentiated by TensorFlow's autodiff. The README describes the library as "high-performance components leveraging the hardware acceleration support and automatic differentiation of TensorFlow." That sentence is the whole pitch, and it also defines the audience: quants who already work inside TensorFlow, or who need gradients through a pricing or calibration routine.

The library is organised in three tiers. Foundational methods cover optimisation, interpolation, root finders, linear algebra, and random and quasi-random number generation. Mid-level methods cover ODE and PDE solvers, an Ito process framework, diffusion path generators and copula samplers. The top tier holds pricing models and quant-specific utilities: Local Vol, Stochastic Vol, Stochastic Local Vol and Hull-White models plus their calibration, rate curve building, payoff descriptions and schedule generation. Each layer is intended to be usable on its own, and the README states that each layer is accompanied by examples that run independently of higher-level components.

This is not a general-purpose derivatives library in the QuantLib sense. It is a TensorFlow-native one. If your workflow is a Python script that prices a book of swaps once a day, the tensor abstraction buys you little. If your workflow is a calibration loop where you want gradients, or a Monte Carlo simulation you want to run on a GPU with a batch of parameter sets, the design makes more sense.

How the TensorFlow graph shapes the design

The mechanism visible in the repository is that numerical routines are written as TensorFlow ops over tensors rather than as scalar Python loops. That is what makes batching and GPU execution possible, and it is also what makes automatic differentiation work: because the pricing and calibration steps are composed of differentiable ops, TensorFlow can compute gradients through them.

The README's roadmap lists the components under development at the time of writing: Ito processes, with methods for sampling paths and for solving the associated backward Kolmogorov equation; specific processes including Brownian Motion, Geometric Brownian Motion, Ornstein-Uhlenbeck, a one-factor Hull-White model, Heston, local volatility, quadratic local vol and SABR; copula definition and sampling; model calibration for Dupire local vol and SABR; rate curve fitting with the Hagan-West algorithm for yield curve bootstrapping and the Monotone Convex interpolation scheme; and support for dates, day-count conventions and holidays.

Two structural details are worth noting. First, the repository ships an api_docs/ directory alongside the package, so the generated API reference is part of the tree rather than only a website. Second, the build is Bazel-driven: the top level contains BUILD, WORKSPACE and build_pip_pkg.sh, and the development section of the README requires the Bazel build system. For a pure user of the pip package that does not matter, but it does mean that contributing a patch or building a wheel from source follows a Bazel workflow, not a plain setup.py one.

Installing tf-quant-finance and pricing a first option

The README states the library requires Python 3.7 and TensorFlow >= 2.7, and that the easiest way to get started is the pip package. It first directs you to install the most recent TensorFlow following the TensorFlow installation instructions, giving this example:

pip3 install --upgrade tensorflow

Then the library itself, again from the README:

pip3 install --upgrade tf-quant-finance

The README notes that you may also have to use the --user option. That is the entire installation section; there is no conda channel, no Docker image, and no prebuilt wheel documented beyond PyPI.

For a first real use, the README points to end-to-end examples under tf_quant_finance/examples/, including tutorial notebooks for American option pricing under Black-Scholes, Monte Carlo via the Euler scheme, Black-Scholes price and implied vol, forward and backward mode gradients, root search with Brent's method, optimisation, swap curve fitting, and vectorization with XLA compilation. Those notebooks open in Colab from the links in the README, which is the lowest-friction way to see the API in action without setting up an environment.

If you prefer to work locally, clone the repository and open the notebook files from tf_quant_finance/examples/jupyter_notebooks/ in Jupyter. The README does not document a CLI, so there is no command to run the library as a tool; it is imported as a Python package. Note that the most recent release listed on the repository is v0.0.1-dev9 from 2019-09-17, so the version you get from pip is a development release, not a 1.0.

The archived status is the first thing to weigh

The README opens with an important note stating that the library is no longer maintained and has been archived, and suggesting that anyone depending on its functionality fork it and continue development elsewhere. The repository metadata confirms the archived flag. The last push to the default branch was on 2026-08-06, but that does not change the maintainer's own statement about support.

This is the limitation that dominates every other one. There will be no upstream fixes for numerical bugs, no compatibility work for future TensorFlow releases, and no response to issues. The version history reinforces the point: the releases listed are v0.0.1-dev7, v0.0.1-dev8 and v0.0.1-dev9, all from September 2019. A library that never left the 0.0.1 development series and is now archived is a snapshot, not a dependency.

There is a second, more mundane constraint. The development dependencies in the README pin TensorFlow Probability between v0.11.0 and v0.12.1 and Numpy 1.21 or higher. Those bounds were written against a TensorFlow 2.x era, and a modern environment will likely require you to resolve version conflicts yourself. The README does not document a supported upgrade path, and there is no migration guide in the repository listing.

It is also the wrong tool for anything outside its scope. There is no execution or order management, no market data handling, no risk aggregation, and no reporting layer. The README describes mathematical methods and pricing models, nothing more.

Where it sits against QuantLib and a plain NumPy stack

The obvious comparison is QuantLib, which the repository's own topics list names. QuantLib is a C++ library with Python bindings that has been developed for decades and covers a far wider surface of instruments, calendars and conventions. Its model is object-oriented and scalar: you build an instrument, attach a term structure, and ask for a price. There is no autodiff and no GPU batching.

TF Quant Finance inverts that. Instead of an instrument object graph, you compose tensor operations, and the value you get is the ability to differentiate and to batch. A calibration that would be a nested optimisation loop in QuantLib can, in principle, be expressed as a gradient descent step. The trade-off is coverage and maturity: QuantLib has the breadth, TF Quant Finance has the autodiff and the accelerator.

The other alternative is writing the math yourself with NumPy and SciPy. That gives you full control and no archived dependency, at the cost of reimplementing root finders, interpolation, copula sampling and the curve-fitting algorithms that this repository already contains. If you only need Black-Scholes prices and implied vols, a few dozen lines of NumPy will do and neither library is warranted. The case for TF Quant Finance starts when you need gradients through the model or GPU-batched simulation.

Licence, forking and the real cost of adoption

The repository is licensed under Apache-2.0, and the LICENSE file sits at the top level. The setup.py header carries the standard Apache 2.0 notice from Google LLC. Apache-2.0 permits commercial use, modification and redistribution provided you keep the notices and state changes; it also includes a patent grant. This is a permissive licence, so forking the code and continuing development is legally straightforward. That is not legal advice, and if you plan to redistribute a modified version you should read the licence text and the NOTICE requirements yourself.

The practical cost is maintenance, not licensing. Because the README directs users to fork, the realistic adoption path is: vendor the package into your own repository, pin TensorFlow and TensorFlow Probability to versions you have validated, and own the numerical results. That means your team absorbs bug fixes, TensorFlow compatibility work and any model corrections. For a small quant team without spare engineering capacity, that cost is likely to exceed the benefit.

The upgrade cost is also asymmetric. There is nothing to upgrade to. The last release is v0.0.1-dev9, and the repository is archived, so the version you install today is effectively the version you will run. Any future change comes from your own fork.

Editorial conclusion

Adopt google/tf-quant-finance only if you need differentiable pricing or Monte Carlo inside a TensorFlow graph and you are willing to fork it, since the README states the library is no longer maintained and archived. Do not adopt it for new production pricing systems that expect upstream fixes, and do not treat the pip package as a supported dependency. Before committing, verify that the pinned requirements (Python 3.7, TensorFlow >= 2.7, TensorFlow Probability between v0.11.0 and v0.12.1, Numpy 1.21 or higher) resolve in your environment, and run the Colab notebooks under tf_quant_finance/examples/jupyter_notebooks/ against your own inputs.

Frequently asked questions

Official sources

1. google/tf-quant-finance on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases