Welcome back.

Last week I was at an event in Frankfurt hosted by LSEG for the 10th anniversary of ORE, where I was invited to talk about the past 25-odd years of QuantLib. This post is not the transcription of that talk, but it’s going to be close.

I didn’t prepare slides; instead, I had the screen behind me show a visualization of the git history of the project, created using Gource. The video shows files as dots, directories and subdirectories as branches, and the committers buzz around making changes (the rays and flashes of light). It’s surprisingly good at showing some different periods of the history of the project. Don’t look at it as a video, from beginning to end: most of it is pretty boring when not in a live talk. You can refer to it as you read this post; I’ll mention some particular moments you can check.

Before diving into the details of the history, though, I must repeat what I said in Frankfurt: the first thing when looking back at these years is a feeling of gratitude. My career would have been a whole lot less interesting without this project and the people it led me to know. So: a heartfelt thanks to its originators, of which I’ll talk in a second, and to all its contributors and users.

The beginnings

The other first thing I have to say is that it wasn’t my idea. The project was born in late 2000, in a small, newly founded company in Milano called RiskMap, of which I was one of the first employees with Ferdinando Ametrano and Marco Marchioro; the founder was Dario Cintioli. We were about to start coding, as one does, and Ferdinando had the idea of open-sourcing our code as a way to put us on the map; Dario agreed (thanks again, Dario) and the project started. In the first year of the video, you can see us figuring out the structure of the library together with others that had joined the company in the meantime. During that first year, we also started getting the first external contributions.

After a couple of years, the work on the library slowed down as the RiskMap team focused less on the library and more on products based on it. There was still maintenance work done, but the architecture had been more or less finalized. Starting from all this way back, work on the library was done when someone had need of a missing feature and contributed it.

This continues today. There’s no real roadmap; and, given that all contributors have day jobs, no resources that we can allocate with any reliability.

Some growth

Sometimes, though, some resources found us. That was the case in mid 2006, when an investment bank decided to implement the Libor market model and reached out to us for collaboration; the late Mark Joshi consulted on the project, too. In the video, you can see what it’s like when a team starts to really work on the library.

One or two years later, we had another sizeable contribution from another team that, needing them, had been working on adding inflation and credit curves to the library. We’ll see those folks again at a later time.

And in the meantime, developments were also happening based on the library but outside of it. Around 2005, Eric Ehlers started work on the QuantLib Excel addin. It’s been more than 20 years now; and, like QuantLib, that project is still going.

The quiet years

In early 2008, the work on the Libor market model ended and the pace of change slowed down. One thing I should note, though, is that those years were a lot less lonely than the video seems to show. There’s just a handful of committers flying around the code, true, but that’s because of the tooling we still had for version control.

This was years before git and GitHub gained momentum. When we started in 2000, we used CSV; in 2007, we migrated to Subversion; but neither of them had the concept of forks, and we just had a central repository to which one needed write access to contribute. For obvious reasons, not a lot of people had such access; most other contributors would send patches to be committed by someone from the inner group. Looking at the copyright attributions at the top of the QuantLib license will give you a much more realistic view of the number of contributors.

The gates open

In the middle of 2013, we finally migrated to git (and GitHub; the code was hosted on SourceForge until then). This finally meant that contributors would appear as such, and in fact you can see a more varied set of people buzzing around in the video.

In the meantime, most of the co-founders had moved on and I found myself in the maintainer role. (Somehow I seem to stumble into such positions—it also happened in the choir of my parish.) This is when I also started focusing on documenting the library; the first chapters of Implementing QuantLib were written in those years, as well as the first of the notebooks that would have gone into the QuantLib Python Cookbook.

A few years later, in 2016, the Open Source Risk Engine (ORE) project started, proving that QuantLib could be the base of a whole risk system. Which was probably already proved in several places around the world, but not in the open. Kind of funny how I don’t really have information on where, how or how much the library is used, but that’s the financial world.

The existence of ORE also allowed us to focus on our pricing code, leaving to them the broader applicative scope.

The modern times

The project happily hummed along into the 2020s, all the while increasing the number of contributors and their activity.

In the meantime, my contributions have been mostly as a maintainer. Besides reviewing and merging contributions, I tried to work on the process. For instance, I increased the automation, adding CI builds for Linux, Windows and MacOS as well as a number of other checks, some of which help maintain the library by running linters and opening automated pull requests; that’s why you’ll also see a github-actions bot flying around in the video.

This also allowed me to set up a quarterly release process, as opposed to the not-so-regular release schedule of the earlier years. Lately, I’ve also been automating the release process itself. The next step might be to finally move the QuantLib repository from my personal GitHub account, where it started as an experiment when we migrated to GitHub, to a proper organization account.

The goal of all this work on the process is for me to avoid becoming the bottleneck, and also to make it possible for the project to continue without me if needed. (No, I don’t plan to leave it, but a bus factor of one is never good.)

Oh, and I kept working on documentation, too, and published the QuantLib Guide.

Interesting times

If I had given the talk a few months ago, this would have been the status quo. I would have said that I was happy about the progress and that the project was humming along.

All this remains true. I am happy about the project, and if you look at, say, 2024 onwards in the video, you’ll see a nice amount of activity.

However, a few months ago I wouldn’t have imagined what was about to happen. Look at the last few months in the video; say, from June 2026, and especially in October.

That is the rise of A.I., and I still haven’t adjusted.

Some of you will remember I posted here this year in May, noticing that A.I.-generated pull requests were starting to arrive and wondering how to setup the repository so that they had a greater chance to be correct. Since then, they have increased a lot. So far, most PRs have been ok; and at least, an advantage of using A.I. for them is that it will write comments and tests, too. However, the sheer volume is becoming a problem; and, like most of the industry, I still have to figure it out. If you have suggestions, they’re welcome.

In conclusion, yes: maintaining QuantLib is still quite interesting after 26 years. Again, thanks to everyone that makes it so.

Subscribe to my Substack to receive my posts in your inbox, or follow me on Twitter or LinkedIn if you want to be notified of new posts, or subscribe via RSS if you’re the tech type: the buttons for all that are in the footer. Also, I’m available for training, both online and (when possible) on-site: visit my Training page for more information.