Pascal Febvre’s software could simulate superconducting circuits. What it couldn’t do was install. With help from Commons Caretakers’ Eric Herman, a suite of twenty-odd interdependent programs that only really built on a Mac became a one-click download for seven platforms.
“It takes easily six months, one year to get used to it. And you spend your time doing that instead of focusing on the science.”
Pascal Febvre is a physicist at the Université Savoie Mont Blanc, in the French Alps. His field is superconducting electronics: circuits that run at enormous speed on almost no energy, next door to quantum computing, which is where most of the attention and most of the money currently sit.
The physics is awkward enough that you can’t reason your way to an answer. You have to simulate it and see.
“The physics of these systems is a bit complicated and we can’t get the intuition out of it. And so the software, the simulation, they help us to understand how it works.”
Which means the simulation software isn’t a convenience, it’s the instrument. And for a long time there wasn’t much of it that was open, affordable or any good. So Pascal and a rotating cast of students set about building some: Frugal EDA, an open-source design suite for superconducting circuits, pulling a schematic editor, a netlist converter, time-domain simulators and a layout editor into something a newcomer could pick up.
It was that last part that caused the trouble.
The challenge
The science was never the hard bit. They have the equations and the equations they can handle; what they couldn’t handle was making any of it usable by anybody else.
Academic software gets written by whoever happens to be passing through. A PhD student here, a master’s student on a six-month internship there, each on their own machine, each solving the problem in front of them. What builds up is a pile of code that works, in the sense that the science underneath is sound, and that nobody can install.
The cost of that lands on the next person through the door. Six months to a year, Pascal reckons, just getting to grips with the tools before you can do anything with them, with files everywhere, a different program for each stage and a permanent low-level need to tweak something to make it behave. Multiply that by every student and every collaborator and every curious newcomer, and the barrier around the field is one the field built itself.
So the objective was blunt. Go to a website, click, download, and it runs, whatever machine you happen to be on.
“We use many applications every day which are like that, but there is a lot of work inside, behind. We are not used to that usually, in science.”
The scale of it only became clear once they tried. This wasn’t one program needing three installers but a suite: around twenty pieces of software, several depending on libraries produced by the others, each needing to be compiled in the right order, on every platform.
“That was really too difficult.”
Discovering Commons Caretakers
Pascal found NLnet by way of the tools he was already borrowing. Hunting for a schematic editor that could draw symbols for devices nothing else supported, he came across LibrePCB, and behind it a community funded to keep the thing alive. Then KLayout at the fabrication end, which he rates as the best there is and well ahead of the expensive commercial packages everyone used to use, no two people on the same one. Frugal EDA would be the missing block in the middle.
“I saw there was a community behind this open-source software, also by funding it. And I found it interesting. That was the right place to do it, the right context as well.”
The application went in through SEFIRA, the non-profit that runs Frugal EDA, and the grant came through from NLnet’s NGI Zero Core fund at the start of 2025, in a process Pascal sets, with some feeling, against the administrative machinery he’s more used to. Then he hit the installer problem, went back to NLnet to ask how on earth you actually do this, and was pointed at Eric Herman at Commons Caretakers.
The first thing Eric gave him was a name for what he needed.
“I discovered this CI/CD system, which is used to install software. I didn’t even know the name before. I’m a physicist, so I’m not used to these computer science tools.”
The process
What followed was direction rather than delivery. Eric explained how to trigger automated builds, what runners were and how to use them, and where to go looking. Pascal took the pointers and worked outward from there.
“After, I could learn and check. But I didn’t know where to start from at the beginning. I was really lost.”
It’s the thing he keeps coming back to. The information was all publicly available, as it always is; what he didn’t have was any way of telling which parts of it mattered.
“You can find everything on the internet. The problem is to know what’s important and when it’s not. This is why you go to school instead of learning by yourself. You always get better information, because you have people who know what’s important, what’s not.”
He’s candid about the rest of it. There was a great deal of work after that first conversation and he leaned on AI coding assistants to get through the volume, checking each part as he went, reckoning it would otherwise have taken five years rather than one. He’s clear-eyed about the trade, too, and his analogy is satnav: you arrive easily enough, but you no longer know where you are.
The outcome
Before, there was a set of programs compiled on a Mac, not yet working on Linux, not yet working on Windows, with most of the effort disappearing into getting them to build at all.
Now it’s seven platforms: three or four applications, twenty or thirty codes underneath them, compiled in parallel by GitLab runners and assembled automatically into installers. The dependencies resolve in sequence, the output of one build feeding in as source for the next, which is the part Pascal says simply wasn’t possible before. Releases publish themselves. You go to GitLab, take the executable for your platform, and it works.
“You click and everything is installed. You have everything on your hard disk, several applications installed at the right place. You don’t even care about it, and you have some icons. You can start working. You don’t know what’s behind. You never open the hood to see the engine. And as long as it works, it’s fine.”
Frugal EDA is for education and for scientists who want to get on with the science. None of them should have to think about any of this.
When we spoke the release was days away, held up by the usual: six platforms behaving themselves and Windows falling over on a syntax difference. It has since landed, with an installer you double-click, a manual that walks through every screen of it and a guide that takes a newcomer to their first superconducting circuit.
The demand was already there. People had written in with problems Pascal couldn’t solve for them, not for want of knowing how, but because solving them properly was a bigger job than he could take on alone.
More than a deliverable
None of the CI/CD work was in the plan, and Pascal anticipated neither the difficulty nor the effort. What came out of it isn’t specific to superconducting electronics in the slightest.
“It’s a lot of work to make it work once, but then it’s ready. You can reuse it for any kind of software. You just need to plug your software inside, and to work for any platform.”
He reckons it’ll be useful to anyone maintaining a set of programs rather than a single one, which is a fairly common position to be in and a poorly served one.
It’s changed how he thinks about what comes next, too. Frugal EDA sits between LibrePCB at one end and KLayout at the other, and Pascal has started eyeing the idea of doing something deliberate about that: a consortium, the way you would for an international research project, with people like Eric in it from the start.
“We need to bring our brick as well. But after, you need to put all that together and build from that, because you can be more ambitious than just the bricks we are doing now.”
His advice to anyone in a similar spot is short and slightly rueful.
“Don’t try to reinvent the wheel. Ask, and then you’ll get the good advice to go in the right direction. It’s like asking our way.”
Could Commons Caretakers help your project?
If you’re a maintainer of a free and open-source project, you don’t have to do everything yourself.
Commons Caretakers supports grantees of the NGI Zero programmes and the wider NGI ecosystem with practical, hands-on help in areas including testing, accessibility, technical writing, internationalisation, technical mentoring, and more.
Engagements typically start with a single conversation.
Leave a Reply