Quantum Parallels. What Quantum Software Can Learn From the 1950s Golden Era

The 1950s were the golden age of computing, and almost everything since has been a variation on what was settled then. The pattern ran like this. A machine nobody could afford to leave idle, and a compiler given away to sell it. Then a user group that wrote the teaching material the vendor did not, and a standard that arrived a decade late and quietly ended the lock-in. IBM ran that sequence with FORTRAN between 1957 and 1966, and it is running it again now.

Qiskit is the de facto default, the go-to framework for building quantum circuits, running experiments, dealing with the underlying hardware and producing results. It has become the workhorse of the quantum industry and academia alike. You would have to be living under a rock not to have come across it, and for many people, it is the first interface to any quantum device at all.

IBM played their hand very well. Qiskit became the gateway to their cloud quantum service, which was the first on the planet, so rewind the clock and there was no real alternative. Now there are competing services and multiple languages. Can Qiskit maintain its podium lead against newer upstarts, and does the 1950s record tell us how this ends?

We delve into the numbers behind each common language and framework. Yes, a framework is different from a language. For example, Q# from Microsoft is a language. In other words, you write in its syntax, whereas for Qiskit and Cirq you call libraries that do the quantum “stuff”; hence, it is a framework. Almost anything can seem like a framework these days, especially when we use the glue of a language like Python, which has become the common language of scientific computing.

But we want to understand the rise of Qiskit, which appears to be the most popular framework, and where it sits relative to other languages/frameworks, and what they might need to do to gain the number-one slot in the quantum software space.

QISKIT vs FOTRAN. A rerun of the 1950s?

The similarities between the rise of FORTRAN and Qiskit are not lost on many, especially as both emerged from IBM, only sixty years apart. FORTRAN is still around as a language, but many would never expressly code in it, instead choosing another ‘higher-level ‘language such as Python or Julia. But under the hood of many an application, the efficiency and well-honed FORTRAN compilers have meant that the language has stuck around, often as some component or module where speed and efficiency are massively critical – think HPC and Data Cetre applications across multiple processors to run, say, a drug discovery process.

Modern software is multi-language, and we have learned to exploit it by cobbling together multiple languages, each giving us something of value. For example, data structures are easy in Python, but it is a slow language, making programming itself fast but perhaps not the application. Therefore, we come to quantum frameworks, which take away the need to understand everything under the hood and use an easy [ish] language such as Python to let the programmer abstractly construct the problem space at a higher level.

FORTRAN won out – it became the gold standard of scientific computing for decades until Python really took off. Now Python is used as the language to drive those lower-level routines, which are actually constructed and compiled. Think of the Python package NumPy. You’d never want to code in Python to do linear algebra. But you want the ease of programming in something like Python, so modules in Python are written in other languages such as C for efficiency and then compiled. This is the framework approach we have in quantum today, for example Qiskit and Cirq to name just two. But Q# is a language and framework designed from the bottom up to be friendly to the type of quantum program researchers in the space have.

Nobody beat FORTRAN head-on. C and Unix came, then C++, then MATLAB and Python, and the upstarts simply stopped arriving at its door, though it likely survives underneath in the linear algebra NumPy/SciPi calls. However, expect developers of these packages to aim to remove FORTRAN code, as it’s hard to maintain.

The danger to IBM (which developed Qiskit) is not a better circuit library. It is the layer below, where NVIDIA already ships inside Qiskit’s own simulator, and the layer above, where synthesis writes the circuit so nobody has to.

The Quantum Leader Board

There is no easy way to track popularity, but we are using the numbers we can get from each language/framework project. By looking at downloads and GitHub stars, we can gauge uptake, and by going back in time, we can see historical trends and relative performance between projects (which saves me from writing framework or language).

The plots we have produced tell a story in themselves, and while we can pull out some trends and clear emerging ideas, the raw plots do a good job of showing what is happening in the market. It’s important to realise the crudity of some of these numbers, for not every project does the same thing.

