acceptodds
Under review as a conference paper at ICLR 2027

Multi-language Neural Decompilation

Abstract

Deterministic decompilers and state of the art neural decompilers often support binary to C translation yet there is a lack of decompilers for modern high level languages (HLLs) such as Swift, Go and Rust. Current benchmarks for decompilation fixate on binary to C decompilation at the function level, limiting the realistic decompilation tasks to evaluate decompilers on. We investigate using LLMs to translate binaries at the repository level for multiple HLLs, and introduce BlankSpaceBench, a multi-language decompilation benchmark. We also develop BlankSpace, a multi-language agentic decompilation framework, which uses existing binary analysis tools to translate binaries from multiple instruction set architectures (ISAs) to HLLs, with support for coding agents Claude Code and Codex. We compare BlankSpace, frontier models, and deterministic decompilers on top open source projects, evaluating decompilation for arm64 to Swift, x86-64 to C, and x86-64 to Go.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Decompilation, Binary Analysis, Neural Decompilation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_yET4OpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper introduces BLANKSPACE, a coding-agent workflow for reconstructing Swift, C, and Go repositories from stripped binaries. It combines extracted assembly and metadata with compilation, binary-similarity feedback, and automatic reversion. It also introduces BLANKSPACEBENCH, which evaluates 90 projects using their own tests and tests from downstream clients.

Critical strengths
  1. The benchmark addresses a useful evaluation gap. Whole-module replacement and downstream client tests check whether reconstructed code works within a project. The authors also check that downstream tests execute the target library.
  2. Figure 1 explains the motivation well through a concrete Swift example. Section 5.3 is also clear about the different rankings under static and functional metrics.
Critical weaknesses
  1. The results do not establish a consistent functional advantage for BLANKSPACE. On Swift, the framework improves static binary similarity, but upstream whole-module success falls from 3/38 to 2/38 and downstream success from 12/33 to 8/33. Function-level success is also slightly lower. C and Go show mixed or unchanged functional results. The conclusion acknowledges this limitation, so my concern is not inaccurate reporting. It is that the added framework has not demonstrated an advantage under the paper’s own behavioral criterion for successful reconstruction. The benchmark is useful, but this gap is central to my assessment of the method contribution.
  2. The ablation leaves the contribution of the feedback mechanisms unresolved. Removing scoring also removes assembly differences and automatic reversion. Table 2 omits the full-system baseline and reports no functional metrics. The results therefore cannot separate the effects of these components or establish whether any improves functional reconstruction. This matters because the feedback loop is a central part of the proposed method, and the overall comparison has not shown a consistent functional benefit.
Questions for authors
  1. Clarification of the functional evaluation: Why do the Swift functional metrics cover 38, 33, and 22 of the 50 projects? Were these subsets fixed before evaluating the reconstructions, and were all reconstruction build failures counted as failures within them? This would help determine whether the reported comparisons are affected by which projects could be evaluated.
  2. Clarification of the ablations: Is the full Codex + BLANKSPACE result in Table 6 the matched baseline for Table 2? If so, removing assembly differences gives higher instruction and BinDiff similarity. How should this result be interpreted, and do existing runs provide evidence separating the effects of scoring feedback and automatic reversion? This would affect my assessment of which design choices are supported.
3 comments

We thank the reviewer for their questions and suggestions. We have added 2 more ablation experiment modes to assess the effects of removing assembly diffs from BlankSpace in Table 2. For any revisions mentioned, we have made the revision font blue in the revised, uploaded pdf.

Q1: “Why do the Swift functional metrics cover only 38, 33, and 22 of the 50 projects? Were the subsets fixed before you evaluated the reconstructions, and were build failures counted as failures?”

  • Why do the Swift functional metrics cover only 38, 33, and 22 of the 50 projects - At submission, Table 1 reported functional measurements for 38 projects for upstream whole-module evaluation, 33 with verified paired downstream whole-module results, and 22 for upstream single-function evaluation. The remaining measurements were unavailable because of reference test suite failures, inventory issues, or incomplete evaluation. Since submission, whole-module evaluation has expanded to 42 of the 50 Swift benchmark projects using upstream tests and 47 projects using downstream client tests.

  • Were the subsets fixed before you evaluated the reconstructions? - No, the subsets weren’t fixed before we evaluated the reconstructions.

  • Were build failures counted as failures? - Reconstruction build failures were counted as failures.

