This talk outlines the University of Toronto ASIC Team's initiative to democratize silicon engineering by leveraging the Free and Open Source Silicon (FOSSi) ecosystem.

By adopting open-source tools the team enables undergraduates to experience the complete design cycle, resulting in tangible tapeouts through services like TinyTapeout. The presentation will detail the team's extracurricular impact—including the university's first IC Design Hackathon—and its strategic partnership with the ECE faculty to rewrite and modernize core course laboratories. This integration of open-source methodologies into both student competitions and formal lab curricula demonstrates a scalable model for making engineering education more practical and industry-relevant.

Mr. Scrub is an open-source, internal scrubber for AMD’s UltraScale FPGAs. We document the algorithms used for SECDED of the device’s configuration frames. We also describe validation of the scrubber using fault injection.

FSMs drive the control plane of hardware: sequences, protocols, arbitration, and recovery logic. Despite language evolution, the way FSMs are written often has not changed. Many "high level" HDLs still express sequencing using the same legacy structure: explicit state variables, explicit transitions, and growing scaffolding as designs evolve. This talk shows a few concrete examples where modern syntax and tooling still lead back to the classic FSM pattern, and why that pattern becomes brittle at scale. Then we focus on the hidden gem: Bluespec. With guarded atomic actions and sequencing as first-class concepts, Bluespec changes the shape of FSM code, making control intent clearer and large stateful behavior more maintainable.

The design of advanced Analog chips‚ especially in photonics, quantum, MEMS, and RF, faces critical challenges due to rigid, outdated EDA tools. Many teams resort to custom Python, C, or MATLAB solutions, which offer flexibility but lack scalability. To bridge this gap, we created GDSFactory, an open-source, python-based Analog Electronic Design Automation software that has been downloaded over 2 million times and adopted by companies, universities, and research organizations worldwide.

Open-source RISC-V cores such as VexRiscv offer flexible architectures for embedded FPGA and ASIC implementations, but instruction cache configurations significantly influence performance, area, and power trade-offs. This work presents a quantitative analysis of instruction cache optimization within the VexRiscv core, evaluating performance impacts across multiple cache configurations in resource-constrained environments. Through synthesis and benchmarking on FPGA and ASIC-targeted workflows, we analyze utilization, and efficiency metrics to identify optimal design trade-offs. Results demonstrate measurable improvements in performance-per-resource metrics. These findings provide practical guidance for designers leveraging VexRiscv in customized RISC-V implementations.

As python-based build systems such as FuseSoC and SiliconCompiler gain adoption across the industry, projects are becoming increasingly tied one ecosystem or another. This lock-in limits teams' ability to use hardware IP and leverage tool flows developed in other ecosystems.

This presentation introduces a new approach for interoperability between build systems, along with a supporting library that enables compatibility between FuseSoC's cores and SiliconCompiler's libraries. By lowering switching costs, we aim to increase IP reuse, reduce engineering duplication, and allow teams to choose the right tool for each stage of the design process

After the shutdown of Efabless in February 2025, Cadence ran their first shuttle on Sky130 with a generous invitation to the open source silicon community. I submitted five chips: Tiny Tapeout TT-06, to compare to the Efabless shuttle run; TT-09, a copy of the original lost Efabless TT-09, and TT-Cad25A, a combination of projects from TT-08 and the never-manufactured TT-10; Chipalooza projects 2, the second of the two planned analog projects chips from the Efabless Chipalooza contest; and Panamax FPGA, a demonstration of the 130-pin "Panamax" frame with a Fabulous FPGA project core. I will present on challenges of the tapeout as well as test results from the manufactured parts.

Open-source silicon reaching real products is the moment the ecosystem matures from a research tool into infrastructure — the same transition Linux made when it started running production servers. Products impose the constraints that drive quality: a battery life target forces low- power verification, a temperature spec forces worst-case timing closure, a BOM cost goal forces die area discipline. These are the rigors that transform open IP blocks from tapeout artifacts into components the industry can trust, and that open custom silicon to the thousands of product companies that have never had access to it. The open-source stack is ready for this — open PDKs, automated RTL-to-GDSII, a proven SoC harness, and shared-wafer shuttles that make silicon accessible. The tools are no longer the barrier. The next step is ours to take.​​​​​​​​​​​​​​​​

