The Aachen Lineage

A View from the Watchtower

How one German institute built virtual prototyping — twice — and why the people who shape this field keep coming from the same place.

Every few years, someone announces that virtual prototyping is dead. The models are too slow, too expensive, too proprietary; the schedules never seem to allow time to build them; the incumbents quietly fold the products into a larger suite and stop talking about them. And then, just as reliably, virtual prototyping comes roaring back — because the alternative is taping out a chip and hoping the software runs.

If you have been in this industry long enough, you have lived through at least two of those cycles. You remember the ESL boom of the 2000s, the consolidation that followed, and the long quiet stretch when "virtual platform" was a phrase you only heard inside the big three. You may also have noticed something stranger, something that does not show up in any market report: an improbable number of the people who built this field — then and now — trace back to a single mid-sized city near the point where Germany, Belgium, and the Netherlands meet.

That city is Aachen. This is the story of why.

Run the software before the silicon exists

Strip away four decades of jargon and a virtual prototype is one idea: an executable model of a chip, fast enough to boot real software, available before the hardware is. Instead of waiting for first silicon to find out whether your firmware works, you run it against a simulation of the system on day one of the project. The discipline that grew up around this idea was once called hardware/software co-design, and its promise never changed — shorten the schedule, raise design productivity, and catch the expensive bugs while they are still cheap to fix.

The hard part was always performance. A model accurate enough to be trusted is usually too slow to be useful, and a model fast enough to be useful is usually too abstract to be trusted. The history of virtual prototyping is, in large part, the history of engineers trying to escape that trade-off — and the breakthroughs that mattered tended to come not from the established tool vendors, but from academia and the start-ups it spun out.

SystemC, the Lego promise, and the great consolidation

The modern era began with a language. In the late 1990s, SystemC gave hardware and software teams a common modeling substrate built on C++; the Open SystemC Initiative shepherded it into a standard, and it became IEEE 1666 in 2005. A few years later, the TLM-2.0 transaction-level modeling standard arrived with a seductive pitch: models from different vendors would snap together like Lego, and assembling a full virtual platform would become a matter of clicking blocks into place.

For a while, the market believed it. A wave of companies formed around the promise — Virtio for software-development prototypes, VaST for fast processor and subsystem models, Virtutech with its Simics platform, and CoWare for hardware/software co-verification. Then came the squeeze. Synopsys acquired Virtio, then VaST, then CoWare, and in 2011 folded all three into a single product, Virtualizer. Intel and Wind River absorbed Virtutech. Cadence and Mentor built their own platforms. Within five years, an entire competitive landscape had collapsed into three suites.

And here is the part the veterans remember most clearly: the Lego promise never fully arrived. The models that shipped were proprietary and binary-only, expensive to license and impossible to crack open. Simulation speed sagged as systems grew more complex. The off-chip interfaces that mattered most for real software development were precisely the ones the standard struggled to cover. Virtual prototyping worked — for the handful of companies with the budget and the patience — but it never became the default, ubiquitous layer the early enthusiasts had imagined.

Why does so much of this keep coming from Aachen?

Pull the thread on the technology that ended up inside those consolidated suites, and a pattern emerges. It does not run through Silicon Valley. It runs through the Rheinisch-Westfälische Technische Hochschule — RWTH Aachen — and, more specifically, through one institute and the people it produced.

In 1977, after more than a decade in industry, Heinrich Meyr took a professorship in electrical engineering at Aachen and founded the institute that would become the Institute for Communication Technologies and Embedded Systems, known as ICE. Meyr was a communications theorist by training, but he had an entrepreneur's restlessness, and over the following thirty years he turned that institute into something rare: a place where processor modeling, compiler technology, and system-level simulation were taught and researched as a single discipline — and where the best of that research was deliberately pushed out into companies.

The list of those companies is the answer to the question.

Read that list again. The COSSAP suite that became part of Synopsys; the modeling technology that ARM bought; the LISA-based processor design tools that flowed into CoWare and then into Synopsys, where they still underpin the company's application-specific processor offerings — all of it grew out of one institute, founded by one professor, in one city. Meyr did not just write papers; he built a pipeline that turned academic research into shipping EDA products, and then trained the people who ran them.

Because that is the other half of the story. The institute's graduates did not just found companies — they staffed the field. Walk into the virtual-prototyping group at a large EDA vendor today and you will find Aachen alumni: the engineers and architects who carried transaction-level modeling, dynamic binary translation, and system simulation from the lab bench into the products the whole industry now depends on. The chair Meyr founded passed to Rainer Leupers, who built it into a powerhouse for processor modeling, multiprocessor SoC platforms, and the very virtual-platform technology this story is about.

It isn't the water. It's the apprenticeship.

It is tempting to file "why Aachen?" under regional charm — something in the air, something in the beer. The real explanation is more useful and more durable. Three things compound there in a way they rarely do elsewhere.

First, a unified discipline. Most universities teach compilers, computer architecture, and system simulation as separate subjects taught by separate people. Aachen treats them as one problem — how do you describe a processor, generate its tools, and simulate it fast enough to run real software? That is exactly the problem virtual prototyping has to solve, and the institute has been solving it, continuously, for over forty years.

Second, a culture of shipping. Meyr's model was never "publish and move on." It was "publish, then commercialize, then come back and do it again." COSSAP and the LISA toolchain are among the few academic research projects that genuinely crossed into industrialization. That ethos — that good research is supposed to leave the building — is now institutional. RWTH Aachen produced 101 spin-offs in 2021 alone. The university is, functionally, a manufacturing line for deep-tech companies.

Third, generational continuity. The thread never broke. Meyr trained Leupers; Leupers trained the next generation; and that generation is now founding the companies that will define the next era. A lineage is not a coincidence you can copy. It is an apprenticeship system measured in decades — and it is why, when something genuinely new appears in virtual prototyping, the smart money checks Aachen first.

The thread reaches 2022

In 2022, a new company emerged from stealth in Aachen — a spin-off from Meyr's old institute, founded by Lukas Jünger and Jan Henrik Weinstock, with Rainer Leupers as its academic anchor. Its name is MachineWare, and its first product was a RISC-V simulator fast enough to run full software stacks in real time. It is built, knowingly, on the same intellectual inheritance that produced COSSAP, LISA, and CoWare — but rebuilt for an era the founders of that earlier wave could only have imagined: custom silicon everywhere, software leading hardware, and AI rewriting what the lifecycle is for.

That is the part of the story worth its own chapter — what changed, why the old virtual-prototyping playbook stalled, and why a SystemC-native, open, JIT-fast platform fits the EDA 3.0 era so precisely. We will get to it next.

For now, the foundation stone: this field has a center of gravity, and it has had one for almost half a century. When you understand the lineage, the next move stops looking like a start-up's gamble and starts looking like exactly what it is — the latest expression of the longest-running tradition in virtual prototyping, picking up the torch at the moment the industry needs it most.

Read more about MachineWare