This talk demonstrates the programmability of the Simodense RISC-V softcore running on an FPGA 1. The latest experimentation based on Simodense features runtime reconfigurability. Custom instructions can automatically be loaded during runtime on demand, using a recently proposed approach called "LUTstructions". LUTstructions are small FPGAs (essentially FPGA-on-FPGA when running on an FPGA) that are optimised for instruction implementation and fast reconfiguration 2. The prototype is entirely written in Verilog and is thus applicable to a variety of usage scenarios.

1 "Simodense: a RISC-V softcore for custom SIMD instructions" (GitHub repository) https://github.com/pphilippos/simodense

2 Philippos Papaphilippou "LUTstructions: Fast-Reconfigurable FPGA-Based Instructions" (in-press) IEEE/SBC SBAC-PAD 2026

wafer.space provides budget silicon manufacturing for the GF180MCU process.

In this talk, we will take a look back at the wafer.space shuttle runs and the challenges that came with them. Furthermore, I will highlight a number of impressive open-source designs, as well as some very useful community-created IP. Finally, I will provide an outlook on ongoing and future developments.

Memory arrays are typically the highest-defect-density block on a chip, yet the tools used to test and repair them at manufacturing time remain locked inside commercial EDA suites, with no real open-source equivalent.

AutoMBIST is an open-source generator that takes a memory macro from RTL through a genuine 2D row-and-column redundancy solver (BIRA, cross-validated against a brute-force oracle) and produces a synthesizable on-chip self-repair controller (BISR) that operates without any external tester. It has been demonstrated on real OpenRAM-compiled SKY130 SRAM macros, each wrapped in a full MBIST and self-repair block, hardened through LibreLane 3.0.5 to zero detailed-routing violations and clean LVS/power-aware signoff.

The talk covers the MBIST collar insertion & BIRA algorithm, a walkthrough of the autonomous on-chip self-repair flow, and the physical closure results.

Every EDA tool reimplements its own LEF/DEF/GDSII/Tcl readers. rawast replaces them with one universal engine where the grammar is data — a runtime .rawast file, not compiled code. One engine parses any text or binary format into a queryable value tree, and because it’s bidirectional, the same grammar re-emits the text too. It’s self-hosting, GDSII is the worked binary example, and a planned container lets downstream tools parse once and never re-parse. The PoC parses a 3,132-file production corpus across four formats. C++17 + Python, MIT.

For a long time, one of the crucial items missing in the open silicon ecosystem has been a formal equivalence‑checking tool capable of verifying modern‑scale architectures. Kepler‑formal provides exactly that, with an advanced multi‑threaded C++ core that can handle even large designs in a timely fashion. This tool adds another important building block in the journey toward industrial‑level development with open‑source EDA. It has already been adopted publicly by several key players in the open silicon community and also saw usage in the industry. In this talk, we will present the tool and its use model, as well as our roadmap in terms of format support and features.

https://github.com/keplertech/kepler-formal

Packaged silicon parts have finally arrived on-site in time for summer 2026, including the second Chipalooza test chip on Sky130 and new 3.3V support for GF180MCU on the first Wafer.Space shuttle run. All circuits are functional! Characterization results will be presented for the several dozen analog blocks on the Chipalooza test chips as well as for the 3.3V SRAM and I/O library components. I will report on continuing efforts to provide open source analog libraries for all of the open PDKs.

Many questions about a hardware design are about connectivity: what drives this signal, what does it fan out to, is there a combinational loop, does this path cross a clock domain? Slang Netlist is an open-source C++ library that answers these by building a bit-level dependency graph directly over an elaborated SystemVerilog RTL design. Working at the source level rather than lowering to gates keeps close correspondence to the RTL and compilation fast; building on the slang front end brings rich SystemVerilog support and optimised parsing, elaboration, and data-flow analyses; and it is easy to integrate with Python bindings. This talk covers how it works — turning slang's analyses into a queryable graph — how to use it via the CLI and Python, and several use cases, including synthesis-style lint checks and clock-domain-crossing (CDC) analysis.

