



Where impossible is just an error code
An online hackathon on compilers and programming languages. Five weeks to build. Finalists present in person at IISc, Bengaluru on Oct 2–3, 2026
SegFault is organised as part of the Innovations In Compiler Technology workshop
Registrations are closed
Nine teams go to Bengaluru.
Out of 41 teams that presented to a panel online, these are the ones selected for the in-person final round at IISc, Bengaluru on Oct 2–3, 2026.
Blank Point
LoomX: An Automatic GPGPU Parallelizing Compiler Framework
We present a source-to-source parallelization pipeline that automatically transforms sequential C/C++ loops into OpenMP multi-core or GPU-offload code. The system combines interprocedural dependence analysis, reduction detection, and a profitability model that decides whether each loop is better left on the CPU or moved to the GPU. The goal is to automate the kind of loop-level parallelization that programmers currently write by hand. The pipeline is validated end-to-end on PolyBench, a widely used collection of affine numerical kernels. CPU OpenMP parallelization produces a solid overall speedup across the suite, and compute-dense kernels such as gemm achieve strong GPU acceleration. We also show that the profitability gate improves GPU performance by suppressing offloads where data-transfer costs would outweigh the benefit, raising the GPU geomean compared to a naive offload-everything strategy. Beyond PolyBench, we have extended the harness and compiler frontend to support additional benchmark suites including NPB, Parboil, Rodinia, and the LLVM Test Suite. These integrations are exposing the pipeline to larger, more realistic code patterns and are guiding ongoing work on frontend robustness, numerical correctness, and profitability modeling across a broader class of applications.
Team
Dead_Code_Society
CompilerLens - AI Compiler Optimization Explorer
CompilerLens is an interactive exploration and experimentation platform that makes AI compiler pipelines easier to understand. It accepts PyTorch and Hugging Face models, compiles them through IREE, and captures their transformation across Torch-dialect MLIR, intermediate compiler stages, LLVM IR, and target assembly. Instead of presenting compiler output as disconnected text dumps, CompilerLens organizes it into a unified, navigable artifact. The platform connects model architecture, including transformer blocks, attention modules, tensor shapes, and parameters to the operations produced during compilation. Users can select an operation and follow its lineage across lowering stages, inspect related IR, compare transformations, and identify where compiler provenance is no longer available. Original compiler output remains the source of truth, while summaries and visualizations support navigation. CompilerLens also provides a live Playground for changing validated compiler options, inspecting selected stages, and benchmarking generated executables. By unifying model architecture, operation lineage, compiler evidence, and performance measurements, CompilerLens transforms complex compilation data into clear and traceable insights.
decompiled_brain
A QIR compiler in rust and decompiling the gates into a usable set of gates
qirc is a compiler for QIR, the LLVM based format used by Q# and PyQIR to hand off quantum programs, written from scratch in Rust. It checks each program against the profile it declares, works out loops and helper functions ahead of time to leave a flat list of gates, and optimises the circuit. The result can be run on a fast built in simulator, emitted as OpenQASM 3, QIR or JSON, or rewritten for the gate sets and qubit layouts of real hardware.
Gloog
Static recompilation of Game Boy ROMs into LLVM IR in order to run on an external runtime without an emulator.
gbrc is an LLVM-based static recompiler for the Game Boy DMG-01 which turns existing Game Boy ROMs into native executables for any system. Rather than emulating the console, it recompiles the game ahead of time, so the result runs natively without needing a Game Boy interpreter at runtime. Alongside the recompiler, we built a runtime library that implements the rest of the console's hardware and exposes a small set of frontend hooks. This lets anyone write their own frontend, targeting desktop, the browser, or anything else, and get a playable native build of a Game Boy game. As of right now, only games which don't require a memory bank controller (MBC) are supported.
Team
pop rsp;ret
LLVM Lens
LLVM-Lens is an LLVM Pass Transformation Analyzer that helps in visualizing the compilation pipeline for a given C/C++ codebase. During the compilation process, various LLVM Passes may affect the final optimized LLVM IR generation. Along with the default passes, users can write custom passes for additional instrumentation of the code. With the help of LLVM-Lens, users can generate a static HTML report to visualize all the passes, with support for custom passes as well. For each stage of the pipeline, users can view the changes in LLVM IR, various analyses that are run and invalidated, CFG, and other compilation graphs. There is also an option to get a `blame` view where the user can probe each line of LLVM IR and find the passes that have created, renamed, or rewritten it. Along with support for LLVM IR, we have support for Machine IR (MIR) as well. Users can visualize the MIR pipeline in a similar manner to the LLVM IR pipeline. Additionally, the physical register allocation and register spills can be viewed as well. Every line also maps back to C/C++ source through debug info. AI is integrated that can help users to understand pass details.
Team
PRISM
HydIR: Ghidra-Native LLVM Lifting
HydIR is a reverse engineering framework for understanding and modifying binaries. It shows the instructions and control flow it can recover, lifts supported functions into LLVM IR or C, and checks those results against native execution. You can inspect the disassembly, add notes, and write bounded patches or rebuilt binaries to new files. The same tools are available through a desktop app, command line, Python SDK, and authenticated local service. When analysis reaches code it cannot handle reliably, HydIR shows the gap instead of guessing.It also supports bounded symbolic exploration of paths through a selected function
Team
RainingComputers
vodd (Virtual OpenCL debugging device), an alternative to Oclgrind
Interactive debugging for OpenCL programs or CUDA programs is currently done via GDB. GDB is not designed for stepping GPU kernels or visualising the state of an entire work-group composed of several work-items simultaneously. For example, it is difficult to visualise bugs arising due to work group divergence over the interface GDB provides. This project aims to fully redesign the debugger interface for debugging GPU kernels and provide a richer visualisation that aids in catching bugs faster and develop good mental model for execution of GPU kernels. vodd implements its own custom interpreter for OpenCL kernels, serves an interactive debugger over http via the browser and borrows all error detection algorithms from Oclgrind.
Solo
- Vishnu Shankar BPropelldGitHub
sigsys
async-a-sync: implicit async futures for C
async-a-sync (Yes sorry we changed the name of our project) async-a-sync is a compiler and runtime system built on top of Fil-C's instrumentation pass that brings implicit asynchronous futures to C. It allows developers to write ordinary, blocking-looking C code that is fully asynchronously underneath at runtime. It transforms blocking function calls into asynchronous backend submissions that return immediately. Values mutated by these operations carry provenance tags that propagate through pointer arithmetic (This is already provided by Fil-C). By extending Fil-C's InvisiCaps(refer: https://fil-c.org/invisicaps), our compiler automatically inserts lazy resolution barriers before memory accesses to results of async functions that resolve any pending values transparently at the access site itself. Request batching is deferred until demand, and resolution polls completion queues directly in userspace memory. The asynchronous backend interface is supposed to be generic across arbitrary asynchronous backends. In this repo we provide an io_uring driver demonstrating substantial ergonomic and throughput gains on system call workloads.
Team
soundnessAndSambar
Effect-Typed Shredding of JSON into a Queryable OCaml
Tatami reads schema less JSON and derives a columnar schema from it, along with the OCaml types that the schema implies. The loader streams documents into tables as the signature describes them, keeping each row's parent and the position it held in the array it came from. We are using Postgres as our DB reached through pgx, a client written in OCaml. We ran the result across dataset sizes and query shapes: reassembling one document, counting over a single column, grouping, and joining up three levels. That gives an informed account of where a columnar layout wins and where it does not. Every run is differentially tested, so the answer from querying the raw JSON must equal the answer our store returns before any timing is believed. On the computed query the columnar store runs 3.34x against row-major. The conversion is backed by a Lean4 proof in five parts. The emitted signature is well formed. The schema is canonical: shuffle the documents and the answer is equal, not merely equivalent. Structure is preserved, so the graph in the signatures is the graph the documents induce, with no edge lost or invented. Every type is principal: wide enough to admit every value that appeared in the data, and no wider. And nullability is exact: a field is optional precisely when some document lacked a value there. 223 theorems and lemmas stand behind that, and the generator emits one .mli per table plus a loader that ingests the JSON into a database on which the benchmarking was done.
Team
Listed alphabetically · placement decided live at IISc, Bengaluru
Everything else that got built.
All 41 projects that reached the panels, with abstracts, repositories and demos.
Everything is online.Except the finale.
Build from anywhere. Only the finale is in person.
No travel to take part.
Register, build and submit from your own machine.
Any city, any timezone. Nothing to book.
Registrations have closed.
Sign-ups ended on Aug 15, 2026.
Shortlisted teams get their next steps by email.
Announced as they land.
Teams are shortlisted as submissions come in, all through the five weeks.
Submit early, hear back early.
One trip, at the end.
Finalists present in person at IISc, Bengaluru on Oct 2–3, 2026.
Their IICT workshop attendance is covered. Nothing before it needs a flight.
Six problem statements.Eight open themes.
Every team picks exactly one of either: an official problem statement from the organizers, or an open theme with an idea of your own.
Official problem statements
Open themes
Domain specific compilers and languages
Design and implement compilers and languages for a specific application or a specific piece of hardware.
- Compilers
- Programming languages
- eDSLs
Compiler frameworks and tools
Work on the infrastructure itself: intermediate representations, program analysis, transformation tooling.
- Tools
- Static analysis
- Debugging
Compilers and AI/ML
Use AI/ML to make compilers better, or compiler technology to make AI/ML workflows better.
- Machine learning
- Codegen
- Tooling
Optimizing for the real world
Take software that already exists and make it run faster or leaner with compiler techniques.
- Auto-tuning
- Energy
- Edge
Explainable compilers
Modern compilers are enormous black boxes. Make their decisions legible to the people using them.
- Visualisation
- Teaching
- Debugging
Compilers for new paradigms
Build compilers or tooling for places compilers are only just arriving.
- Quantum
- eBPF
- Security
Functional programming
Build using functional programming languages, or build the tooling that makes them better.
- OCaml
- Haskell
- Type systems
Open innovation
Build anything on compiler technology. If it does not fit the other tracks but it is compilers, it fits here.
- Anything compilers
- Your idea
One pick per team · a problem statement or a theme
Two months, end to end.Here is how it runs.
Aug 1 – Oct 3, 2026. Fully online until the finale in Bengaluru.
Registrations open
Sign up as a team or solo. Nothing to build yet, just get on the list.
Problem statements and tracks announced
The real track list and problem statements land a week after sign-ups open.
Registrations close
Late entries are still accepted once hacking is underway.
Hacking begins
Five weeks, fully remote. Everything runs on your own machine.
Shortlists announced
Teams get shortlisted as submissions come in, instead of all at once on one date.
Final evaluation
Online judging across both days. The finalist list is locked by the end of it.
Grand finale at IICT
Finalists present in person at IISc Bengaluru, alongside the IICT workshop.
Cash for the top three teams.
₹2,00,000 in total, plus certificates and mentorship for everyone who takes part.
Total prize pool
₹2,00,000
Certificates
Every participant gets a certificate.
Mentorship
Sessions with compiler engineers working in industry.
Travel
Finalists' IICT workshop attendance is covered.
Hiring
Internship and job conversations with the sponsors.
Sponsors.
Host
SegFault is organised as part of the Innovations In Compiler Technology workshop.
Questions people ask.
Yes. Registration, hacking, submissions and final evaluation all happen remotely, so you never have to travel to take part. The only in-person part is the grand finale on Oct 2–3, and that's for finalists.
Registration is free, and you don't have to be a student. In 2025 teams came from IITs and other colleges alongside working engineers, and solo entries did fine — three of the six finalists were teams of one.
Yes. Late registrations are accepted after hacking begins — you just get less time to build. All IP in what you build stays with your team.
On a rolling basis. Teams are shortlisted as their submissions come in, rather than all at once on a single announcement date. Submit early and you hear back early.
Five minutes to pitch in front of the jury, then two to three minutes of questions. Finalists attend the IICT workshop free. Travel can't be guaranteed, but reimbursements are offered to student attendees — reach out to the organisers. Accommodation at IISc isn't confirmed yet.
Email Ashutosh Pandey at ashutosh@compilertech.org, or reach the IICT workshop on LinkedIn or X.
