💬 NLP

SuperCoder: Assembly Program Superoptimization with Large Language Models

This paper introduces SuperCoder, a large language model-based approach for assembly superoptimization that, through the creation of a new large-scale benchmark and reinforcement learning fine-tuning, achieves 95% correctness and a 1.46x speedup over industry-standard compilers, demonstrating the viability of LLMs for program performance optimization beyond traditional heuristics.

Original authors: Anjiang Wei, Tarun Suresh, Huanmi Tan, Yinglun Xu, Gagandeep Singh, Ke Wang, Alex Aiken

Published 2026-02-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Anjiang Wei, Tarun Suresh, Huanmi Tan, Yinglun Xu, Gagandeep Singh, Ke Wang, Alex Aiken

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a recipe for a cake that a world-class chef has already perfected. The chef has measured every ingredient, chosen the best oven temperature, and timed the baking to the second. This is your "optimized" code, created by a standard computer compiler (like gcc -O3).

Now, imagine asking a brilliant but inexperienced apprentice (a Large Language Model, or LLM) to look at that perfect recipe and say, "I can make this cake even faster."

This is exactly what the paper SuperCoder investigates. Here is the story of their experiment, explained simply.

The Challenge: Beating the Master Chef

For decades, computer scientists have tried to write programs that automatically find the fastest way to do things. This is called Superoptimization.

The Old Way: Previous attempts were like trying to optimize a single sentence. They could only handle tiny, simple tasks without any loops (repeating actions). It was like trying to make a sandwich faster, but you couldn't even add a second slice of bread.
The New Goal: The authors wanted to see if modern AI could optimize a whole "meal" (a complex program with loops and logic) that was already cooked by the best professional chefs (industrial compilers).

The Toolkit: A Massive New Playground

To test this, the researchers couldn't just use the old tiny datasets. They needed a massive gym to train their AI.

The Dataset: They built a library of 8,072 assembly programs (the raw, low-level instructions computers actually run).
The Scale: These weren't tiny snippets; they averaged 130 lines of code and included complex loops. Think of it as moving from optimizing a single Lego brick to optimizing an entire castle.
The Safety Net: They created thousands of "test cases" (like taste tests) to ensure that if the AI changed the recipe, the cake still tasted exactly the same, just baked faster.

The Experiment: Training the Apprentice

They took 23 different AI models and asked them to rewrite the assembly code to be faster.

The Initial Results: Most AIs were terrible at this. They either wrote code that crashed (the cake fell apart) or code that was just as slow as the original.
The Star Performer: One model, Claude-opus-4, was the best of the bunch. It managed to make the code 1.43 times faster on average while still working correctly. That's like cutting a 10-minute baking time down to 7 minutes without ruining the cake.

The Secret Sauce: Reinforcement Learning

The researchers realized that just asking the AI to "do better" wasn't enough. They needed to train it like a video game character.

The Reward System: They used a technique called Reinforcement Learning.
- If the AI wrote code that crashed or gave the wrong answer, it got zero points.
- If the code worked, it got points based on how much faster it was.
The Result: They took a solid model (Qwen2.5-Coder-7B) and trained it with this reward system.
- Before Training: It was correct 61% of the time and only 10% faster.
- After Training (SuperCoder): It became correct 95% of the time and 46% faster on average.

How They Polished the Gem

Even after training, they used two clever tricks to get even better results:

Best-of-N Sampling: Instead of asking the AI for one answer, they asked it for 8 different versions and picked the absolute best one. This boosted the speedup even further.
Iterative Refinement: If the AI made a mistake, they showed it the error message and asked, "Try again, but fix this specific problem." The AI used this feedback to correct itself, getting smarter with every attempt.

What Did the AI Actually Change?

When the researchers looked at how the AI made the code faster, they found it was doing things like:

Loop Restructuring: Rearranging the order of steps to be more efficient.
Instruction Selection: Swapping a long, slow instruction for a short, specialized CPU trick (like using a secret shortcut).
Removing Bloat: Taking out safety checks or complex math that the compiler had kept but wasn't strictly necessary for that specific task.

The Bottom Line

This paper proves, for the first time, that AI can act as a superoptimizer. It can take code that has already been optimized by the world's best human-engineered compilers and find ways to make it even faster, without breaking it.

They didn't just guess; they built a massive testing ground, trained the AI with a strict reward system, and showed that with the right training, AI can outperform the current "gold standard" of computer optimization.

Technical Summary: SuperCoder: Assembly Program Superoptimization with Large Language Models

Problem Definition

The paper addresses the challenge of superoptimization: transforming a program into a faster variant while strictly preserving its input-output behavior. While traditional compilers (e.g., gcc -O3) have been refined over decades, they rely on heuristic transformation rules and do not guarantee optimality. Existing superoptimization research has been limited to very short, straight-line assembly programs (typically 2–15 instructions) without loops, relying on CPU-based search heuristics that fail to scale.

This work investigates whether Large Language Models (LLMs) can serve as superoptimizers for large-scale, loop-containing assembly programs. The specific task is to generate assembly code that outperforms the baseline output of industry-standard compilers at their highest optimization level (gcc -O3), a significantly more demanding challenge than generating code from natural language specifications.