While building netlist tools at keplertech.io, we kept missing a lightweight schematic viewer for browsing design connectivity and hierarchy. naja-schematic has been an internal project we'd now like to open to the community for use and collaboration. It's a small, fast viewer in C++ leveraging Dear ImGui for portability and WebAssembly capabilities. It currently loads naja data structures, but we are looking for ways to offer a general way to load any data structure.

Where do the liberty files come from? How to create own liberty files with open source tools? This talk introduces OpenChar, a new open-source standard cell library characterizer. OpenChar uses NGSpice to simulate standard cells and generate liberty files and Verilog models for them. The talk will focus on user visible features and compare OpenChar with other existing open-source solutions. We briefly look at the internal workings of OpenChar, and since SW is never finished, we will also talk about missing features and future plans.

AI agents can already execute EDA commands, but reliable chip-design automation requires more than shell access. Every tool has different invocation rules, environment assumptions, artifacts, logs, and definitions of success. This makes agent workflows difficult to reproduce, audit, and move between tools.

OpenADA is an open-source semantic interface between AI agents and open EDA tools. An agent expresses an engineering intent—such as netlisting a schematic, running a circuit simulation, checking DRC, comparing LVS, or structurally checking RTL—and OpenADA translates it into a deterministic native-tool operation. It returns structured evidence, including separate execution and engineering status, diagnostics, artifact hashes, provenance, and the assumptions affecting interpretation.

This talk presents OpenADA’s architecture and its current integrations with Xschem, ngspice, Xyce, KLayout, Netgen, and Yosys. A demonstration will show the same circuit-simulation intent executed through ngspice and Xyce while retaining each simulator’s native artifacts. The talk will explain how an open semantic contract can let EDA maintainers integrate once, allow researchers to swap backends, and keep agent-generated engineering results reviewable instead of reducing them to unbounded log summaries.

The initial cost for producing a chip is very high. Therefore, getting the design right on the first run is essential. To identify potential errors in the design before production, considerable effort is invested in testing and verifying the design.

However, the current practice of chip design verification uses languages with roots in the 80s. The Doppio project aims to modernize verification tooling by leveraging insights from software testing. This paper introduces a software-based verification framework. We propose a framework using modern programming languages, such as Java and Scala, to verify digital circuits.

Bucket is an open-source Python project for collecting and viewing functional coverage, first presented at ORConf 2024. Since then Vypercore shut down, Noodle-Bytes took the project on, and Bucket has been picked up by two more silicon companies, one of which uses it to cover software rather than hardware. This talk covers the many changes from the last two years, including the improved viewer, comparing coverage between runs, and a new archive format, along with plans for the future.

As open-source hardware becomes increasingly complex, interoperability and reuse have become major challenges. While software development benefits from high-level data type abstractions, standardized interfaces, package ecosystems, and implementation-independent specifications, hardware development remains largely centered around implementation-specific RTL, making component integration, portability, and collaboration more difficult. We need to reduce these interoperability hurdles to make collaboration between community driven open-hardware efforts more effective.
Tydi is an open hardware interface standard that addresses this gap by providing a vendor and technology-agnostic specification language for hardware interfaces and dataflow architectures. Tydi describes an interface at a high level by 1) a datatype and 2) a set of behavior parameters. By a principled reduction of this high-level description to the hardware interface implementation, Tydi enables component reuse across designs, easy composition, and verification across hardware description languages. Integration with open-source HDL tooling further improves the user experience of hardware design.
This talk introduces Tydi and its growing ecosystem of open-source tooling. We will discuss how Tydi enables automatic generation of interface code and documentation, improves composability of hardware IP, and serves as a stable specification layer for emerging AI-assisted hardware design and debugging workflows. The presentation will also highlight ongoing developments in generator tooling and ecosystem integration, demonstrating how Tydi contributes to a more interoperable, vendor-independent open hardware ecosystem. By providing a common specification layer for hardware component interfaces, Tydi aims to do for open hardware what interface definition languages and package ecosystems have done for software; enable reusable building blocks that accelerate innovation and strengthen the open hardware commons.