Q2: “Is the full result in Table 6 the matched baseline for Table 2? If so, why does removing assembly diffs improve instruction and BinDiff similarity? Do any existing runs separate the effects of scoring feedback and automatic reversion?”

(NEW EXPERIMENTS) To test removing assembly diffs, we added two more ablation experiments on the same 20 Swift projects - 1) Scoring without assembly diffs or automatic reversion and 2) scoring with assembly diffs but without automatic reversion in Table 2. Without assembly diffs, instruction and BinDiff similarity are 46.00% and 58.71%, compared with 44.47% and 57.58% with assembly diffs. Assembly diffs provide localized diagnostics to guide edits, but these results show that such guidance does not consistently improve binary similarity.

Functional results show a different pattern. On the same 13 upstream and 15 downstream projects evaluated across all six ablation configurations, adding assembly diffs leaves upstream whole-module success unchanged at 15.38% and increases downstream success from 33.33% to 40.00%. These new ablations isolate the effect of assembly diffs with automatic reversion disabled.

Reviewer_yET4OpenReview ↗

Questions on the Revised Claims and Main Contribution

Thank you for the additional experiments and clarifications. The revised ablations address much of my earlier concern about missing component comparisons. I also acknowledge the positive functional results in some settings, particularly for Go.

My main concern now is the interpretation of the ablations. Section 5.4 describes the configurations and summarizes static similarity, but does not explain the new functional results. With automatic reversion disabled, adding assembly diffs improves downstream whole-module success from 5/15 to 6/15; with reversion enabled, it decreases from 7/15 to 6/15. The full framework performs better on downstream function-level tests, but those results cover only four projects. These mixed outcomes do not establish a consistent benefit, but they may reveal something useful about how the components interact. How do the authors interpret these differences, and what motivates retaining both mechanisms in the final framework?

This also relates to my broader uncertainty about the paper's contribution. The expanded Swift evaluation still shows no whole-module advantage over plain Codex, despite improvements in static similarity and some function-level results elsewhere. I see value in both the reusable multi-language workflow and the repository-level benchmark, but it remains unclear whether the main contribution is improved decompilation performance or a new evaluation and understanding of its limitations. A clearer interpretation of the existing evidence and how it supports the intended contribution would help me reassess the paper.

Thanks for the feedback. We have just updated Table 1 and Table 2 with more functional correctness results. For Table 1, whole-module evaluation expanded from 38 to 42 upstream projects, and 33 to 47 downstream projects. The function-level evaluation now covers 30 upstream and 33 downstream projects. For the Table 2 ablations, the function-level results now cover 12 upstream and 14 downstream projects, extending the earlier 4 project results. We have also updated our observations from the Table 2 results in Section 5.4.

In Table 2 comparing "w/o Assembly Diffs and Automatic Reverts" with "w/o Automatic Reverts", upstream function-level success increases from 37.03% to 38.50%, while downstream function-level success decreases from 32.85% to 31.86%, and downstream whole-module success increases from 33.33% to 40%. Full BlankSpace achieves higher downstream function-level success than "w/o Assembly Diffs" at 37.26% vs. 30.86%, though downstream whole-module success is lower (40% vs. 46.67%).

The function-level success results suggest that assembly diffs can help reconstruct individual functions, even when they do not improve binary similarity or whole-module success. The expanded main Swift comparison in Table 1 also shows higher function-level success than plain Codex: 24.72% versus 22.52% upstream and 30.92% versus 24.66% downstream.

Our main contribution is a reusable workflow for repository-level decompilation across Swift, C, and Go, and BlankSpaceBench for evaluating the reconstructed code. The expanded results demonstrate improvements in binary similarity and individual function reconstruction but identify a current limitation that these improvements don’t consistently translate into higher whole-module success.

Reviewer_BZvdOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces BlankSpace and BlankSpace Bench. BlankSpace is an agentic framework supporting decompilation from multiple instruction set architectures (ISAs) to high-level languages (HLLs). It decompiles binaries into source code at the repository level and provides explicit similarity-scoring feedback. The paper primarily focuses on Swift, C, and Go. It also constructs BlankSpace Bench, a benchmark comprising 90 top open-source projects for evaluating binary decompilation. The experiments show that BlankSpace improves binary instruction similarity and BinDiff similarity, while functional correctness remains challenging.