Some key observations are:

• Qiskit leads massively in monthly downloads. It is almost a magnitude larger than, say, PennyLane.
• Qiskit is still in a massive growth phase. It continues an exponential curve upwards. It took until 2025 to reach 10M downloads, but only until 2026 to reach 20M. Qiskit is still experiencing huge growth.
• PennyLane (from Xanadu) is showing the hallmarks of massive exponential growth. It remains second in terms of overall downloads.
• Popularity based on downloads alone indicates that Qiskit is several steps ahead, with over 25M downloads compared to PennyLane, Cirq, PyTKET (Quantinium), and Braket (Amazon SDK).

Breaking Qiskit

The advantage is that Qiskit already has a massive installed base. It has massive backing and, at one point, was the only way to use a real quantum computer in the cloud – going back to IBM’s Quantum Cloud, it was for many the only way to access a machine. Or even simulate a quantum circuit. That is now changing with alternatives. The choice is increasing, and we can clearly see that in the data.

Contenders [to Qiskit] can take comfort in PyTorch’s rise in machine learning. It emerged from Meta as an alternative to Google’s TensorFlow (TF) but has now become the dominant ML package, despite TF’s head start. PyTorch also has better syntax (according to many), along with better functionality, such as a better-equipped debugger, which helped it win in both the application and research space.

Keras ended up wrapping TF and its clunky syntax and static graph, but many think this was simply a band-aid. It made an application faster to build, but it was still essentially TF underneath. TF, in Figure XX, shows that the install rate had flatlined, while PyTorch continues to increase and pull ahead. TF version 2.0 made eager execution the default and added tf.function for graph compilation when you wanted it.

The Quantum Killer Apps

One clear take-home is that QML is likely driving PennyLane’s install base, as it has focused on getting right into the application space. Whether some of what plays out with the FORTRAN allegory might be relevant, as we see that just as they did with programming languages, programmers push to get more ‘meta‘ and away from the more lower-level aspects of the language – so, for example, building a linked list is futile in Python – you simply don’t need to. Could the same be said of the quantum circuit, where the circuit is just a model to be optimised?

We posit that developers are therefore more focused on the value quantum can bring rather than on lower-level circuit building. Of course that layer is needed, but if developers can instead focus on building a quantum machine learning application that provides a better result than classical, that will drive tremendous interest by moving us closer to quantum applications and away from pure circuit-level experimentation. Also, Xanadu has been focused on QML pretty much since its inception and has also made its documentation and frameworks easy and simple to use, and we know from talking to many that it has won many fans for its no-nonsense approach.

It’s All Exponential

If we plot and fit an exponential curve to where we see exponential take-off, we back out a growth rate. Of course, limited by the fact that we are not across the same time frame. PennyLane is the cleanest exponential in the entire dataset. Its full 93-month series fits well with no searching at all, and it is still running. That is a stronger result than Qiskit’s on every axis except duration. So expect to see more of PennyLane! We can see it has all the hallmarks of a takeoff success in its exponential growth.

There are always questions of growth rate vs installed base, but one method we have used is to get the time to double the installed base. The shorter the period, the better. We perform this over the last N months.

What To Watch

As I said, the plots tell an interesting story in themselves; these are not simple projects, and every reader will likely view the data through a different lens. So I don’t wish to be too crude in the analysis, but I will make some predictions for the future based on these data. Plus, not everything competes with everything else, or even has the same functionality. It’s not Apples vs Oranges. We could easily do a 30-page report.

NVIDIA CUDA Quantum will continue to push the nearer-term side of classical-quantum hybrids. NVIDIA’s sheer firepower and compute dominance will help drive uptake.

PennyLane will continue to flourish. Xanadu is doing a fantastic job, and users are coming. Broadly, we can see PL as the PyTorch-to-TensorFlow comparison. As commercial use cases become more important, the meta layer of creating classical-hybrid use cases will increasingly feature in companies’ budgets. Less important will be what’s under the hood – results and application will drive demand.

