🤖 AI

DynaFix: Iterative Automated Program Repair Driven by Execution-Level Dynamic Information

DynaFix is an iterative automated program repair framework that leverages fine-grained execution-level dynamic information, such as variable states and control-flow paths, to guide large language models in refining patches through a stepwise debugging process, thereby significantly improving repair effectiveness and efficiency on complex bugs compared to existing methods.

Original authors: Zhili Huang, Ling Xu, Chao Liu, Weifeng Sun, Xu Zhang, Yan Lei, Meng Yan, Hongyu Zhang

Published 2026-04-21

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Zhili Huang, Ling Xu, Chao Liu, Weifeng Sun, Xu Zhang, Yan Lei, Meng Yan, Hongyu Zhang

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 are trying to fix a broken car engine.

The Old Way (Traditional Program Repair):
Most current automated repair tools are like a mechanic who has never seen the engine running. They only have a photo of the engine (the static code) and a note from the driver saying, "It won't start!" (the error message).

The Problem: If the mechanic sees a part labeled "EnginePartA" in the photo, they know how to fix it. But if the car owner just renamed that part to "EnginePartB" or rearranged the wires (a syntactic change), the mechanic gets confused. They might try to fix the wrong thing because they are relying on the look of the photo, not how the engine actually works.
The Trial-and-Error: If the first guess fails, the mechanic just guesses again based on the same photo, hoping to get lucky. This is slow, expensive, and often leads to the mechanic making the engine worse.

The New Way (DynaFix):
The authors of this paper, DynaFix, built a system that acts like a mechanic with a live video feed and a dashboard inside the engine.

Here is how it works, broken down into simple concepts:

1. The "Live Dashboard" (ByteTrace)

Instead of just looking at a photo of the code, DynaFix installs a tiny, invisible camera (called ByteTrace) inside the program. When the program crashes, this camera records exactly what happened in real-time:

What were the numbers inside the variables right before the crash?
Which path did the code take?
What was the stack of calls leading to the error?

Analogy: Imagine a detective solving a crime. The old way is looking at a crime scene photo. The new way is watching the security footage while the crime happened. The footage shows the suspect's hand shaking (a variable going negative) or a door being locked from the inside (a logic error), which a photo would never reveal.

2. The "Iterative Detective" (The Repair Loop)

DynaFix doesn't just guess once. It works like a human developer debugging code:

Observe: It runs the broken code and watches the "live dashboard" to see where things go wrong.
Ask: It sends this live video feed to a super-smart AI (a Large Language Model) and says, "Look at this specific moment where the number turned negative. Fix it."
Try: The AI suggests a fix.
Re-Run: If the fix doesn't work, DynaFix doesn't just say "Try again." It runs the code again, records the new live video feed, and shows the AI: "Okay, you tried that, but now this new thing broke. Look at the new video."
Refine: The AI uses this new, specific feedback to make a better guess.

Analogy: It's like playing a game of "Hot and Cold." The old tools just shout "Cold!" and guess again. DynaFix says, "You are getting warmer, but you missed the target by 2 inches to the left," allowing the AI to zero in on the solution much faster.

3. Why It's Better (The Results)

The paper tested this on thousands of real-world bugs. Here is what they found:

It's Robust: If someone renames variables or changes the code's style (like changing "EnginePartA" to "EnginePartB"), DynaFix doesn't care. It looks at the behavior (the live video), which stays the same even if the labels change.
It's Smarter: It fixed 236 bugs that other top tools couldn't fix.
It's Cheaper: Because it gets the right answer faster and doesn't waste time guessing blindly, it uses 60–70% less computing power (and money) than other methods.

The Bottom Line

DynaFix is a program repair tool that stops guessing in the dark. Instead of just reading the code like a book, it watches the code run like a movie. By showing the AI the actual "movie" of the bug happening, it can guide the AI to fix the problem logically, just like a human engineer would, but much faster and cheaper.

It turns automated repair from a game of "blind luck" into a process of "informed debugging."

1. Problem Statement

Automated Program Repair (APR) aims to automatically generate correct patches for buggy programs. While Large Language Models (LLMs) have advanced the field, existing approaches suffer from two fundamental limitations:

Syntactic Sensitivity of Static Representations: Most APR methods rely on static code snippets, exception logs, and test failure messages. These representations are highly sensitive to syntactic variations (e.g., variable renaming, control-flow restructuring) and fail to capture the underlying execution semantics. Consequently, LLMs often learn shallow correlations rather than behavioral logic, leading to poor robustness and generalization.
Coarse-Grained Feedback in Iterative Repair: Current iterative repair pipelines typically rely on "pass/fail" test outcomes or summarized error messages. This coarse-grained feedback forces LLMs into blind trial-and-error, lacking insight into intermediate execution states (e.g., variable values, branch paths) that are crucial for diagnosing complex, multi-step bugs.