Open-source electronic design automation (EDA) tools and accessible fabrication platforms are transforming how integrated circuits are designed, enabling broader participation in silicon development beyond traditional industrial environments. The Chipathon is a global open-source IC design challenge organized under the IEEE Solid-State Circuits Society (SSCS) PICO (Platform for IC Design Outreach) initiative. The program aims to democratize chip design by providing students, educators, and researchers with a structured pathway to design, verify, and potentially fabricate integrated circuits using open-source tools and publicly accessible process design kits.

The Chipathon combines a multi-month design competition with a culminating workshop where participants present their designs, methodologies, and lessons learned. Teams develop innovative circuit blocks and systems across multiple tracks, including digital systems, analog and mixed-signal circuits, AI-assisted design flows, and reusable open-source building blocks. Emphasis is placed on reproducibility, open collaboration, and transparent evaluation through shared design artifacts, verification methodologies, and benchmark metrics.

By integrating education, open-source infrastructure, and real silicon opportunities, Chipathon lowers barriers to entry for integrated circuit design and fosters a new generation of hardware innovators. The program also serves as a testbed for emerging design methodologies—including AI-assisted EDA workflows—and promotes the development of reusable circuit intellectual property for the open-source hardware ecosystem. Through its global participation and collaborative spirit, Chipathon advances the SSCS mission of expanding access to chip design education and accelerating innovation in the semiconductor community.

The award-winning FuseSoC is the world's most widely used package manager for chip design and powers everything from small hobbyist FPGA projects to multi-billion transistor ASIC tapeouts on leading-edge nodes.

Despite the benefits, there is often a fear associated with moving to a new system. As FuseSoC developers, we often hear "It won't work for our code base" or "we have some special requirements". Well, my friends. This presentation is for you. It is also for all of you who are already using FuseSoC but perhaps hasn't picked up how to unlock its full potential. We will look at some of the convenient features that sometimes are missed, adaptations that are often used when FuseSoC is introduced into an existing code base as well as sorting out some common misconceptions that we have come across when working closely with FuseSoC users with large code bases.

Analog integrated circuit layout remains intensely manual, requiring weeks of expert effort. We present CLARA's multi-objective reward function that decomposes layout quality into interpretable components: symmetry, compactness, connectivity, and device grouping. Unlike sparse terminal rewards, our graduated penalty system provides dense feedback that scales proportionally to constraint violations. Validation across three SKY130 circuits demonstrates convergence from severely constraint-violating states to fully feasible layouts, with device grouping driving optimization while revealing fundamental trade-offs between matching and geometric efficiency.

