Available student projects at LAP

Updated: 05-05-2026

Open-Source Work on Dynamic High-level Synthesis Compiler Targeting FPGAs

Supervisor: Andrea Guerrieri ([email protected])

Dynamic high-level synthesis (DHLS) is the process of turning high-level source code into synchronous dynamically scheduled circuits. We offer opportunities to work on an open-source DHLS compiler called Dynamatic that is based on the MLIR compiler ecosystem and which generates synthesizable RTL that targets FPGA architectures from C/C++ code. Projects can revolve around writing compiler passes that transform our intermediate representation (IR) at some level of our progressive lowering pipeline. These go from close-to-source high-level analysis steps (e.g., memory dependence analysis, loop transformations) down to dataflow circuit-level transformations (e.g., buffer placement, bit-width optimisation). We also have open lines of work in the infrastructure surrounding the core compiler, be it debugging, visualisation, or benchmarking tools. Regardless of the exact line of work, as an open-source project we value good software design, solid development practices, and want to make any student contribution a permanent part of Dynamatic’s codebase. If you would like to discuss potential directions, please reach out with your resume/transcript and any specific interest you may have.

 

Accelerate FPGA Implementation Time

Supervisor: Andrea Guerrieri ([email protected])

FPGAs are powerful devices from embedded applications to data centres. However, developing with FPGAs requires hardware design skills and a long implementation time. High-level synthesis covers the gap in creating hardware design from C/C++ code. However, the time required to generate a bitstream configuration to download to the FPGA is still very long. This project aims to accelerate the FPGA implementation design from several minutes to a few seconds.

 

Postquantum Cryptography Core Using High-Level Synthesis

Supervisor: Andrea Guerrieri ([email protected])

In 2016, the American National Institute of Standards and Technology (NIST) started a contest to qualify a set of post-quantum cryptography standards. High-level synthesis produces HDL code for FPGAs out of C/C++ in an automatic way, bridging the gap from algorithm to hardware design. However, the quality of results could be suboptimal compared to RTL-based (Register Transfer Level) designs. This project aims to explore and improve the QoR of the post-quantum cryptography hardware using HLS. 

 

Low-Level Optimization of Dynamically Scheduled Circuits

Supervisor: Rouzbeh Pirayadi ([email protected])

Dynamic High-Level Synthesis (DHLS) transforms high-level source code into synchronous, dynamically scheduled circuits, offering a flexible alternative to traditional static scheduling. While significant research focuses on high-level compiler IR transformations, there is a distinct opportunity to improve performance by targeting the lower levels of the hardware implementation flow. This project explores optimizations that occur after the core compiler has generated its output, specifically focusing on the transition from RTL to a physical FPGA implementation to bridge the abstraction gap between the DHLS compiler’s intermediate representation and the final hardware bitstream. By operating within the Vivado environment, the student will investigate adjustments that can be made during and after the logic synthesis and place-and-route phases, refining the produced circuit based on real physical constraints, such as routing delays and logic congestion, which are invisible at the high-level compiler stage.

 

Toward Coarse-Grained Field Programmable Gate Arrays

Supervisor: Louis Coulon ([email protected])

Reconfigurable computing systems are ideal candidates to fulfil the  growing need for hardware specialization. They enable the mapping of  applications to efficient dedicated digital circuits which can be  implemented on generic computing fabrics, thus improving both  performance and energy efficiency while still being capable of  supporting virtually any application. In practice, the only reconfigurable computing system available commercially today is the  FPGA, recently adopted as a computing device in data centres and targeted  by all high-level synthesis compilers to ease its programming. However,  in data centre setting, there is a striking mismatch between the FPGA  programmable fabric and the computing needs of applications: these  generally perform word-level computations, while FPGAs allow bit-level  reconfigurability and provide bit-level abstractions. In this project,  we study a coarser granularity version of FPGAs and evaluate its  performance as a word-level reconfigurable computing fabric. We offer  opportunities to work on new compiler optimisations targeting this new  category of processors, new architectural ideas, and the physical  implementation and modelling of such processors.

 

Optimizing place and route for high frequency task parallel FPGA accelerators

Supervisor: Mohamed Shahawy ([email protected])

Task-Level Parallelism is a computing paradigm used in applications like graph-processing algorithms. Such algorithms could benefit from the custom circuits that can be designed on FPGAs. HardCilk is an open-source scheduler for task parallel acceleration on FPGAs. Since HardCilk uses ready-valid interfaces, the design frequency could be increased by adding elastic buffers. In this project, students will analyse the frequency of the circuits generated by HardCilk using Vivado place and route. They would manipulate the circuit by adding buffers and test whether this enhances the frequency of the generated designs.

 

SOC-graphical configurator as VS-code plugin

Supervisor: Theo Kluter (ties.kluter@epfl.ch)

Currently the embedded systems used in CS-473 (System programming for Systems On Chips) and CS-476 (Embedded System Design) use OpenRisc-based softcore systems that are described in Verilog and have a static architecture. Tools like Quartus provide a graphical configuration tool (QSYS) that allow the designer to create their own SOC by placing the modules on the graphical plane and connect them together by connecting the masters and slaves on the bus architecture, providing, amongst others the generation of the top-level verilog file based on the selected modules and a memory-map of the connected slaves. As the modules are already present the goal of this project would be to provide the means of using the same idea for the fore mentioned courses as a VS-code plugin that can be used on MAC, Linux, and Windows. An important aspect is also to export the graphical SOC-designs as tikz-pictures and pdf for documentation purposes.
 

Software configurable Instruction-cache for a RISCV CPU

Supervisor: Theo Kluter (ties.kluter@epfl.ch)

For the courses CS-473 and CS-476 we are moving towards using a RISC-V soft-core. The core that is going to be used is the Hazard3 (https://github.com/wren6991/hazard3). This core does not provide any caches and performs single-word accesses using the AHB5 bus protocol. The goal of this project is to design in verilog a software-configurable instruction cache that connects to the core by using the AHB5 bus protocol and provides a Wishbone-bus interface (also allowing burst transfers by the Whishbone 2.0 specifications). The instruction cache should be software controllable by using the Special Purpose Register interface of the RISC-V (Zicsr-extention). The parameters to be configured are: 1) the size (1kB, 2kB, 4kB, and 8kB), 2) the associativity (off, direct-mapped, 2-way-set-associative, 4-way-set-associative), 3) the cache-line-size (16bytes, 32bytes, 64bytes, 128bytes), and 4) the replacements policy (round-robin, PLRU, LRU). It would be nice if also a Scratchpad (tightly-coupled memory) with an DMA-controller could be added.