RISC-V EU Summit 2026: An Ecosystem Coming of Age

Reflections on the Summit

I recently returned from the RISC-V Europe Summit 2026 in Bologna and, like many attendees, I came away energized by the announcements, the technical discussions and the sheer number of people building products around RISC-V. But the thing that struck me most wasn’t a particular processor, benchmark, board or product launch. It was the change in the conversation itself. A few years ago, many discussions around RISC-V centred on potential. What could it become? Which markets might it disrupt? Which software stacks might eventually arrive? In Bologna, the conversation felt fundamentally different. Now, the discussion was about execution. Which platforms are shipping? Which software stacks are production ready? How do we scale from embedded systems into AI, automotive, mobile, cloud and datacenter deployments?

As someone who spent sixteen years at Arm helping build platforms, software ecosystems and industry partnerships before joining SiFive, that shift resonated deeply with me. One of the lessons I learned during those years is that processors matter but in the end robust ecosystems determine success. Software architecture. Developer experience. Shared investment. Community alignment. Those are the signals I look for when trying to understand where an ecosystem is heading.

They were everywhere in Bologna.

This blog is a personal reflection inspired by RISC-V Europe Summit 2026. I wanted to capture observations on the maturation of the RISC-V software ecosystem through the perspective of someone who spent many years helping build the software ecosystem at Arm and is now helping drive the future through SiFive and RISE.

Section Summary

Executive Summary

The Most Exciting Thing Wasn’t a Product

Software Has Become the Main Story

Open Source Software Is Becoming the Architectural Language

Common Targets Create Confidence

AI Is Raising the Bar for the Entire Ecosystem

Ecosystems Mature When They Start Prioritising

Looking Through an Arm Lense

Leaving Bologna Optimistic

The Most Exciting Thing Wasn’t a Product

One of my favorite aspects of the week wasn’t any individual keynote or product announcement. It was the conversations between sessions. You would leave a talk on Android readiness, find yourself discussing firmware architecture over coffee, walk into a session on AI software, then spend lunch talking about virtualization, security or developer tooling. Those conversations often involved people from completely different parts of the ecosystem. Silicon vendors. Commercial software companies. Open-source maintainers. Linux developers. Hyperscalers. Standards bodies.

Increasingly, everyone seemed to be talking about the same problems. That may sound like a small observation. I don’t think it is. Healthy ecosystems eventually converge on a common understanding of the challenges that matter most. The history of computing is full of technically capable architectures that struggled because the software ecosystem lacked a common direction.

Walking around the summit, I came away with the opposite impression. The RISC-V ecosystem is increasingly moving together.

Software Has Become the Main Story

This was my first ever RISC-V summit and I was told that one of the biggest changes compared to earlier ones was the prominence of software. Of course there were exciting processor announcements, but many of the most interesting discussions were about compilers. Operating systems. Virtualization. Firmware. Security. Developer tooling. AI runtimes. Platform specifications. In other words, the software infrastructure that ultimately determines whether developers choose to build on a platform.

One of the recurring themes throughout the summit was the growing role of RISE, the RISC-V Software Ecosystem Alliance. RISE was visible across many of the conversations taking place in Bologna; not because it was promoting a single project, but because it is helping coordinate investment in foundational software that benefits the entire ecosystem. Compilers. Language runtimes. Kernel and virtualization technologies. Firmware. Security software. Microcontroller software.

These are the components that every company depends upon, yet historically have often been developed independently. Organizations such as RISE help change that equation. Instead of fragmenting effort, companies can collaborate on common infrastructure while continuing to innovate and compete in the products they ultimately deliver.

That collaborative mindset was visible throughout the week.

One of the aspects of the summit that resonated most with me personally was seeing the progress of initiatives I’ve had the privilege to help shape through RISE. As lead of the RISE Security Software Working Group, and more recently as one of the people helping launch the Microcontroller Software Working Group, I spend much of my time thinking about where collaborative software investment can have the greatest impact. Not simply what software should exist, but what software the ecosystem should build together.

During the summit, it was encouraging to see that broader conversation emerge across many different organizations which suggests that the ecosystem is becoming increasingly aligned on technology, as well as priorities.

Open Source Software Is Becoming the Architectural Language

One observation genuinely surprised me.