Machine learning accelerators are frequently designed, simulated, and left as RTL — verified against a testbench, never carried through to physical implementation. This talk follows one such design: a K-Nearest-Neighbors classifier (K=7, squared Euclidean distance, 64-entry reference set, 16-bit fixed-point inputs) built as a Verilog controller-FSM and datapath.

I integrate it as a memory-mapped coprocessor on an open RISC-V core and push the design through the open-source RTL-to-GDSII flow — Yosys, OpenROAD, and the SkyWater SKY130 PDK. The talk presents the implementation flow end to end, reports synthesis and physical implementation results as achieved by the time of the conference, and highlights specific engineering trade-offs encountered moving from RTL simulation toward physical implementation; including where a brute-force, single-cycle 64-way distance computation becomes the critical path once timing closure is on the table. This is a concrete account of what the gap between "verified in simulation" and "ready for physical implementation" actually contains.

Design rule checking is one of the last steps between a layout and a tape-out — and, in a fully open flow, often one of the slowest. Running IHP's SG13G2 rule deck through KLayout takes long enough to break the edit-check-fix loop, and because the deck is written for one engine and shipped inside the PDK, it is neither easy to reuse nor easy to run in isolation.

gdscheck grew out of a simple set of requirements: a DRC engine that saturates every core of a workstation instead of one; that carries its rules with it, so no PDK installation is needed to check a GDSII file; that lets a user run a single layer deck or a curated suite without writing a line of script; and that is regression-tested against per-rule test patterns, so a rule change cannot silently break a PDK.

This talk introduces gdscheck, an open-source DRC engine written in Rust. Rules are declarative YAML decks referencing layers by name; the hierarchy is flattened up front; every check fans out with rayon, with bounding-box pre-filters and a sweep-line search keeping spacing checks near-linear. Violations are written to a KLayout-compatible .lyrdb, so existing debug workflows are unchanged.

I will close with benchmark results against the reference flow on real SG13G2 designs, and outline what is still missing before the tool can be trusted for sign-off.

The key for end-to-end open source HW are OpenPDKs released by the manufacturers. At the moment, there are a handful of OpenPDKs, and we need more. In this talk I will summarize the case for Open PDKs and why they are more important than you think, the issues that are raised by manufacturers and finally what we have been doing recently to advocate for more Open PDKs.

This talk introduces the EuroCDP Open IP Library, a curated collection of reusable open-source Intellectual Property (Open IP) blocks covering digital, analog, mixed-signal, RF, and photonic design domains. The library forms part of the European chip design platform (EuroCDP) and provides openly accessible IPs that can accelerate and simplify Integrated Circuit (IC) development. The presentation will introduce the IP Readiness Level (IPRL) framework, describing the definition of each level and the associated maturity milestones used to assess the quality and reuse readiness of Open IPs. It will also present the structure and organization of the Open IP Library, together with the standardized format adopted for each Open IP entry, including metadata, documentation, and evaluation criteria. Finally, the talk will provide an overview of the resources that Will support the assessment, discovery, and reuse of Open IPs within EuroCDP.

One of the major complaints often leveled against cocotb is performance. coconext is an experimental cocotb fork which involves a major redesign to solve this problem by providing a first-class cocotb-like C++ API, while retaining the existing Python cocotb API, and providing communication between the two via a friction-less binding layer. This allows users to write tests, models, monitors and drivers, and all the other pieces of a testbench entirely in C++, Python, or whatever mix they deem appropriate. This talk will go over the rationale, features, a demonstration of performance gained by moving functional modeling to coconext, and the future of this project and related projects.