Critical strengths
  1. The paper constructs a reasonably sized repository-level decompilation benchmark that combines upstream and downstream tests to assess the functional correctness of reconstructed modules, and demonstrates its applicability to Swift, C, and Go.

  2. The paper proposes an agentic framework for neural decompilation across multiple languages, combining existing binary analysis tools with similarity-scoring feedback, and instantiates it for three languages.

Critical weaknesses

The practical gains in functional correctness from similarity feedback have not yet been demonstrated. In the main Swift experiments, the observed values of all three functional metrics are lower than those of Codex alone. Moreover, the ablation study does not report functional metrics, preventing an assessment of whether the individual components contribute to functional correctness.

Questions for authors
  1. Table 2 does not report results for the full BlankSpace framework. Do Table 2 and Table 6 (Codex, GPT-5.6 Sol) use the same 20 Swift projects under comparable experimental conditions? If so, removing Assembly Diffs yields higher values for both binary similarity metrics than the full BlankSpace framework. Please explain the actual role of this component and the stability of these differences, and whether any existing functional evaluation results support the effectiveness of the individual components.

  2. Table 1 covers 50 Swift projects, but reports the three functional metrics on subsets of 38, 33, and 22 Swift projects, respectively. Please explain why the remaining projects were not included, and clarify the specific meaning of the dashes in Tables 1 and 3.

  3. The paper notes that there is a substantial body of existing work on C decompilation, but the C experiments do not include comparisons with existing methods. Could you explain why these comparisons were not included and whether there are any constraints?

1 comment

We thank the reviewer for their questions and suggestions. We have added 2 more ablation experiment modes to assess the effects of removing assembly diffs from BlankSpace in Table 2. We have updated the dashes in Table 3. We added more C baseline experiments in Table 3 and Table 4. For any revisions mentioned, we have made the revision font blue in the revised, uploaded pdf.

Q1: “Do Tables 2 and 6 use the same 20 Swift projects under comparable conditions? If so, why does removing assembly diffs yield higher values for both binary similarity metrics, what role does the component actually play, and how stable are these differences? Is there any functional evidence that the individual components work?”

(New Experiments) To test the efficacy of assembly diffs, we added two more ablation experiments on the same 20 Swift projects - 1) Scoring without assembly diffs or automatic reversion and 2) scoring with assembly diffs but without automatic reversion in Table 2.

Assembly diffs provide function-level mismatch diagnostics to guide edits. They are distinct from the feedback scoring and the automatic-reversion mechanism. Without assembly diffs, instruction and BinDiff similarity are 46.00% and 58.71%, compared with 44.47% and 57.58% with assembly diffs. We added whole-module functional evaluation across all six ablation configurations, using the same 13 upstream and 15 downstream projects for each configuration. Adding assembly diffs leaves upstream whole-module success unchanged at 15.38% and increases downstream success from 33.33% to 40.00%. Function-level evaluation is ongoing. Across four completed projects at the function level for all six ablation configurations, adding assembly diffs increases function-level success from 63.77% to 64.83% upstream and from 32.72% to 35.05% downstream.

Q2: “Why are the functional metrics reported on only 38, 33, and 22 of the 50 Swift projects, and what do the dashes in Tables 1 and 3 mean?”

  • Functional Metrics Reported on only 38, 33, and 22 of the 50 Swift projects - At submission, Table 1 reported functional measurements for 38 projects for upstream whole-module evaluation, 33 with verified paired downstream whole-module results, and 22 for upstream single-function evaluation. The remaining measurements were unavailable because of reference test suite failures, inventory issues, or incomplete evaluation. Since submission, whole-module evaluation has expanded to 42 of the 50 Swift benchmark projects using upstream tests and 47 projects using downstream client tests.

  • Dashes in Table 1 - In Table 1, dashes marked functional metrics for Ghidra and Binary Ninja, which both emit C pseudocode while our functional tests require Swift code.

  • Dashes in Table 3 - The Go function-level results, unfinished at submission, are now reported in Table 3 and discussed in Section 5.6.

Q3: “Why aren’t the C experiments compared against existing C decompilation methods?”

