Raphael Seidel is a Staff Engineer at IQM and one of the driving forces behind Qrisp. In this story, he shares how a frustration with quantum programming evolved into an open-source language designed for the future of real-time quantum computing.
When I first started programming quantum computers, I quickly ran into a problem.
Not a physics problem.
A software problem.
“Even if you want to program something super basic like 3 plus 4, you easily spend hours writing it down and bug fixing it. “It gets super messy.”
At the time, I had recently transitioned from theoretical particle physics into quantum computing. During my studies, I focused heavily on quantum chromodynamics and the more fundamental side of physics. But after finishing my master’s degree, I knew I didn’t want to stay purely in academia forever.
I had always been deeply interested in programming as well, and quantum computing felt like the perfect combination of both worlds: advanced physics combined with real software engineering.
So I moved to Berlin and started working in quantum computing at Fraunhofer FOKUS for the first time. That’s where I discovered how difficult quantum programming still was.
Even implementing something conceptually simple could become extremely complicated. Tasks that would take minutes in classical software engineering could turn into hours of low-level programming, debugging, and manually organizing quantum instructions.
“That frustration eventually became the starting point for Eclipse Qrisp, an open-source quantum programming language I helped create and develop over several years. ”
What started as internal tooling at Fraunhofer FOKUS gradually grew into a broader open-source effort, now being developed jointly by Fraunhofer FOKUS and collaborators, including IQM.
Qrisp solves two major challenges in quantum computing.
The first is developer productivity.
Quantum programming today often requires enormous complexity for even relatively simple operations. Qrisp introduces abstractions, modularity, and reusable structures that make quantum software development cleaner and more maintainable, closer to how modern classical software is built.
“It’s simplifying the development workflow, making the code reusable, modular, exchangeable, and more tidy.”
But the second challenge is where things become even more technically exciting.
Qrisp enables real-time classical computation during quantum execution.
In practice, this means a quantum computer can perform a quantum operation, immediately execute classical logic, and then continue quantum operations, all within the coherence time of the qubits.
That entire cycle must happen within nanoseconds to microseconds.
This capability is critical for the future of quantum error correction and fault-tolerant quantum computing, two of the biggest technological challenges in the field today.
Many of today’s established quantum frameworks are not designed around these types of real-time workflows.
“What’s exciting is that at IQM we’re building the hardware to cater to this feature.”
Rather than software adapting to generic systems, Qrisp and IQM’s hardware are evolving together, designed to maximize the possibilities of real-time quantum computation.
Quantum computing is still a highly research-driven field.
Because of that, I strongly believe collaboration matters more than isolated development.
If every organization builds the same things independently in completely separate ecosystems, progress slows down significantly. Open collaboration allows researchers, engineers, and companies to learn from each other and push the field forward faster.
That’s one reason why the Eclipse Foundation became such a natural home for Qrisp.
It creates an environment where contributors are not simply building technology for one company. They’re contributing to a larger open-source ecosystem that multiple organizations can shape together.
At least at the current stage of quantum computing, I think this openness is extremely important.
As Qrisp matured, it started to gain attention across the quantum ecosystem. That momentum eventually led me to IQM.
I joined in 2025 to build and lead a Qrisp-focused team in Berlin while continuing to develop the technology together with the broader ecosystem.
At IQM, we are not only building software frameworks in isolation. We are actively developing hardware capabilities that support features like real-time computation workflows.
That interaction between compiler teams and hardware teams is incredibly exciting because it allows us to optimize the entire stack together.
It’s also one of the reasons why IQM is such an interesting environment to work in.
There is an extremely high concentration of quantum expertise across the company. You constantly learn from people working on completely different layers of the technology stack.
Coming from a stronger programming background myself, joining IQM significantly expanded my understanding of hardware execution and system-level challenges.
At the same time, the company culture remains very open and collaborative, which I appreciate a lot.
Right now, one of the biggest goals for Qrisp is enabling quantum error correction workflows and eventually supporting fully fault-tolerant quantum algorithms.
That is still a long journey for the entire industry, but we are already building many of the foundational pieces today.
If I could give one piece of advice to people wanting to enter quantum computing, it would actually be very simple:
Start building things.
Read papers, of course. Learn the theory. But most importantly, sit down and implement things yourself.
That’s where real understanding starts.
When you force yourself to build something, you also force yourself to understand all the small details and hidden complexities behind it. And sometimes, understanding those details deeply enough can lead to entirely new ideas.
That’s certainly how it started for me.
Search faster—hit Enter instead of clicking.
Click to expand