Q# from Microsoft has lost its support. Even the knowledge base, Katas, and initial interest in building out the community seem to have waned. Plus, perhaps one of the biggest hold-ups is that Q# IS A LANGUAGE, and that means learning a new language (programming syntax) and also, if quantum language too (assembling and designing circuits). Likely just too much overhead for many. Microsoft tried, of course, building its own take on many other languages, from Visual Basic (BASIC) to ASP (JSP) to C#.Net. (C++). Many people we talk to consider Q# a dead project. Perhaps this is time for MSFT to come up with something brand new!?

My personal favourite project is Cirq, which is also somewhat lagging behind and feels a little unloved from just a few years back. Google is one of the pioneers of a great many everyday technologies, so it’s sad to see Cirq languishing. It needs a better community. Google also has OpenFermion, which is proving popular and additionally Stim (for QEC), so it’s building out great components, but perhaps it is or at least feels, fragmented. Could Google try rebranding; could it pull all its projects behind a common name?

Qiskit averages 1.11 million installs a month and is adding about 100k a month. That absolute gain is larger than every other vendor SDK put together. Qiskit builds circuits and sends them to machines, and it is the default nearly everywhere. It is tied to nobody’s hardware, with providers shipping for IonQ, IQM, AQT and AWS Braket, among others. That makes it basically infrastructure.

QEC is a fast-growing segment. The fastest-growing thing in quantum software is error correction. The whole sector, including packages such as LDPC, is growing at almost a healthy 100k installs a month. A different beast, so we are not comparing directly with traditional projects. But it does show where people are still looking. Google has an iron in this fire with OpenFermion too. Of course, some of these projects share dependencies.

The future looks very bright for Qiskit. It’s growing exponentially, with a massive installed base and ecosystem to support it. It has the pedigree of IBM backing it, and Big Blue doesn’t really have much in the way of frontier tech, so quantum is one area where they have the lead and can keep pushing. Some languages such as PyQuil look to be dead – simply, it’s not growing – sadly, a great early project from Rigetti, but now in severe need of a reboot. It still managed an install base in the low millions.

One clear trend is that QEC is rising rapidly. Interest is growing in logical qubits as opposed to NISQ, so it’s no surprise that users want to get to grips with the tooling that might run future measures.

Microsoft could adopt an open-source language, throw in the towel and do more to get its installed base into quantum. Let’s be honest: most programmers are lazy, and learning another language feels pointless unless it really offers benefits. Learning Q# only gives you the ability to create quantum applications, but learning Python opens the door to so many worlds. However, Q# never seems to have had the growth phase of other projects.

Expect to see a continued uptick in projects, esp. PennyLane and QEC, and Qiskit is still growing massively and will likely continue to do so, as the ecosystem is so dominant and well supported. However, I expect that without nourishment, some of the slower-growing projects will decline and wither on the vine. It probably makes sense for some of these packages to throw in the towel if they cannot invest in building the mass of tutorials, demos and examples that Qiskit and PennyLane have managed to do. Qiskit is a fab gateway for people to enter the IBM ecosystem, and IBM has deep pockets.

Just as we see new contenders in the cloud, such as Nebius competing with AWS, GCP and Azure (classical cloud), we may find that newer players such as IQM take on IBM Quantum on the cloud front with their Resonance platform, which might offer a simpler, more agnostic approach.

If that happens, as could happen with any cloud tool (not just IQM), Qiskit doesn’t have to be the only supported framework; on IQM, for example, it isn’t the only framework. Expect inroads from competitive cloud platforms, not just IQM but AWS and many others, as the default supported framework on IBM Cloud could follow. All could begin to shake the dominance of Qiskit, but we don’t see the beginnings of this yet.

So if I had to bet, the 1950s might still come to play, and even in 60 years we might still need Humans or AI with Qiskit Experience. But 60 years feels like an awfully long way from here.