(New Experiments) We have added Ghidra and Binary Ninja as baselines for the C experiments in Table 3 (20 C projects, -O2, -O3) and Table 4 (DecBench) since they are widely used deterministic decompilers. We have also updated our C baseline comparison discussion with the new Ghidra and Binary Ninja results in Section 5.6. Existing neural decompilers such as LLM4Decompile [1], Idioms [2], and Decaf [3] are designed for function-level C decompilation while BlankSpace targets repository-level decompilation for multiple languages. We did not include these existing neural decompilers in our experiments because they finetune smaller, short context open weight models of 0.5B-33B parameters while BlankSpace and our agent baselines use frontier models. A comparison would reflect differences in model scale and context length rather than decompilation approach. We account for model scale by comparing GPT-5.6 with and without BlankSpace, for example.

  • [1] Tan, Hanzhuo, et al. "Llm4decompile: Decompiling binary code with large language models." Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing. 2024.
  • [2] Dramko, Luke, Claire Le Goues, and Edward J. Schwartz. "Idioms: A Simple and Effective Framework for Turbo-Charging Local Neural Decompilation with Well-Defined Types." NDSS. 2026.
  • [3] Shypula, Alexander, Osbert Bastani, and Edward Schwartz. "Decaf: Improving Neural Decompilation with Automatic Feedback and Search." arXiv preprint arXiv:2605.11501 (2026).
Reviewer_U6N6OpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents BLANKSPACE, an agentic framework for repository-level decompilation of stripped binaries across multiple instruction set architectures and high-level languages. It combines a general translation pipeline with iterative refinement guided by compiler feedback and binary similarity scores. The paper also introduces BLANKSPACEBENCH, a benchmark of real-world Swift, Go, and C projects that evaluates functional correctness using both upstream unit tests and downstream client tests. It evaluates BLANKSPACE against frontier models paired with coding agents and deterministic decompilers, with ablations examining binary analysis tool access and iterative feedback, alongside additional evaluation on DecBench.

Critical strengths

The paper addresses repository-level decompilation, extending beyond the function-level setting commonly studied in prior work.

The framework supports decompilation across multiple high-level languages.

The paper introduces a benchmark for evaluating repository-level decompilation on real-world projects.

Critical weaknesses

Limited methodological novelty. Overall, I find the technical contribution insufficiently compelling. The framework primarily combines information extracted by Ghidra with LLM prompting and iterative feedback, which appears to be a fairly standard approach to LLM-based decompilation in 2026. For a framework emphasizing multi-language support, I would expect a deeper investigation of language-specific features, the challenges they introduce, and how the proposed approach addresses them.

Insufficient justification of the function similarity metric. What motivates the proposed definition of function similarity, and is it grounded in prior work? Its advantages over alternative metrics are unclear. I am also concerned about the assumption that functions in the original and reconstructed binaries can be reliably paired or aligned. The paper should explain how this correspondence is established and how alignment errors affect the evaluation.

Unclear rationale for the coverage metric. Why does the evaluation not consider a fuzzing-based coverage approach such as that used in DecompileBench? The paper should clarify what its coverage metric captures and what advantages it offers over existing alternatives.

Potentially underpowered coding-agent baselines. I am not convinced that the reported Codex/GPT results reflect the capabilities of a well-equipped coding agent. Providing these baselines with comparable binary analysis information, including Ghidra’s decompilation output, could substantially improve their performance. A stronger comparison would give Codex access to Ghidra through MCP or appropriate skills and allow it to perform the task iteratively. The recent REA GitHub project may provide a relevant reference for this setup. The paper should establish that the observed gains come from the proposed framework rather than differences in tool access, input information, or execution budget.

Questions for authors

please refer to the weakness

2 comments

We thank the reviewer for their feedback. Revisions are in blue in the updated PDF: a new Codex + Ghidra baseline (Table 7, Sec. 5.3), harness design moved from App. B.2 to Sec. 3.8, similarity motivation (Sec. 3.4), matching validation (App. B.4), function alignment errors' effect on evaluation (App. A.1), and functional tests vs. fuzzing (App. C.2).

Q1: “What is the technical contribution beyond combining Ghidra, LLM prompting, and iterative feedback?”