Open-source silicon has advanced rapidly for digital design, yet the analogue, mixed-signal (AMS) and RF domain remains the ecosystem's hardest gap-with fragmented flows, missing or immature tools, and open PDKs that seldom support a complete AMS path. This presentation introduces ODE4EC-AMS (Open Design Environment for European Chips - Analogue and Mixed Signal, Project No. 101252962), a three-year initiative funded by the Chips Joint Undertaking and carried out by a consortium of research institutes, universities and industry partners, created to close that gap by strengthening and connecting the open-source tools designers already rely on rather than replacing them. Starting in June 2026, the project aims to make mature technology nodes accessible for AMS product development and to lower the barrier to entry for SMEs and start-ups, and this talk maps its planned scope across the flow: improved open electromagnetic, RF and mixed-signal simulation and parasitic extraction (building on tools such as ElmerFEM, ngspice, Magic and KLayout-PEX), an automated framework for generating AMS and RF IP and layout, integration of these advances into open PDKs validated through Multi-Project Wafer (MPW) runs, and openly licensed training material to support wider adoption. As an early-stage introduction, the talk emphasises transparency and community-sharing the roadmap openly, explaining how results will be released under open licenses and sustained beyond the project's lifetime, and, above all, inviting the open-source hardware community to follow, test, use and contribute to the outcomes from day one.

Large Language Models (LLMs) are rapidly transforming hardware design, yet evaluating their true ability to generate correct Register-Transfer Level (RTL) code remains a moving target. Existing static benchmarks suffer heavily from data contamination, as newer models are continuously trained on open-source repositories containing the test questions themselves.

To break this cycle, we introduce NotSoTiny, an automated, living evaluation benchmark that turns the vibrant Tiny Tapeout open-source ecosystem into a continuous source of fresh evaluation data. Following its appearance at DAC 2026, this talk brings NotSoTiny home to the FOSSi community to explore how crowdsourced physical silicon designs and tools can drive the future of AI for chip desing.

NotSoTiny automatically ingests new designs from consecutive Tiny Tapeout shuttles. By leveraging an open-source evaluation pipeline built on formal verification and automated linting, it cleans duplicates and generates complex, structurally rich module-completion tasks. Because the dataset updates dynamically, it provides a contamination-resistant sandbox that reflects actual, human-designed hardware challenges.

In this presentation, we will detail the architecture of the NotSoTiny pipeline, share insights from evaluating state-of-the-art LLMs, and discuss how the open-source community can contribute to accelerate trustworthy AI-driven chip design.

Since introducing the IHP Open PDK and its accompanying open-source design flows, the ecosystem has continued to evolve well beyond its initial infrastructure. This presentation highlights recent milestones and provides an outlook on the next steps toward a broader and more accessible open hardware ecosystem. The talk begins with an update on the DI-OCDCpro project (Funding Code: 16ME0940), including the first collaborative chip designs submitted for fabrication through IHP's Multi-Project Wafer (MPW) program and an overview of the upcoming activities planned together with the project partners. Another focus is SG13CMOS5L, a CMOS-only technology variant that recently reached its first tape-out. Originally initiated within the DI-OCDCpro project, SG13CMOS5L is designed as a fast and cost-effective platform for education, student projects, prototyping and future open design challenges, while remaining fully compatible with the existing open-source ecosystem. Finally, the presentation concludes with an outlook on future community activities. Building on the experience gained so far, the talk will present the vision for additional open design challenges currently under preparation, aiming to further lower the barrier to ASIC design, strengthen collaboration within the open-source hardware community, and create new opportunities for education and hands-on chip design.

Authors: Kanchi Venkata Mahith, Daniel Große The effectiveness of a branch predictor varies significantly across software workloads, making it difficult to select and tune an appropriate predictor configuration without detailed insight into prediction accuracy and misprediction behavior. Existing approaches often require RTL instrumentation, dedicated performance counters, or processor-specific modifications.

We address this problem with a framework based on the Waveform Analysis Language (WAL), using the CVA6 open-source RISC-V processor as a case study. By analyzing branch-prediction behavior directly from simulation waveforms across benchmarks such as Dhrystone and CoreMark, the framework enables non-intrusive, workload-specific evaluation and supports informed configuration and microarchitectural exploration.

I'm working on an exploratory RISC-V VPU that scales to very large numbers of lanes. I've been developing it using only open-source tools, and the focus of the talk will be on that experience. I'll choose a small section of the design (probably a distributed systolic array that I'm currently working on) and use that design space exploration as an example.

