SegFault

Where impossible is just an 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

Fully onlineCompilersProgramming languagesProgram analysisLLVM · MLIROpen to students & industryRolling shortlistsFinale at IISc BengaluruFully onlineCompilersProgramming languagesProgram analysisLLVM · MLIROpen to students & industryRolling shortlistsFinale at IISc Bengaluru
Results are in

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.

Team

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.

Solo

  • Angad BasandraiIndian Institute of Engineering Science and TechnologyGitHubLinkedIn

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

Everything else that got built.

All 41 projects that reached the panels, with abstracts, repositories and demos.

The format

Everything is online.Except the finale.

Build from anywhere. Only the finale is in person.

Fully onlineAug 1 – Oct 3, 2026
Anywhere001

No travel to take part.

Register, build and submit from your own machine.

Any city, any timezone. Nothing to book.

Entry002

Registrations have closed.

Sign-ups ended on Aug 15, 2026.

Shortlisted teams get their next steps by email.

Shortlists003

Announced as they land.

Teams are shortlisted as submissions come in, all through the five weeks.

Submit early, hear back early.

The finale004

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.

Tracks

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
Timeline

Two months, end to end.Here is how it runs.

Aug 1 – Oct 3, 2026. Fully online until the finale in Bengaluru.

Aug 1

Registrations open

Sign up as a team or solo. Nothing to build yet, just get on the list.

Aug 7

Problem statements and tracks announced

The real track list and problem statements land a week after sign-ups open.

Aug 15

Registrations close

Late entries are still accepted once hacking is underway.

Aug 15same day

Hacking begins

Five weeks, fully remote. Everything runs on your own machine.

Rollingcontinuous

Shortlists announced

Teams get shortlisted as submissions come in, instead of all at once on one date.

Sept 19–20

Final evaluation

Online judging across both days. The finalist list is locked by the end of it.

Oct 2–3

Grand finale at IICT

Finalists present in person at IISc Bengaluru, alongside the IICT workshop.

VenueA V Rama Rao Auditorium, Indian Institute of Science
Prizes

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.

FAQ

Questions people ask.

Registrationsare closed.

Sign-ups ended on Aug 15, 2026. Shortlisted teams get their next steps by email.

Last year

24

Submissions

6

Finalists

3

Solo finalists

Read what got built last year before you pick an idea.

All 24 ideas · 2025 archive