Many of the most interesting software conversations I had during the summit weren’t with open-source developers but with companies building commercial software products around RISC-V. What struck me was how often those conversations naturally gravitated towards upstream open source software projects. Not because those companies intended to ship upstream software directly but because those projects had become the common point of reference. Increasingly, open source is doing more than providing software, it is providing a shared architectural language.

In my years at Arm, I saw how successful ecosystems eventually converge around a set of common software architecture themes like: platform abstraction, firmware frameworks, security architectures, virtualization, operating system interface and developer tooling. Eventually these ideas become so familiar that people stop noticing them.

What fascinated me in Bologna was seeing many of those same architectural principles being rediscovered: not copied, but reimagined in distinctly RISC-V terms.

Across firmware, operating systems, virtualization, security and platform software, the ecosystem is increasingly developing RISC-V-native solutions to problems that every successful computing platform must eventually solve.

Open-source projects are playing a critical role in that process. They provide a place where ideas can be explored, challenged, refined and adopted across company boundaries. They create a shared understanding of what works, what scales and what developers can depend upon.

That, in turn, gives commercial software vendors a stable architectural foundation upon which they can innovate and differentiate. There were representatives from areas as diverse as Automotive and Aerospace learning how to leverage the RISC-V architecture as best as possible when porting their commercial software - all by using Open Source Software as the template.

To me, this represents a fascinating evolution. The relationship between open source and commercial software is often portrayed as a competition. What I increasingly see is a partnership. Open source establishes common architectural patterns and commercial software implements those patterns uniquely and then builds differentiated products on top of those patterns. Both reinforce one another.

The conversation is gradually shifting from “How do we make RISC-V look like existing architectures?” to: “How do we achieve the same or better outcomes, using RISC-V’s own architectural foundations?” For me, that was one of the clearest signs that the ecosystem is maturing.

Common Targets Create Confidence

Another theme that appeared repeatedly throughout the summit was the importance of common software targets. One of the biggest challenges facing RISC-V software has been fragmentation. Different implementations exposed different capabilities, making it difficult for operating systems, distributions and application developers to establish a predictable software baseline.

The increasing adoption of RVA23 is changing that. Linux support is now upstream and major Linux distributions are aligning around the profile while toolchains increasingly can optimize for a common target.

As someone who has spent much of his career thinking about software architecture rather than processors, I cannot overstate the importance of this. Developers invest where they have confidence.

Profiles such as RVA23 don’t just improve compatibility, they also reduce uncertainty and reducing uncertainty is one of the most effective ways to accelerate ecosystem growth.

Android readiness felt similar. Only a few years ago, discussions centred on whether Android could run on RISC-V at all, but today the conversation has moved on. The focus is increasingly on application compatibility, optimisation, validation, developer experience and ecosystem scale. Those are engineering problems rather than existential problems, which is a subtle distinction, but an important one. It is another indication that the conversation has shifted from enablement to refinement.

AI Is Raising the Bar for the Entire Ecosystem

It was impossible to attend the summit without noticing the influence of AI. A few years ago, discussions around RISC-V were largely centred on embedded systems and microcontrollers and those conversations remain important but the scope of ambition has expanded dramatically.

Across the summit, AI was discussed not simply as another workload, but as a forcing function for the entire ecosystem. Modern AI systems stress every layer of the software stack including: compilers, language runtimes, operating systems, memory management, virtualization, security, platform management and developer tools.

What struck me most wasn’t simply the presence of AI, but the breadth of the conversation. Within the same event, it was possible to move between discussions about microcontroller-based AI inference, embedded intelligence, automotive platforms, edge computing, application processors, cloud infrastructure and large-scale datacenter systems. That breadth matters as it suggests that RISC-V is increasingly being viewed not as an architecture for a particular market segment, but as a compute architecture capable of spanning the entire continuum of modern computing.

For those of us working on system software, that is particularly exciting. AI workloads have a habit of exposing weaknesses in platform architecture. They stress performance, scalability, resource management, observability, security and system coordination in ways that many traditional workloads simply do not. In many respects, AI has become one of the best measures of ecosystem maturity.

Ecosystems Mature When They Start Prioritizing

One of the most encouraging themes I observed throughout the summit was something subtle. The ecosystem is beginning to agree not just on what can be built, but on what should be built together. That is an important distinction.