Over the last seven years I've been teaching digital hardware design and FPGA development at the University of Wrocław. Along the way, the limitations of existing educational tools led to the development of DigitalJS: a visual hardware simulator which connects HDL code to the circuits described by it. Later, the Transactron library was developed in order to provide reliable hardware abstractions upon which the Coreblocks out-of-order CPU could be built.

This talk tells that story. I'll show how each project came about and how they made a difference in the teaching process. I'll also share what surprised me about teaching hardware, which concepts students consistently struggle with, and how open-source tools can lower the barrier to learning advanced computer architecture. As my background is in computer software (and programming languages in particular), I'll put some emphasis on how software and hardware worlds differ and what can they learn from each other.

Block-level verification of parameterised RTL relies on hand-written parameter sets chosen from designer intent, not the assembled design. As the SoC grows, the two drift, and that gap goes undetected, because what the design actually builds is known only after elaboration.

I present a Bazel build-integrated flow tool that derives block stimulus from the elaborated design: one cache-gated slang elaboration of the SoC top is inverted into a per-module manifest of the parameter tuples each module is really instantiated with, and each is run at test time through the block's existing testcases, deduplicated against hand-written corners with coverage merged across runs. Deriving configurations inside the build graph rather than committing them means new instantiations are verified on the next regression, with no manual refresh and no staleness. I discuss the load-time/execution-time boundary that shapes such flows and results from a widely instantiated block whose hand-written sweep was missing real configurations.

In this presentation the current state of project Arrakeen will be discussed. Focus will be on the advancements in the SRAM generator development done in the IHP FlowSpace project.

In this talk, we'll share the latest on the ongoing effort to expand Verilator's verification capabilities. We'll provide insight into the following developments:

• Four-state logic support is becoming usable on an experimental branch.
• The constrained randomization work continues, with significant improvements to the quality of generated stimuli.
• On the UVM side, what remains is bugfixing and scheduling improvements.
• SVA is close to feature complete, and the remaining work is bringing it into full IEEE compliance.
• Update on coverage and the tooling around it.

Safety- and radiation-critical systems need fault-tolerant CPUs, but the available options are predominantly proprietary solutions. This talk will present the ongoing work on Triple Modular Redundancy configuration of the VeeR-EL2 core, an open source RISC-V CPU hosted by CHIPS Alliance. This talk covers the current state of the implementation and introduces new open source tooling around Verilator built to enable fault injection testing and used for verifying the VeeR-EL2 TMR configuration.