Methodology

1. Dataset Construction

To address the scarcity of large-scale assembly datasets, the authors constructed a new benchmark consisting of 8,072 assembly programs (7,872 for training, 200 for evaluation).

Source: Derived from the CodeNet corpus of competitive programming submissions.
Selection Criteria: Programs were sampled based on high relative speedup between gcc -O0 and gcc -O3 to ensure complexity and optimization potential.
Scale: The average program length is 130 lines, a substantial increase over prior datasets restricted to <15 lines.
Validation: Test suites were regenerated by executing original submissions to ensure correctness, achieving 96.2% line coverage and 87.3% branch coverage.

2. Task Formulation

The problem is framed as a contextual multi-armed bandit problem where:

Context ( $s$ ): The source C program, the baseline gcc -O3 assembly, and a set of test cases.
Action ( $a$ ): Generating a candidate assembly program.
Objective: Maximize Speedup, defined as the ratio of baseline execution time to candidate execution time.
Constraint: The candidate must be valid (compilable) and correct (pass all test cases). If a candidate fails compilation or correctness, it is assigned a default speedup of 1.0 (reverting to the baseline).

3. Reinforcement Learning (RL) Framework

The authors employ RL to fine-tune LLMs, optimizing a reward function that jointly encodes correctness and performance.

Algorithms: Proximal Policy Optimization (PPO) and Group Relative Policy Optimization (GRPO).
Reward Function:
- $r = 0$ if the program fails to compile or fails any test case.
- $r = \text{speedup}$ if the program passes all tests.
- This design ensures the model is penalized for hallucinations or incorrect optimizations and rewarded only for valid, faster code.
Base Model: Qwen2.5-Coder-7B-Instruct was selected for fine-tuning due to its strong baseline correctness.

4. Inference-Time Techniques

To further enhance performance, the study evaluates:

Best-of-N Sampling: Generating multiple candidates and selecting the one with the highest speedup among those that pass all tests.
Iterative Refinement: Feeding compilation errors or test failures back into the model's prompt to guide subsequent generations.
Supervised Fine-Tuning (SFT): Using the best candidates from Best-of-8 sampling as ground truth for LoRA fine-tuning.

Key Results

Baseline Evaluation

The authors evaluated 23 state-of-the-art LLMs (including GPT-4o, DeepSeek-R1, Claude-3.7, and specialized compiler models).

Performance Gap: Most models struggled, with many achieving only 1.00× speedup (no improvement) or failing to compile.
Top Baseline: Claude-opus-4 achieved the best baseline performance with a 51.5% test-passing rate and an average speedup of 1.43× over gcc -O3.
Failure Modes: Models like DeepSeek-R1 failed to generate executable code (0% compilation), often outputting verbose reasoning instead. GPT-4o achieved high compilation rates (81%) but low correctness (5%), frequently violating low-level conventions (e.g., stack canaries, calling conventions) in pursuit of optimization.

RL Fine-Tuning (SuperCoder)

Fine-tuning the base model (Qwen2.5-Coder-7B-Instruct) with RL yielded significant improvements:

Correctness: Increased from 61.4% to 95.0%.
Speedup: Increased from 1.10× to 1.46× (average).
Comparison: The RL-trained model outperformed all other evaluated models, including the proprietary Claude-opus-4 baseline. PPO and GRPO yielded nearly identical results.

Inference-Time Gains

Best-of-N: Applying Best-of-8 sampling to the RL-trained model further increased the average speedup to 1.93×.
Iterative Refinement: Providing feedback on errors improved performance across all models, with the most significant gains observed in the RL-trained model.

Analysis of Transformations

An analysis of the optimized code revealed nine categories of transformations where LLMs surpassed gcc -O3:

Loop restructuring (unrolling, reordering).
Instruction selection (using specialized CPU instructions like popcnt, cmov).
Algorithmic simplification (replacing custom logic with standard library routines).
Stack canary removal (eliminating security checks).
Register allocation improvements.
Branch elimination (using conditional moves).
Address calculation optimization.
Function call optimization.
Arithmetic optimization (e.g., replacing division with shifts).

Significance and Claims

The paper claims to be the first to successfully apply LLMs as superoptimizers for assembly programs that have already been optimized by industry-standard compilers. Its primary contributions are:

New Benchmark: The introduction of a large-scale, realistic dataset (8,072 programs, avg. 130 lines) that moves beyond the toy examples of previous superoptimization research.
RL for Performance: Demonstrating that Reinforcement Learning, with a reward function explicitly integrating correctness and speedup, is highly effective for code performance optimization, outperforming standard supervised fine-tuning and prompting strategies.
Feasibility: Establishing that LLMs can discover performance improvements in assembly code that standard compiler heuristics miss, achieving up to 1.46× speedup (and up to 1.93× with Best-of-N sampling) over gcc -O3.

The authors position this work as a foundation for future research in program performance optimization beyond the limits of traditional compiler heuristics.