2. Methodology: DynaFix Framework

DynaFix is an LLM-based APR framework that tightly integrates execution-level dynamic information into a closed-loop iterative repair workflow. It mimics human debugging by continuously grounding reasoning in concrete runtime behavior.

Core Components:

ByteTrace (Instrumentation Tool):
- A lightweight, non-intrusive Java bytecode instrumentation tool.
- It records fine-grained execution states at runtime without modifying source code.
- Captured Data: Local variable states, control-flow paths (branch execution), method call stacks, and exception events.
- Granularity: Operates at the function level to balance context richness with scalability.
Structured Prompt Construction:
- Constructs debugging prompts that combine the buggy code with the collected dynamic traces.
- Includes system instructions, one-shot examples (buggy code + trace $\to$ fixed code), and specific debugging context (variables, call stacks).
Layered Progressive Repair (LPR) Strategy:
- A cost-efficient search mechanism that balances breadth and depth.
- Breadth Phase: Generates multiple initial candidate patches. Invalid patches (compile errors) are discarded immediately.
- Depth Phase: For patches that compile but fail tests, the system re-executes the code, collects updated execution traces, and feeds this new dynamic feedback to the LLM for refinement.
- Termination: The process stops when a patch passes all tests or when the search budget (breadth $\times$ depth) is exhausted.

3. Key Contributions

DynaFix Framework: The first APR framework to systematically integrate fine-grained, execution-level dynamic information into an iterative LLM repair loop, moving beyond static code and coarse error logs.
ByteTrace Tool: Development of a specialized instrumentation tool that captures rich runtime context (variables, control flow, call stacks) with low overhead, enabling dynamic feedback-driven repair.
Layered Progressive Repair (LPR): A novel search strategy that reduces token consumption by discarding invalid paths early and focusing computational resources on refinable candidates using updated dynamic feedback.
Comprehensive Evaluation: Extensive experiments demonstrating superior effectiveness, robustness to syntactic perturbations, and cost efficiency compared to State-of-the-Art (SOTA) methods.

4. Experimental Results

The authors evaluated DynaFix on three benchmarks: Defects4J v2.0, Real-World Benchmark (RWB), and Defects4J-Trans (code perturbation).

Repair Effectiveness (Defects4J v2.0):
- Using GPT-4, DynaFix repaired 236 single-function bugs.
- Using the more cost-efficient GPT-4o, it repaired 186 bugs.
- It successfully fixed 23 bugs that no existing baseline (including ReInFix, D4C, GIANTREPAIR) could repair.
- Under imperfect fault localization (simulating real-world scenarios), DynaFix repaired 68 bugs, outperforming all baselines in that setting.
Generalization & Robustness:
- RWB (Unseen Bugs): DynaFix outperformed SOTA methods (ReInFix, ThinkRepair) on bugs collected after LLM training cutoffs, proving it does not rely on memorized patterns.
- Defects4J-Trans (Syntactic Perturbation): When code was semantically preserved but syntactically transformed (e.g., variable renaming), DynaFix showed 15.6%–32.1% higher repair rates than ReInFix. This confirms its reliance on semantic invariants rather than static patterns.
Cost Efficiency:
- DynaFix consumed an average of 80,058 tokens per bug.
- This represents a 60%–70% reduction in token usage compared to SOTA agent-based methods (e.g., RepairAgent, ChatRepair), translating to significantly lower economic costs (approx. $0.253 per bug vs. $1.45 for others).
Ablation Studies:
- Iterative feedback was found to be the most critical factor, doubling performance over single-pass dynamic information.
- All dynamic components (Local Variables, Control Flow, Method Calls) contributed positively, with Local Variables and Control Flow being the most impactful.

5. Significance

Paradigm Shift: DynaFix shifts APR from static pattern matching to dynamic semantic reasoning, aligning automated repair more closely with how human developers debug (observing runtime states).
Robustness: It solves the critical issue of LLM sensitivity to syntactic noise, making APR viable for real-world software evolution where code refactoring is common.
Scalability: By introducing the LPR strategy and lightweight instrumentation, it demonstrates that high-performance, dynamic-feedback APR is computationally feasible and economically viable for large-scale deployment.
Open Science: The framework, ByteTrace tool, and datasets are publicly available to facilitate reproducibility and future research.

In conclusion, DynaFix establishes that integrating fine-grained execution traces into an iterative LLM loop significantly enhances the robustness, generalization, and cost-efficiency of automated program repair.