[Vulkos](https://vulkos.co.uk] is a free, browser-based platform for young students and entry-level engineers to learn and practice chip design, verification and analysis using agentic AI. In this presentation, we'll demo some of the key features, student creations and future developments - and within 5 minutes we plan to do a live demo going from the sign up page to a verified, tapeout-ready GDS.

This talk takes a look at the Surfer waveform viewer for digital simulation with a focus on what has been added since last OrConf. This includes simulator integration, annotations, a memory viewer, and several new ways to customize what you see.

Mapping algorithms to area-efficient, time-multiplexed hardware architectures that meets the specifications is a non-trivial task, particularly with respect to scheduling, resource assignment, and generation of control logic. Manual pen-and-paper design is typically both difficult and error prone. B-ASIC is an open-source Python framework for the design and implementation of static algorithms. From capturing the algorithm as a signal-flow graph, through simulation and mapping, to automatic generation of synthesizable RTL and testbenches. In contrast to typical high-level synthesis flows, where the designer has limited influence over the resulting architecture, B-ASIC provides designers with granular control over operator and memory selection, scheduling, resource assignment, pipelining of control signals, and I/O.

APyTypes is a cross-platform Python library for simulating finite word-length effects in complex digital systems, intended for design exploration and bit-accurate co-verification. It provides configurable fixed-point and floating-point data types, including scalar, multidimensional array, and complex-valued classes. With a NumPy-like interface, APyTypes makes algorithm design simple while staying true to hardware. This talk introduces APyTypes, how it can be used, and potential future directions.

This talk will outline the activities and objectives of the CHIPS Alliance and newly formed OpenROAD initiative organizations.

The OpenROAD initiative is a non-profit organization focusing on making chip design open and accessible to all.

CHIPS Alliance hosts open source tools and IP blocks for ASIC development, and has a vision of aligning open source efforts towards building a tool suite for faster and more collaborative design and testing of silicon. The talk will discuss restructured SV Tools and VeeR projects as well as new developments in tools and cores hosted within CHIPS Alliance.

Software reuse works because a registry tells you what you are getting and you can run the tests. Silicon reuse has meant tarballs and PDFs.

Vyges VyCatalog is an open, machine-readable registry for silicon IP. Each block carries validated metadata describing its real RTL interface, filesets, and bus and PDK targets, and a CLI resolves and stages blocks the way a package manager would.

Vyges Loom is the other half: an open sign-off suite — geometric DRC, LVS, RC extraction, and static timing with signal integrity — so you can check what you pulled instead of trusting a datasheet. It is a second opinion alongside magic, netgen, KLayout and OpenSTA, not a replacement. Critical path delay correlates within about 1.6% of OpenSTA on synthesized sky130 designs.

The talk shows both, and the limits of each. https://vyges.com

Software has had CI for two decades. Hardware still finds most of its bugs at the bench, even while we use incredible physics sims for film and ML. Hauksbee closes this gap: it takes a real PCB design file (KiCad, Eagle, Altium, or gerber-only), parses the circuit, and simulates the hardware on each commit, so a fault that used to cost a fab spin and a fornight fails in minutes instead.

The tool exists because of a blind spot. Tarski, an analogue neuromorphic accelerator built at the University of GAlway, had a bespoke emulator (requiring significant time investment to built) integrating the intended circuit in closed form. Fast, but structurally incapable of seeing miswirings, or unnaccounted for behaviour, because it only ever simulated the design we wanted, not what was built. Hauksbee simulates exactly what you have laid out in a PCB file.

This talk covers what that means in practice: partitioning a board so linear islands get fast matrix-exponential solves and nonlinear islands get MNA and Newton; co-simulating firmware against the analog board in lockstep so a GPIO the code drives moves the simulated copper; and validating it against ground truth. This included re-deriving the Raspberry Pi 4’s shipped USB-C fault cold, from spec thresholds alone, matched to the real physics to within 0.01%.

I’ll also cover what happened when the tool was pointed at unreviewed, open-source boards: three previously unreported hardware defects, and one firmware-triggered ignition fault only a copper-to-silicon-to-firmware co-sim could have caught.

Slang-server is a SystemVerilog language server that debuted last year at ORConf. It has custom client extensions for Vscode and Neovim that extend the LSP with hardware features, enhancing the functionality when a design is specified. This talk will go over features added in the last year, planned features and tools, and news in the related Slang ecosystem

Logic synthesis is a key step in the chip design flow. By abstracting away many physical implementation details, it has also provided a fertile platform for academic research. At UC Berkeley, this line of work began with ESPRESSO and SIS and later achieved broad impact with ABC, which has become a foundation for much of modern logic synthesis research and serves as the core optimization engine in Yosys. More recently, mockturtle, developed at EPFL, has revisited and refined many synthesis algorithms in a clean, modern C++ framework, emerging as an important new platform for research.

This presentation will give an overview of these open-source logic synthesis efforts. We will first introduce the core intermediate representations and state-of-the-art optimization techniques. We will then discuss directions for the next generation of synthesis, including hierarchical and word-level optimization upstream and physically aware optimization downstream, as well as practical benchmarks from the PULP platform developed at UniBo and ETHZ to help drive improvements in synthesis tools.

Open-source EDA tools lower the barrier of entry to IC design by lowering tool costs, allow inspectability and modifiability, and reduce supply chain dependencies. This talk presents a summary of the state of open-source EDA tools for integrated circuit design. It describes the findings of analysis and the resulting report which have been carried out in the context of EuroCDP. The work covers the domains of digital, photonics, analog & mixed-signal and radio frequency design. The talk presents conclusions on the maturity of toolflows, and the results of a gap analysis which identified tool functionalities and features that are either missing or would benefit from further improvements.