In App. Sec. B.2, we discuss how in earlier iterations, we finetuned open weight models to decompile Swift, and used more structured LLM guidance. As models became more capable we moved to an agentic harness, which is easier to use and generalizes beyond Swift. Our insight is that multi-language support can be simple. Providing each language's compiler toolchain and deterministic disassembly tools is much simpler than finetuning models for each ASM and HLL pairing (now Sec. 3.8).

Q2: “What motivates the function similarity definition?”

  • Function Similarity Motivation - Comparing recompiled output against the target per function is an established method to measure decompilation quality. decomp.me [1] and objdiff [2] score each function by its recompiled similarity, Coda [3] uses similarity to guide iterative corrections, and Decaf [4] uses it to rank candidates. The agent needs a score to measure partial progress and identify which functions to improve. Exact matching fails to capture partial progress, and BinDiff’s [5] whole-binary score does not indicate which functions to improve. We give partial credit for near-miss instructions after normalizing addresses, immediate values, and selected registers, then aggregate by function size as objdiff does, giving zero credit to unreconstructed functions and penalizing extra code (Sec. 3.4).
  • Function Alignment for Feedback Scoring - Functions sharing a retained, non-anonymous name are paired first (the name earns no credit). Remaining functions are paired one-to-one to maximize total similarity, restricted to similarity >= 0.35 and instruction counts within 2x. Unmatched functions count as missing or extra code. We tested our matching on Swift, C, and Go cases with known pairings (renamed, reordered, missing, extra, and threshold pairs). These tests don’t guarantee correct pairs on real binaries, where inlining can violate the one-to-one assumption [6] (App. B.4).
  • Alignment Errors’ Effect on Evaluation - This alignment is used only for agent feedback. Our evaluation's instruction similarity (Sec. 5.2) pairs functions by exact linkage names occurring once in each binary. These pairs are exact identities rather than inferred and cover a subset of functions (30.4% for BlankSpace and 28.6% for plain Codex). On functions matched by both, BlankSpace still achieves higher instruction similarity (41.31% vs 37.56%), matching Table 1 (40.19% vs. 36.47%). Matched symbols indicate corresponding functions, not equivalent behavior, which we measure using functional tests (Sec. 5.3). See App. A.1, Table 8.

Q3: “What does the coverage metric capture, and what advantages does it have over existing alternatives? Why didn’t the evaluation use a fuzzing-based coverage approach?”

  • Coverage feedback in BlankSpace (Sec. 3.4) - This feedback signal measures how broadly the binary has been reconstructed. We introduced it after observing that, given only similarity, the agent focused on functions it had already reconstructed instead of translating new ones. It is measured over target binary instructions rather than source functions because in higher level languages, source and binary functions map many-to-many (Sec. 3.8).
  • Functional Correctness Tests in Evaluation (Sec. 4.2) - We agree that DecompileBench’s fuzzing approach could be used to measure correctness, but it relies on OSS-Fuzz harnesses, and as of 11/13/2026 OSS-Fuzz supports only 3 Swift projects. Project test suites also reflect more realistic execution. We discuss the trade-offs in App. C.2 and leave coverage equivalence to future work.

Q4: “Do the Codex/GPT baselines reflect the capabilities of a well-equipped coding agent? ” (New Experiment) We agree that baselines should have binary analysis tools such as Ghidra, so we added Codex + Ghidra (via REA) on 20 Swift projects to our evaluation (Table 7). BlankSpace achieves 40.61% instruction and 55.59% BinDiff similarity, vs. 34.33% and 51.28% for Codex + REA/Ghidra (Sec. 5.3).

[1] decomp.me. https://decomp.me [2] L. Street. objdiff. https://github.com/encounter/objdiff [3] C. Fu et al. Coda: An End-to-End Neural Program Decompiler. NeurIPS 2019. [4] A. Shypula et al. Decaf: Improving Neural Decompilation with Automatic Feedback and Search. arXiv:2605.11501, 2026. [5] T. Dullien, R. Rolles. Graph-Based Comparison of Executable Objects. SSTIC 2005. [6] A. Jia et al. 1-to-1 or 1-to-n? Investigating the Effect of Function Inlining on Binary Similarity Analysis. TOSEM 2023.

Thank you for the reply. My concern remains that the work lacks insight in the agentic area. I will keep my original rating.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.