Building on our ORConf 2025 verification in Verilator (https://fossi-foundation.org/orconf/2025#advancing-design-verification-with-verilator) presentation, in this talk we'll dive into further progress Antmicro and others have made with regard to Verilator's verification capabilities. We will cover topics like improvements to UVM compatibility, developments in assertion support, an overhaul of force/release statements, and the next big step for Verilator: four-state logic. We will also touch on tools that helped us get here, such as sv-bugpoint or CHIPS Alliance's sv-tests.

Erbium is the first tapeout of AIFoundry's open-source manycore ASIC platform for parallel computing acceleration. This 8C16T RISC-V SOC with Vector and Tensor extensions is targeted towards the EdgeAI application space. In this talk we will cover

1. The ISA, Memory and SOC design.
2. The design process.
3. Verification Flow.
4. The current state of opensourcing the design.

Attendees will learn about the opensource components that can be reused in their design and contributing to the growing community of Silicon and Software developers at AIFoundry.

Coding agents and agentic software development are changing EDA development, most visibly and straightforwardly in the realm of permissive open source. Recent advances span agentic flow tuning and local optimization; repo-scale, closed-loop autonomous coding pipelines; and bespoke EDA tools and flows to achieve design-specific optimization goals. At the same time, models, multi-agent architectures, and value propositions are also rapidly evolving. Open-source EDA thus faces a host of new challenges – validation and evaluation; balancing of humans and agents; IP and creators’ rights; project and ecosystem governance; and many more. This talk will give some thoughts on the above – recent progress, emerging challenges, and new opportunities – from the perspective of the OpenROAD project.

Introducing a new addition to your quiver of PeakRDL tools: PeakRDL-PyRAL Register abstraction layers provide a mechanism to manipulate your device's configuration and status registers (CSR) by name rather than by cryptic addresses and bit-slicing. In Python, this abstraction is often provided using auto-generated Python code that is parsed and imported at runtime. For larger designs, this can become a significant burden due to slow load times and large memory overheads. Learn how PeakRDL PyRAL avoids this issue and provides an easy to use abstraction layer that can scale to enormous SoC-level designs that contain thousands of memory-mapped registers. PeakRDL-PyRAL is flexible enough for anything from embedded applications, hardware test instrumentation, to your next cocotb testbench.

The TinyTapeout FabricFox breakout brings an FPGA onto a board pin-compatible with the TinyTapeout demoboard, enabling designers to validate their synthesized implementation on real hardware before committing to silicon.

This talk covers how the breakout slots into the open-source ASIC design flow: local or github-action based hardening, a unified microPython SDK for project selection and hardware control, and custom Python or microcotb for hardware-in-the-loop testbenches that mirror simulation. The same demoboard hosts both FPGA prototype and final ASIC--making physical validation a first-class step in the loop, not an afterthought.

The result is a tight, open-source loop from simulation → FPGA → silicon that dramatically accelerates iteration while keeping every step reproducible and accessible to the FOSSi community. Come see how this tiny board closes the gap between prototype and tapeout.

Substrate is an open-source, statically typed framework for creating highly configurable schematic and layout generators using the Rust programming language. Substrate provides multiple levels of abstraction, allowing designers to navigate the tradeoff between fine-grained control over a design and increased automation. We also describe algorithms for programmatically creating and modifying circuit layouts, including two methods for automatically adjusting the aspect ratio of a layout. We use Substrate to design generators for a StrongARM comparator and a programmable resistor bank in Skywater 130nm and Intel 16nm, demonstrating 90 degree rotation, array folding, and the ability to change the aspect ratio by a factor of over 10 in both processes. These generators highlight Substrate's ability to facilitate design reuse, process portability, and performance and area optimization.

Modern FPGAs can swap out a hardware module at runtime while the rest of the chip keeps running, this is partial reconfiguration. But when you try to verify that behavior in simulation, you hit a wall: Verilator and other simulators compile the entire design into a single binary at elaboration time, and cocotb's runtime assumes the module hierarchy never changes. Today, the only way to test a different module configuration is to recompile and restart the simulation from scratch, making it impossible to verify sequences of runtime swaps without deploying to physical hardware.

We present a multi-process simulation architecture that lets cocotb test arbitrary module swaps mid-simulation without modifying cocotb or Verilator. The key idea is to run each swappable module as an independent simulator process. In the main simulation, the module's slot is filled by an adapter which cocotb sees as a normal module, but under the hood, can shuttle signal values to and from the appropriate reconfigurable module simulator processes over shared memory. A lock-free barrier synchronizes all processes at every clock cycle. Swapping a module is just an OS-level process replacement: kill the old one, start the new one, resume the barrier. cocotb's VPI state, Python objects, and test flow are completely undisturbed.

Vaporview is a waveform viewer extension for VS Code. It was first presented on at Latch-Up last year, and has since grown in popularity. In this year's presentation, I will give a brief update on new features, and then discuss the project architecture and the design process I used to create Vaporview.

Spade is a modern hardware description language that brings a powerful type system, abstractions for hardware constructs like pipelines and memories, and user friendly tooling to the hardware space. In September 2025, the language turned 5 years old, and this presentation will show off the current status of the project, the new development since the last LatchUp presentation two years ago, and perhaps some new things coming in the future.

Silicon engineering demands multiple model types — architecture, behavioral, RTL, and test. These typically all use different languages, limiting reuse and forcing teams to maintain disconnected -- possibly inconsistent -- descriptions of the same design.

Zuspec provides a unified Python-based hardware modeling language that covers design and verification. A model written with Zuspec can be can be evaluated statistically, simulated at native-compiled speed, and refined to synthesizable RTL.

Hardware design with Zuspec is progressive: add detail to a shared model instead of starting over at each abstraction. This makes cross-functional collaboration natural, while new synthesizable constructs and design patterns open up a richer micro-architecture design space.

Hudson River Trading continues to push the bounds of what is possible with Verilator. This talk will explore several improvements and fixes we've made to the tool. We'll discuss the rationale for these changes and how they relate to our build and test ecosystem.

Now that it's possible to tape-out an analog open source design, you might find yourself in the predicament of having to layout a design manually - full custom. This talk will provide a brief overview of the process, as well as best practices for designing good, reliable layout to get you started on your full custom journey!

We’ve developed an event based framework in modern C++ to do hardware verification. This framework, which is implemented in a header-only library, is useful for tracking activity in a DUT. It implements a normal producer and consumer callback scheme, as well as some more unique and novel features such as event history, delayed callbacks, event filtering mechanisms, and clock configurability that make it particularly suited for hardware verification.