Early-stage ecosystems naturally spend much of their effort proving capability. Can it compile? Can it boot? Can it run Linux? Can it execute an AI model? Eventually those questions become less interesting and the focus shifts towards identifying the highest-leverage investments. Where should the ecosystem collaborate? Which software components create the greatest benefit for the greatest number of developers? I see this increasingly within the work being undertaken through RISE.

Take embedded AI, as one example, where there appears to be growing convergence around LiteRT Micro as the front-end framework for many RISC-V microcontroller AI workloads. That convergence is valuable because it allows the ecosystem to focus effort where it creates the greatest impact. Rather than fragmenting across multiple front-end frameworks, the community can invest in highly optimised inference kernels exploiting RISC-V architectural capabilities such as the Packed SIMD (P) and Vector (V) extensions. This is one of the opportunities we are beginning to explore within the newly launched RISE Microcontroller Software Working Group. The goal is not simply to enable AI workloads on RISC-V microcontrollers, but to provide high-quality, maintainable and openly available software building blocks that benefit the entire ecosystem.

DSP software presents another exciting opportunity. Historically, much DSP software has evolved within proprietary environments, often resulting in duplicated effort across vendors. I believe there is an opportunity to take a different approach. Rather than attempting to solve every possible DSP problem, the ecosystem can rally around a handful of representative workloads—audio processing, predictive motor control and biomedical instrumentation, for example—and build world-class open-source reference implementations.

These projects can do far more than produce useful software. They would establish benchmarks, demonstrate architectural capabilities, create optimization targets and, importantly, provide reference designs that silicon vendors, commercial software providers and application developers can build upon.

The same philosophy applies equally well to application-class systems. Whether the challenge is AI inference, virtualization, confidential computing, security or platform management, progress accelerates when the community identifies a small number of strategically important software investments and executes them exceptionally well.

The challenge is no longer identifying work that can be done but to identify work that should be done together. That, perhaps more than anything else, was the conversation I found myself having repeatedly throughout the week.

Looking Through my Previous Arm Lens

People often ask me how my years at Arm influence the way I look at RISC-V and the answer is: constantly. It is important to note that RISC-V is not intended to be another Arm. Instead, the ecosystem is establishing its own identity as the premier Open Standard architecture. Every successful ecosystem ultimately develops its own identity, but I do recognize certain patterns. The moments that really matter are rarely the launch of a single processor but progress accelerates when ecosystems begin aligning around common foundations.

Sharing is key. Shared software targets. Shared architectural patterns. Shared standards. Shared tooling. Shared investment. That is precisely what I felt was happening throughout Bologna. I found myself reflecting on conversations I had many years ago while helping build the Arm software ecosystem. Back then we were wrestling with many of the same questions. How do you reduce fragmentation? How do you establish common software targets? How do you encourage companies to collaborate on infrastructure while continuing to compete through innovation?

The technologies have changed. The questions have not.

The difference today is that RISC-V has the advantage of learning from decades of industry experience. Rather than recreating every step taken by previous ecosystems, it has the opportunity to adopt proven architectural ideas while expressing them in ways that are uniquely RISC-V. That, to me, is one of the most exciting aspects of where the ecosystem finds itself today. It is no longer trying to imitate. It is increasingly finding its own voice.

Leaving Bologna Optimistic

I did not leave Bologna believing that all the hard problems have been solved. Far from it.

There is still an enormous amount of work ahead. Performance must continue to improve. Software stacks will continue to mature. Developer experience can always become better. The ecosystem will need to continue growing across every layer of the stack.

But I did leave with something I hadn’t fully expected. A sense that the industry is increasingly aligned on the right problems. Many of the conversations I remember having only a few years ago about missing software, missing standards and missing ecosystem pieces have evolved into discussions about optimization, deployment and scale. That is a very different place to be.

The summit also reinforced something I have believed for a long time. Processors create opportunity. Software ecosystems create adoption. The companies represented in Bologna will continue to innovate and compete, as they should, but increasingly, they are also collaborating on the software foundations that will benefit everyone, and to me, that is one of the strongest indicators of long-term ecosystem health.

Having spent much of my career helping build one successful computing ecosystem, I find it incredibly exciting to now be contributing to another through SiFive and RISE. If RISC-V Europe Summit 2026 demonstrated anything, it is that RISC-V is no longer defined primarily by what it might become, it is increasingly being defined by what the ecosystem is already building together.

From where I was standing in Bologna, the future of RISC-V software has never looked more promising.