acceptodds
Under review as a conference paper at ICLR 2027

Decomposer: Learning to Decompile Symbolic Music to Programs

Abstract

Musical performance involves executing a set of high-level musical instructions, yet recovering those instructions from the performance is a challenging inverse problem. We present Decomposer, a post-training framework for symbolic music decompilation: the task of recovering executable, editable music programs from symbolic music. We instantiate the task as MIDI-to-Strudel decompilation, where the model takes symbolic MIDI as input and produces a program in Strudel, a music programming language, that reconstructs the input when executed. The task poses two challenges: Strudel is a low-resource language with little naturally paired MIDI-code data, and optimizing faithful reconstruction of MIDI alone can collapse to unreadable note-by-note transliteration. We address these challenges in two stages. First, we construct Strudel-Synth, a synthetic corpus of paired Strudel programs and rendered MIDI, and use it for supervised fine-tuning. Second, we refine the model with reinforcement learning on unpaired MIDI, optimizing rewards for both MIDI reconstruction faithfulness and code readability. Our evaluation across synthetic and real-world MIDI benchmarks shows that Decomposer achieves substantially higher MIDI reconstruction faithfulness than closed-source LLMs while producing more readable and diverse code than the heuristic converter.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
symbolic music, decompilation, program synthesis, post-training, music programming languages, code generation, MIDI

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.25 over 4 reviews, above 96% of the others.
Reviewer_VyZGOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes DECOMPOSER, a framework for decompiling symbolic music (MIDI) into Strudel, a music programming language that represents music as high-level, pattern-based instructions. Because paired MIDI–Strudel data is scarce, the authors construct STRUDEL-SYNTH, a synthetic paired corpus, for supervised fine-tuning. They then refine the model with reinforcement learning on unpaired MIDI, using rewards for both reconstruction faithfulness and code readability. The method is evaluated on faithfulness, readability and output diversity across synthetic and real-world MIDI benchmarks, and a human study supplements the automatic readability metrics.

Critical strengths
  1. The idea of recovering high-level musical instructions from symbolic music is compelling. MIDI encodes low-level note events but not the musical structure behind them, such as repetition, chord progressions and rhythmic patterns. Framing this as program decompilation is a natural and interesting way to recover that semantic layer.
  2. Naturally occurring Strudel–MIDI pairs are scarce: the authors found only 688 non-trivial human-authored programs. To address this, the paper proposes an effective pipeline for generating synthetic paired data (LLM-based program generation, cleaning and execution-based rendering). The resulting STRUDEL-SYNTH corpus of about 21K pairs is a useful contribution to the community in its own right.
  3. An 8B open-weight model trained with this framework substantially outperforms frontier LLMs in reconstruction faithfulness while matching their readability. The human study finds it comparable to GPT-5.5. The ablations support the two-stage design: SFT alone transfers poorly to real-world MIDI, and RL without SFT initialization collapses to literal note lists.
Critical weaknesses
  1. I personally like this topic very much, but I am not sure it is suitable for this venue. Even at ISMIR, I suspect many people have not heard of Strudel.
  2. The authors openly acknowledge that the model may be susceptible to reward hacking. However, the objective readability evaluation in Table 2 includes the Rubric score, which is the same as the optimization target used during post-training. Moreover, comparing the objective results with the human evaluation results suggests that the Rubric score favors Decomposer more, suggesting that the rubrics score might not be robust.
Questions for authors
  1. The paper emphasizes readability for Strudel, but does coding really needs to be readable these days?
  2. Do you think the Decompiliation for MIDI will help music understanding?
4 comments
AuthorsOpenReview ↗

Response to Reviewer VyZG (1/2)

We sincerely appreciate your thoughtful review and the effort you put into reviewing our manuscript. We are glad that you found the decompilation framing compelling and Strudel-Synth a useful contribution to the community.To keep our response organized, we restate your comments as the questions below and respond to each in turn. In the revised manuscript, we mark our major revisions in blue.


Summary of the reviewer comments

[W1] Venue relevance: Is this work suitable for ICLR, given that Strudel is unfamiliar to much of the community?

[W2] Robustness of the Rubric score: Rubric is both the RL reward and an evaluation metric in Table 2, and it favors Decomposer more than the human evaluation does. Is it a robust measure of readability?

[Q1] Value of readability: The paper emphasizes readability for Strudel, but does coding really need to be readable these days?

[Q2] Music understanding: Do you think the Decompiliation for MIDI will help music understanding?


Author responses

[W1] Venue relevance

Is this work suitable for ICLR, given that Strudel is unfamiliar to much of the community?

We believe our work fits the venue. The ICLR call for papers (https://iclr.cc/Conferences/2027/CallForPapers) lists music among its application areas, along with reinforcement learning, datasets and benchmarks, and neurosymbolic systems, all of which this work touches.

Although Strudel is not widely known, our underlying problem is broader: recovering faithful, readable executable programs from their outputs without naturally paired data, using synthetic supervision and execution-based RL. Strudel provides a low-resource testbed with a deterministic runtime, where note-by-note listings and compact pattern operators make the distinction between faithfulness and readability clear. Related work at ICLR and NeurIPS explores similar problems with CAD scripts [1], SVG [2], and TikZ [3].

Our experiments, dataset, and parts of the readability rubric are specific to Strudel, so we do not claim empirical generalization to other languages. We nevertheless hope the task formulation and findings will inform future work on symbolic music decompilation.

[W2] Robustness of the Rubric score:

Rubric is both the RL reward and an evaluation metric in Table 2, and it favors Decomposer more than the human evaluation does. Is it a robust measure of readability?

Thank you for raising this. We agree that Rubric is not an independent measure of readability, since it is directly optimized during RL, and that it favors Decomposer more than the human evaluation does. We include Rubric in Table 2 only to show how well the policy satisfies its training objective on held-out inputs, as with Compile rate and Inst F1. Our readability claims rest on Rank and the human study, which agree on two points: Decomposer is much more readable than the heuristic converter, and it is comparable to frontier LLMs. To make this clear, we have marked the metrics used in the reward (Compile rate, Inst F1, and Rubric) with asterisks in Table 2 and revised Section 3.2 to prioritize Rank and human judgments.

[Q1] Value of readability

The paper emphasizes readability for Strudel, but does coding really need to be readable these days?

Thank you for the question. We understand the concern that readability may matter less as LLM agents increasingly write and read code. While this may hold for some software, we believe readability remains important in our setting for two reasons.

First, code remains the medium of live coding performance [5, 6]: musicians write and edit it on stage, often projecting it for the audience [7]. Creative coding likewise treats code as material artists work with directly [8, 9]. Even when AI generates the initial code, readability helps musicians take control, for example, by identifying and changing a repeating pattern without tracing individual notes.

Second, readability also reflects whether a program exposes structure behind the notes. Our heuristic baseline reproduces MIDI almost perfectly (Onset F1 of 0.99 on Strudel-Synth), but its note-by-note listing conveys little beyond the input. Decompilation instead aims to reveal repeated patterns and chord progressions in a readable, editable form. Related work recovers CAD programs from 3D shapes [1], SVG code from images [2], and source code from binaries [4] with similar goals. Such structure may also help AI agents edit music more reliably than a flat list of events.

AuthorsOpenReview ↗

Response to Reviewer VyZG (2/2)

[Q2] Music understanding applications

Do you think the Decompiliation for MIDI will help music understanding?

Yes, we see music understanding as a promising application, as discussed in Appendix J. A decompiled program states musical relationships such as repetition, layering, and harmony explicitly, so they are easier to inspect than in a long sequence of note events. This may also let music understanding benefit from LLMs’ strength in reading and reasoning about code, and because the program is executable, an interpretation can be checked against the rendered music. Our project page (https://decomposer-page.netlify.app/) shows an illustrative example in which an LLM analyzes the same excerpt given as audio, MIDI, and Strudel code, and the Strudel-based analysis was the most accurate. While this single example does not establish a systematic improvement, we believe it illustrates the potential of executable program representations as an interface for music understanding.

[1] M. Kolodiazhnyi et al. cadrille: Multi-modal CAD Reconstruction with Reinforcement Learning. ICLR, 2026.

[2] J. A. Rodriguez et al. Rendering-Aware Reinforcement Learning for Vector Graphics Generation. NeurIPS, 2025.

[3] J. Belouadi, S. P. Ponzetto, and S. Eger. DeTikZify: Synthesizing Graphics Programs for Scientific Figures and Sketches with TikZ. NeurIPS, 2024.

[4] H. Tan, W. Li, X. Tian, S. Wang, J. Liu, J. Li, and Y. Zhang. SK$^2$Decompile: LLM-based Two-Phase Binary Decompilation from Skeleton to Skin. ICLR, 2026.

[5] N. Collins, A. McLean, J. Rohrhuber, and A. Ward. Live Coding in Laptop Performance. Organised Sound, 2003.

[6] G. Wang and P. R. Cook. On-the-fly Programming: Using Code as an Expressive Musical Instrument. NIME, 2004.

[7] A. F. Blackwell, E. Cocker, G. Cox, A. McLean, and T. Magnusson. Live Coding: A User's Manual. MIT Press, 2022.

[8] C. Reas and B. Fry. Processing: Programming for the Media Arts. AI & Society, 2006.

[9] G. Levin and T. Brain. Code as Creative Medium: A Handbook for Computational Art and Design. MIT Press, 2021.

AuthorsOpenReview ↗

Kind reminder as the discussion period ends today

Dear Reviewer VyZG,

With less than 24 hours left in the discussion period, we wanted to follow up on our rebuttal. We would be grateful for a brief note on whether our response addresses your concerns. If any points remain unclear, we would be happy to clarify them before the discussion closes.

Thank you again for your time.

Best regards,

Authors

Reviewer_VyZGOpenReview ↗

I raised my score

I thank the reviewer for the replying all my questions, and will raise the score.

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

This paper studies how to turn MIDI into readable, executable Strudel programs. The authors build Strudel-Synth, a dataset of 21,174 synthetic program–MIDI pairs, and use it to fine-tune Qwen3 models. They then apply reinforcement learning on unpaired MIDI, combining a reconstruction reward with a code-readability reward. The resulting models reconstruct the input more accurately than the general-purpose LLMs evaluated in the paper, while producing code that human participants prefer to the output of a heuristic converter. The paper also examines generalization to other MIDI datasets and the tradeoff between reconstruction accuracy and readability.

Critical strengths
  1. The task is well motivated, and the authors provide a substantial implementation rather than just a few examples. Building paired data by executing synthetic programs is a sensible starting point, and training on unpaired MIDI makes the approach useful beyond the synthetic distribution. I see the main contribution as the task, dataset, and working system.
  2. The improvements are substantial. On LMD, the 8B model improves from 0.10 Onset F1 after SFT to 0.60 after RL, while the strongest frontier-model result in Table 2 is 0.28. Compilation also reaches 0.99. The human study adds useful independent evidence: participants prefer Decomposer to the heuristic converter in 79.5% of readability comparisons. These results make a reasonable case that the system offers something neither baseline provides on its own.
Critical weaknesses
  1. I am not fully convinced by the breadth of the faithfulness claim. The MIDI representation drops note durations, and the prompt asks the model to infer them. Two passages with the same pitches and onsets but different articulation can therefore have the same model input. The reward does not distinguish them either. Reporting Frame F1 helps expose this limitation, but does not resolve it. On LMD, the 8B model scores 0.53 on Frame F1, compared with 0.67 for the heuristic converter. I would either narrow the claim to onset-focused reconstruction or show what happens when duration information is retained.
  2. The readability results are encouraging, but it remains unclear how much comes from recovering useful structure and how much comes from simplifying the music. The heuristic converter preserves substantially more of the input, which may itself make its code harder to read. Human participants see only the code, so their preferences cannot resolve this issue. Several rubric items also reward using particular operators regardless of whether they are helpful for the passage. A stronger comparison would add simple, semantics-preserving compression to the heuristic converter, or compare readability at similar reconstruction quality. An actual editing task would provide more direct support for the editability claim.
Questions for authors

See weaknesses

4 comments
AuthorsOpenReview ↗

Response to Reviewer aRzi (1/3)

We sincerely appreciate your thoughtful review and your encouraging assessment of the task, the dataset, and the system. To keep our response organized, we restate your comments as the questions below and respond to each in turn. Each response starts with a short answer, followed by details with supporting evidence where needed. In the revised manuscript, we mark our major revisions in blue.


Summary of the reviewer comments

[W1] Breadth of the faithfulness claim: Since the MIDI representation drops note durations and the reward does not distinguish them, could the authors either narrow the claim to onset-focused reconstruction or show what happens when duration information is retained?

[W2] Readability-fidelity confound

  • (a) How much of the readability comes from recovering useful structure rather than simplifying the music? Does the result hold at similar reconstruction quality, or against the heuristic converter with simple, semantics-preserving compression?
  • (b) Do the rubric items reward particular operators regardless of whether they are helpful for the passage?
  • (c) Would an actual editing task provide more direct support for the editability claim?

Author responses

[W1] Breadth of the faithfulness claim:

Since the MIDI representation drops note durations and the reward does not distinguish them, could the authors either narrow the claim to onset-focused reconstruction or show what happens when duration information is retained?

Short answer: We did both. We now state our scope of pitch, onset, and instrument explicitly in Sections 1 and 2.2, and explain the reasons for it below. We also ran a preliminary experiment with GPT-5.5 that retains durations in the input. The result suggests a tradeoff: including durations slightly improves duration-sensitive metrics like Frame F1 and Onset+Offset F1, but (i) lowers Onset and Inst F1 and (ii) makes the input/code longer and less readable. Separately, even without duration input, Decomposer-8B reaches a note duration accuracy of 70% on Strudel-Synth and 54% on LMD, higher than all frontier LLMs.

Details:

Justification for excluding duration in the study. First, we would like to clarify that our choice of pitch-onset reconstruction is based on an established evaluation setting. We left durations out of the input and the reward, following prior work on melody transcription that represents each note by its pitch and onset alone [1]. This practice is grounded in a listening study [2] in which onset-only note-level F-measure aligned best with human judgments of transcription quality, and offset (i.e., duration) accuracy was less important than onset accuracy. This focus also suits Strudel, where a note’s duration by default follows from its position in the rhythmic pattern rather than being specified note by note [3]. The existing MIDI-to-Strudel converter [4], our heuristic baseline, likewise uses only note onsets and pitches. We now state this scope explicitly in the revised manuscript (Sections 1 and 2.2).

Effect of retaining duration. As a preliminary study, we prompted GPT-5.5 with and without per-note duration in the MIDI representation ({pitch}@{onset}:d{duration} vs. {pitch}@{onset}) on the Strudel-Synth (N = 1,022) and LMD (N = 1,063) test sets.

DatasetInputCompile rateOnset F1Inst F1Frame F1Onset+Offset F1Rank ↓Input tokensCode length (chars)
Strudel-Synthw/o duration0.7960.5650.4980.6270.3361.462,2761,263
w/ duration0.7670.5330.4670.6440.3571.543,0391,312
Paired difference–−0.040 (p < .001)−0.037 (p < .001)+0.013 (p = 0.32)+0.023 (p = 0.045)+0.08 (p < .001)+34%+4% (p < .001)
LMDw/o duration0.8180.2720.2310.3100.1201.351,1571,034
w/ duration0.8170.2460.2080.3250.1291.651,7201,186
Paired difference–−0.022 (p = 0.22)−0.018 (p = 0.17)+0.016 (p = 0.022)+0.012 (p = 0.16)+0.30 (p < .001)+49%+15% (p < .001)

Onset+Offset F1 follows mir_eval implementation [5] and is computed on pitched notes only. All other metrics follow the definitions in Appendix F.1. Paired differences and p-values are computed with Wilcoxon signed-rank tests over the pieces that compiled in both conditions. (continues in the next post)

AuthorsOpenReview ↗

Response to Reviewer aRzi (2/3)

Adding duration led to small increases in Frame F1 (+0.013 on Strudel-Synth, p = 0.32; +0.016 on LMD, p = 0.022) and Onset+Offset F1 (+0.023, p = 0.045; +0.012, p = 0.16). However, including duration made the input 34% and 49% longer in tokens, and the generated code 4% and 15% longer. Rank also favored the code generated without durations (1.46 vs. 1.54 on Strudel-Synth, p = 0.008; 1.35 vs. 1.65 on LMD, p < 1e-20). On Strudel-Synth, Onset F1 and Inst F1 also decreased significantly (−0.040, p < .001; −0.037, p < .001). These results provide preliminary evidence that including duration trades a small gain in duration-sensitive metrics for longer, less readable code and some loss in onset accuracy.

Duration can be recovered to some extent without duration input. In addition, from our analysis of the outputs in Table 2, we found that durations are partly recovered even though no method receives them as input. Specifically, we computed Onset+Offset F1 and note duration accuracy [6], the percentage of onset-matched non-drum notes whose offsets also match.

Strudel-SynthLMD
MethodOnset+Offset F1 ↑Note duration accuracy ↑Onset+Offset F1 ↑Note duration accuracy ↑
Heuristic0.6465.2%0.4747.6%
Claude-Opus-4.60.2863.0%0.1339.3%
Gemini-3.5-Flash0.2354.9%0.0836.0%
GPT-5.50.3456.6%0.1232.3%
Decomposer (8B)0.4670.3%0.3254.3%

Decomposer (8B)'s note duration accuracy is 70.3% on Strudel-Synth and 54.3% on LMD, higher than all frontier LLMs and the heuristic converter. Its Onset+Offset F1 remains below the heuristic's, since this metric also requires the onset to match and the heuristic's onset accuracy is higher.

[W2] Readability-fidelity confound

(a) How much of the readability comes from recovering useful structure rather than simplifying the music? Does the result hold at similar reconstruction quality, or against the heuristic converter with simple, semantics-preserving compression?

Short answer: Thank you for raising this important point. We ran both comparisons on the test pieces where the heuristic converter and Decomposer-8B both reach Onset F1 ≥ 0.9 (about 28% of each test set). On these pieces, our LLM-judge readability metric (Rank) placed Decomposer's code above both the heuristic output and a compressed version of it for 94.2% of the Strudel-Synth pieces and 88.4% of the LMD pieces. While we recognize that this is not sufficient to claim that Decomposer improves readability without simplifying the music in general, we believe this provides supporting evidence that it can do so in some cases. We have added this analysis to Appendix J.1.

Details:

Readability at similar reconstruction quality, against the compressed heuristic. To check the readability at similar reconstruction quality, we selected the test pieces on which both Heuristic and Decomposer (8B) achieve Onset F1 >= 0.9, so that the two programs describe nearly the same notes. This gives 281 of 1,022 pieces on Strudel-Synth (27.5%) and 297 of 1,063 on LMD (27.9%). As suggested, we also added a semantics-preserving compression of the heuristic output as a third method (Heuristic + Compression). It groups repeated bars with Strudel’s replication operator (!n) and reduces a fully periodic bar list to a single period, and its rendered output is identical to the heuristic’s on every piece. We measure readability with Rank (Appendix F.1), computed here among the three programs for each piece. P-values below are from paired Wilcoxon signed-rank tests.

Strudel-Synth (n = 281)LMD (n = 297)
MethodOnset F1 ↑Rank ↓Ranked firstOnset F1 ↑Rank ↓Ranked first
Heuristic1.002.920.3%0.992.364.8%
Heuristic + Compression1.002.015.5%0.992.446.8%
Decomposer (8B)0.961.0794.2%0.981.2088.4%

Decomposer is ranked first for 94.2% of the Strudel-Synth pieces and 88.4% of the LMD pieces, and its rank is significantly better than both heuristic variants on both datasets (p < 1e-40). Compression helps the heuristic on Strudel-Synth (p < 1e-40) but not on LMD (p = 0.11), likely because exact bar-level repetition is less common in LMD dataset.

AuthorsOpenReview ↗

Response to Reviewer aRzi (3/3)

(b) Do the rubric items reward particular operators regardless of whether they are helpful for the passage?

Short answer: Yes. Our rubric credits operators by their presence, so they can be satisfied by calls that do not help the passage. We identified four recurring patterns of superficial rubric satisfaction, but removing them did not significantly change the Rank-based readability results. We acknowledge this limitation and have added the analysis to Appendix J.2 and discussed future improvements in Section 5.

Details:

Some rubric items are satisfied by calls that have no effect on the music. We identified four recurring code patterns whose removal leaves the rendered MIDI unchanged: empty layers, redundant .scale calls, unused variables, and no-op calls such as .fast(1). Unused variables are sometimes credited by the judge despite the rubric explicitly requiring reuse. All four patterns are more frequent after RL than after SFT alone, suggesting that the model learns to satisfy the rubric superficially.

Removing these calls does not change the readability trends. To see whether these calls drive our readability results, we removed all identified instances and repeated the Rank evaluation from Table 2:

DatasetRank, original (Table 2)Rank, cleanedpPosition among the 8 methods
Strudel-Synth3.833.800.594th → 4th
LMD4.124.000.384th → 4th

Decomposer’s mean Rank did not change significantly (3.83 to 3.80 on Strudel-Synth, p = 0.59; 4.12 to 4.00 on LMD, p = 0.38), and it kept its position among the eight methods. We nevertheless acknowledge this as a limitation, and we thank you for raising it. We have added the full analysis to Appendix J.2 and mentioned it as future work in Section 5.

(c) Would an actual editing task provide more direct support for the editability claim?

Thank you for the suggestion. We agree that an actual editing task would provide more direct support for the editability claim. However, such a study requires a new IRB protocol, a study design, and the recruitment of Strudel users, which is beyond what we can complete during the discussion period. We therefore leave it as future work and have added it to Section 5.

[1] C. Donahue, J. Thickstun, and P. Liang. Melody Transcription via Generative Pre-Training. ISMIR, 2022.

[2] A. Ycart, L. Liu, E. Benetos, and M. Pearce. Investigating the Perceptual Validity of Evaluation Metrics for Automatic Piano Music Transcription. TISMIR, 2020.

[3] Strudel Documentation: Mini-Notation. https://strudel.cc/learn/mini-notation

[4] E. de Jong. MIDI-To-Strudel: Convert MIDI Files to Strudel Code. 2025. https://github.com/Emanuel-de-Jong/MIDI-To-Strudel

[5] C. Raffel, B. McFee, E. J. Humphrey, J. Salamon, O. Nieto, D. Liang, and D. P. W. Ellis. mir_eval: A Transparent Implementation of Common MIR Metrics. ISMIR, 2014.

[6] T. Kwon, D. Jeong, and J. Nam. Towards Efficient and Real-Time Piano Transcription Using Neural Autoregressive Models. TASLP, 2024.

AuthorsOpenReview ↗

Kind reminder as the discussion period ends today

Dear Reviewer aRzi,

With less than 24 hours left in the discussion period, we wanted to follow up on our rebuttal. We would be grateful for a brief note on whether our response addresses your concerns. If any points remain unclear, we would be happy to clarify them before the discussion closes.

Thank you again for your time.

Best regards,

Authors

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

The paper introduces symbolic music decompilation through MIDI-to-Strudel program generation. It constructs STRUDEL-SYNTH, containing 21,174 program–MIDI pairs, and combines supervised fine-tuning with execution-based reinforcement learning to optimize reconstruction fidelity and code readability. Experiments on synthetic, real-world, and out-of-distribution MIDI, complemented by human evaluation, demonstrate improved reconstruction and more readable code than event-level heuristic conversion.

Critical strengths
  1. Useful task, dataset, and training pipeline: The paper introduces a valuable music decompilation task and a 21,174-pair dataset. Its SFT–RL pipeline delivers substantial gains, improving the 8B model’s LMD Onset F1 from 0.10 to 0.60.

  2. Independent evaluation and cross-distribution validation: Human evaluators prefer DECOMPOSER over heuristic conversion in 79.5% of comparisons. Higher Onset F1 than GPT-5.5 across four distribution shifts further supports its generalization.

Critical weaknesses
  1. Limited coverage of reconstruction faithfulness: The input omits note durations and velocities, while the reward evaluates pitch, onset, and instrument agreement. Consequently, the results support partial event reconstruction rather than complete MIDI equivalence.

  2. Structural recovery and editability remain insufficiently validated: The readability rubric may reward superficial operator usage, while code-only human judgments do not establish faithful musical abstraction or editing utility. Fidelity-matched comparisons and controlled editing tasks would strengthen these claims.

Questions for authors
  1. Scope clarification: Why are note durations and velocities omitted from the input? How would including durations affect Frame F1 and the readability tradeoff? If complete MIDI reconstruction is outside the intended scope, could the corresponding claims be narrowed?
  2. Validation: Is the readability reward invariant to musically neutral transformations such as .fast(1)? Have you evaluated readability at matched reconstruction fidelity or compared against heuristic-to-program refactoring constrained by execution checks?
6 comments
AuthorsOpenReview ↗

Response to Reviewer 33uj (1/5)

We sincerely appreciate your careful review and your positive comments on the task, the dataset, and the evaluation. To keep our response organized, we restate your comments as the questions below and respond to each in turn. Each response starts with a short answer, followed by details with supporting evidence where needed. In the revised manuscript, we mark our major revisions in blue.


Summary of the reviewer comments

[W1, Q1] Limited coverage of reconstruction faithfulness

  • (a) Why are note durations and velocities omitted from the input and the reward?
  • (b) How would including durations affect Frame F1 and the readability tradeoff?
  • (c) If complete MIDI reconstruction is outside the intended scope, could the corresponding claims be narrowed?

[W2, Q2] Validation of structural recovery and editability

  • (a) Have you evaluated readability at matched reconstruction fidelity or compared against heuristic-to-program refactoring constrained by execution checks?
  • (b) Is the readability reward invariant to musically neutral transformations such as .fast(1)?
  • (c) Would controlled editing tasks strengthen the claims about editability?

Author responses

[W1, Q1] Limited coverage of reconstruction faithfulness

(a) Why are note durations and velocities omitted from the input and the reward?

Short answer: Our faithfulness metric does not include duration or velocity; it measures note-event agreement in pitch, onset, and instrument. We made this choice because pitch-onset evaluation is an established setting in transcription research [1, 2] and per-note velocity is rare in our data (only 3.1% of human-written Strudel programs set it per note). We have revised the main text to state this scope explicitly (Sections 1 and 2.2).

Details:

While our framework can be extended to handle duration and velocity, in this work we left them out of the input and the faithfulness reward, for the reasons below.

Pitch-onset reconstruction is an established evaluation setting. We evaluate notes by pitch, onset, and instrument, leaving duration and velocity outside the scope. Our choice of pitch and onset follows prior work on melody transcription, which represents notes using these two attributes alone [1]. The perceptual basis for this representation comes from a listening study [2], in which onset-only note-level F-measure aligned best with human judgments of transcription quality and offset accuracy was less important than onset accuracy. This focus also suits Strudel, where a note’s duration by default follows from its position in the rhythmic pattern rather than being specified note by note [5]. The existing MIDI-to-Strudel converter [3], our heuristic baseline, likewise uses only note onsets and pitches. Although our evaluation does not capture all aspects of musical expression, we believe these findings support pitch-onset accuracy as a meaningful measure of reconstruction.

Per-note velocity is uncommon in our data. Explicit per-note velocity control is relatively uncommon in both our Strudel data and the real-world LMD data. Of 688 publicly shared human-written programs we collected, only 61 (8.9%) use .velocity() and only 21 (3.1%) assign it per note. The corresponding proportions in Strudel-Synth are 6.2% (1,321/21,174) and 3.1% (651/21,174). On the input side, 71.4% of the LMD pieces we use have no within-track velocity variation, limiting the prevalence of note-level dynamic variation in this evaluation setting. The existing MIDI-to-Strudel converter [3], our heuristic baseline, also omits velocity.

AuthorsOpenReview ↗

Response to Reviewer 33uj (2/5)

(b) How would including durations affect Frame F1 and the readability tradeoff?

Short answer: Our preliminary experiment using GPT-5.5 suggests a tradeoff: including durations slightly improves duration-sensitive metrics like Frame F1 and Onset+Offset F1, but (i) lowers Onset and Inst F1 and (ii) makes the input/code longer and less readable. Separately, even without duration input, Decomposer-8B reaches a note duration accuracy of 70% on Strudel-Synth and 54% on LMD, higher than all frontier LLMs.

Details:

Effect of including duration. As a preliminary study to examine what changes when duration information is provided, we prompted GPT-5.5 with and without per-note duration in the MIDI representation ({pitch}@{onset}:d{duration} vs. {pitch}@{onset}) on the Strudel-Synth (N = 1,022) and LMD (N = 1,063) test sets. In addition to Frame F1 and Rank, we report Onset F1, Inst F1, and Onset+Offset F1.

DatasetInputCompile rateOnset F1Inst F1Frame F1Onset+Offset F1Rank ↓Input tokensCode length (chars)
Strudel-Synthw/o duration0.7960.5650.4980.6270.3361.462,2761,263
w/ duration0.7670.5330.4670.6440.3571.543,0391,312
Paired difference–−0.040 (p < .001)−0.037 (p < .001)+0.013 (p = 0.32)+0.023 (p = 0.045)+0.08 (p = 0.008)+34%+4% (p < .001)
LMDw/o duration0.8180.2720.2310.3100.1201.351,1571,034
w/ duration0.8170.2460.2080.3250.1291.651,7201,186
Paired difference–−0.022 (p = 0.22)−0.018 (p = 0.17)+0.016 (p = 0.022)+0.012 (p = 0.16)+0.30 (p < .001)+49%+15% (p < .001)

Onset+Offset F1 follows mir_eval implementation [4] and is computed on pitched notes only. All other metrics follow the definitions in Appendix F.1. Paired differences and p-values are computed with Wilcoxon signed-rank tests over the pieces that compiled in both conditions.

Adding duration led to small increases in Frame F1 (+0.013 on Strudel-Synth, p = 0.32; +0.016 on LMD, p = 0.022) and Onset+Offset F1 (+0.023, p = 0.045; +0.012, p = 0.16), significant only for Frame F1 on LMD and Onset+Offset F1 on Strudel-Synth. However, including duration made the input 34% and 49% longer in tokens, and the generated code 4% and 15% longer. Rank also favored the code generated without durations (1.46 vs. 1.54 on Strudel-Synth, p = 0.008; 1.35 vs. 1.65 on LMD, p < .001). On Strudel-Synth, Onset F1 and Inst F1 also decreased significantly (−0.040, p < .001; −0.037, p < .001). These results provide preliminary evidence that including duration trades a small gain in duration-sensitive metrics for longer, less readable code and some loss in onset accuracy.

How well Decomposer recovers duration without duration input. Note that none of the methods in Table 2 (of the manuscript) receive note durations as input. Durations are nevertheless partly recoverable, because Strudel fills them in with a default heuristic when they are not specified: each note is held for the length of its slot in the pattern, which in a sequence without rests means until the onset of the next note. A program that reproduces the rhythm therefore reproduces much of the duration as well.

To check how well they recover durations anyway, we took the same outputs and computed two additional metrics: Onset+Offset F1 and note duration accuracy [6]. Onset+Offset F1 requires both the onset and offset to match for a note to count as correct. Thus, a higher score can reflect improved onset accuracy rather than better duration estimation alone. To assess duration recovery conditional on correct onsets, we also report note duration accuracy: the percentage of onset-matched non-drum notes whose offsets also match.

Strudel-SynthLMD
MethodOnset+Offset F1 ↑Note duration accuracy ↑Onset+Offset F1 ↑Note duration accuracy ↑
Heuristic0.6465.2%0.4747.6%
Claude-Opus-4.60.2863.0%0.1339.3%
Gemini-3.5-Flash0.2354.9%0.0836.0%
GPT-5.50.3456.6%0.1232.3%
Decomposer (8B)0.4670.3%0.3254.3%

Even though duration is not part of its input or reward, Decomposer-8B matches offsets for 70% of its onset-matched notes on Strudel-Synth and 54% on LMD. This is higher than all frontier LLMs and comparable to or above the heuristic converter.

AuthorsOpenReview ↗

Response to Reviewer 33uj (3/5)

(c) If complete MIDI reconstruction is outside the intended scope, could the corresponding claims be narrowed?

We agree that our results support the reconstruction of pitch, onset, and instrument, not complete MIDI equivalence, and we have clarified this explicitly in the manuscript (Sections 1 and 2.2). In addition, we would like to clarify that the proposed framework itself is not tied to this choice. For applications where they matter, such as expressive performance, duration and velocity can be added through the input representation and the reward, with the same training procedure. We have added this direction to Future Work (Section 5).

[W2, Q2] Validation of structural recovery and editability

(a) Have you evaluated readability at matched reconstruction fidelity or compared against heuristic-to-program refactoring constrained by execution checks?

Short answer: Thank you for raising this important point. We ran both comparisons on the test pieces where the heuristic converter and Decomposer-8B both reach Onset F1 ≥ 0.9 (about 28% of each test set). On these pieces, our LLM-judge readability metric (Rank) placed Decomposer’s code above both the heuristic output and a compressed version of it for 94.2% of the Strudel-Synth pieces and 88.4% of the LMD pieces. While we recognize that this is not sufficient to claim that Decomposer improves readability without simplifying the music in general, we believe this provides supporting evidence that it can do so in some cases. We have added this analysis to Appendix J.1.

Details:

We understand the concern as follows. In Table 2, the heuristic converter reproduces almost every note of the input (Onset F1 of 0.99 on Strudel-Synth and 0.95 on LMD), while Decomposer-8B reproduces fewer (0.73 and 0.60). Decomposer’s code could therefore look more readable simply because it writes down less of the music, and Table 2 alone cannot tell this apart from recovering useful structure.

Readability at similar reconstruction quality, against the compressed heuristic. To check the readability at matched fidelity, we selected the test pieces on which both Heuristic and Decomposer (8B) achieve Onset F1 >= 0.9, so that the two programs describe nearly the same notes. This gives 281 of 1,022 pieces on Strudel-Synth (27.5%) and 297 of 1,063 on LMD (27.9%). As suggested, we also added a semantics-preserving compression of the heuristic output as a third method (Heuristic + Compression). It groups repeated bars with Strudel’s replication operator (!n) and reduces a fully periodic bar list to a single period, and its rendered output is identical to the heuristic’s on every piece. We report Rank for measuring readability (definition in Appendix F.1). In the description below, we report p-values from paired Wilcoxon signed-rank tests.

Strudel-Synth (n = 281)LMD (n = 297)
MethodOnset F1 ↑Rank ↓Ranked firstOnset F1 ↑Rank ↓Ranked first
Heuristic1.002.920.3%0.992.364.8%
Heuristic + Compression1.002.015.5%0.992.446.8%
Decomposer (8B)0.961.0794.2%0.981.2088.4%

Decomposer is ranked first for 94.2% of the Strudel-Synth pieces and 88.4% of the LMD pieces, and its rank is significantly better than both heuristic variants on both datasets (p < .001). Compression helps the heuristic on Strudel-Synth (p < .001) but not on LMD (p = 0.11), likely because exact bar-level repetition is less common in LMD dataset.

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

In this paper, the authors present DECOMPOSER, a post-training framework for symbolic music decompilation. They frame the task as MIDI-to-Strudel decompilation, using a two-stage approach with STRUDEL-SYNTH and reinforcement learning on unpaired MIDI data. Experiments across synthetic and real-world MIDI benchmarks show that DECOMPOSER achieves good MIDI reconstruction performance.

Critical strengths

(1) The authors define the symbolic music decompilation task of recovering executable, editable musicprogramming-language code from symbolic music input. To address this practical problem, the authors propose a two-stage framework, named DECOMPOSER. (2) To train and evaluate the proposed method, the authors construct a synthetic corpus of 21,174 (Strudel, MIDI) pairs. (3) The authors designed two evaluation metrics, faithfulness and readability, and introduced them into the reward function to evaluate the generation effect of the Strudel program.

Critical weaknesses

(1) Concerns regarding the synthetic training corpus. The synthetic corpus, STRUDEL-SYNTH, is constructed by frontier LLM generation of Strudel code. Given that the training corpus is synthetically generated by an LLM, it is important to consider whether the optimization objective and evaluation criteria may reflect the same underlying model preferences, potentially leading to improvements within the system being mistaken for genuine progress in real-world performance.

(2) The proposed Faithfulness metric considers pitch matching, the time offsets between note onsets, and MIDI program numbers. However, another fundamental MIDI parameters—velocity—also carry important information about the music. Velocity captures the intensity of individual note events and can substantially affect the resulting musical expression. However, it is unclear whether this parameter is accounted for in the current evaluation.

Questions for authors

(1) Could the authors clarify whether the proposed approach has been fine-tuned on real-world data, including MIDI files and Strudel code written by human users? Since STRUDEL-SYNTH is generated by a frontier LLM, how do the authors ensure that the training data do not reinforce the same model preferences reflected in the evaluation criteria, potentially leading to improvements that are specific to the synthetic data distribution rather than generalizable to real-world use? Would it be possible to augment a corpus of real-world MIDI files and human-authored Strudel code with synthetic data to increase dataset size and diversity, and then evaluate the resulting model on an independent test set of real-world data? Such an evaluation would provide stronger evidence of the proposed approach's generalizability beyond LLM-generated data.

(2) The proposed metric may not sufficiently establish whether the music rendered from the generated Strudel code faithfully corresponds to the reference MIDI. The authors should clarify how velocity can be handled and consider incorporating it into the evaluation to provide a more comprehensive and reliable assessment.

5 comments
AuthorsOpenReview ↗

Response to Reviewer Mamn (1/4)

We sincerely appreciate your insightful comments and the effort you put into reviewing our manuscript. To keep our response organized, we restate your comments as the questions below and respond to each in turn. Each response starts with a short answer, followed by details with supporting evidence. In the revised manuscript, we mark our major revisions in blue.


Summary of the reviewer comments

[W1, Q1] Synthetic data bias and generalization

  • (a) Is Decomposer trained on real-world (human-authored) MIDI and Strudel code, or only on LLM-generated data?
  • (b) Since the training data is LLM-generated, could the training objective and the evaluation criteria reflect the same LLM preferences?
  • (c) Are the gains specific to the synthetic data distribution, or do they generalize to an independent test set of real-world music?

[W2, Q2] Missing velocity evaluation

  • (a) Does the faithfulness metric account for velocity?
  • (b) How can velocity be handled and incorporated into the evaluation?

Author responses

[W1, Q1] Synthetic data bias and generalization

(a) Is Decomposer trained on real-world (human-authored) MIDI and Strudel code, or only on LLM-generated data?

Short answer: Decomposer is trained on real-world MIDI (LMD [1]) in its RL stage, which raises held-out LMD Onset F1 from 0.10 to 0.60 (Table 2 in the manuscript). It is not trained on human-written Strudel code: we deliberately avoid this out of respect for the Strudel community's concerns about training models on users' music [6]. We agree that adding human-written code to training is a valuable direction, and Section 5 of the revised manuscript now discusses collecting a consented corpus for this purpose.

Details:

Real-world (human-authored) MIDI. In our two-stage training pipeline (Section 2.1), SFT uses synthetic Strudel-MIDI pairs, and RL uses a mixture of synthetic MIDI and real-world MIDI from LMD [1], a collection of multi-instrument, multi-genre MIDI files containing arrangements and transcriptions of existing music. As the RL reward executes the generated program using Strudel runtime and compares its output with the input MIDI, Decomposer does not need reference code, and therefore can learn from any real-world MIDI in the RL stage, which realizes the real-world augmentation on MIDI side the reviewer suggests. On held-out LMD, the 8B model’s Onset F1 rises from 0.10 after SFT to 0.60 after RL (Table 2 in the manuscript), showing that RL on real-world MIDI overcomes the limited transfer of synthetic SFT.

Real-world (human-authored) Strudel code. Thank you for the valuable suggestion! We agree that the human-authored Strudel program may differ in style from LLM-generated program, and that our current results do not directly test this. Although we obtained 688 human-authored Strudel programs from the web, we deliberately chose not to use them directly as supervised training targets, taking into account the Strudel community’s expressed concerns about training models on users’ music [6]. A consented corpus, for instance one collected through paid contributions from Strudel practitioners, would let us add human-written code to training, increasing the diversity of the training data. We have added this to the Discussion and Conclusion section (Section 5) in the revised manuscript.

AuthorsOpenReview ↗

Response to Reviewer Mamn (2/4)

(b) Since the training data is LLM-generated, could the training objective and the evaluation criteria reflect the same LLM preferences?

Short answer: We believe that our reward and evaluation criteria do not simply reflect the data generator’s preferences. Faithfulness is measured with standard transcription metrics [11] and involves no LLM. Readability is judged by models different from the data generator, and we also conducted a human study as a check independent of any LLM. Finally, the data generator gains no advantage when evaluated as a baseline, even on the readability metric judged by a model from its own family. We have clarified these points in the revised manuscript (Section 3).

Details:

We understand this concern as follows. Strudel-Synth is generated by Claude-Opus-4.6; therefore, Decomposer may learn this model’s coding style from the synthetic training data. If our reward and evaluation criteria favored that same style, the gains could be overstated. We believe this is not the case in our setup, for three reasons.

Faithfulness metrics are LLM-free. We would like to clarify that faithfulness is computed without any LLM, both as the RL reward (Inst F1) and as an evaluation metric (Onset F1, Frame F1, and Inst F1). The generated program is executed by the deterministic Strudel runtime, and its rendered MIDI is compared with the input MIDI using standard transcription metrics [11], which are computed directly from note events (Section 2.2, Appendix F.1). The score therefore depends only on the notes the program produces, not on how the code is written, and therefore it does not depend on any model’s coding style preferences.

Readability is judged by different models and corroborated by human judgment. For readability, Rubric is optimized during RL using LLM, and Rank is also LLM-based, but both judges differ from the data generator: Strudel-Synth is generated by Claude-Opus-4.6 (Section 2.3), whereas Rubric is judged by Qwen3.6-35B-A3B and Rank by Claude-Opus-4.7 (Appendix F.1). Moreover, the generator model (Claude-Opus-4.6) is not favored in our evaluation, which we detail in below. In addition, as a check independent of any LLM, we conducted a human study on both synthetic and LMD inputs (Section 3.2, Appendix I). Participants preferred Decomposer over the heuristic converter in 79.5% of comparisons overall, with no significant difference from GPT-5.5. We have made these points clearer in the revised manuscript (Section 3).

The generator is not favored. Although Strudel-Synth is generated by Claude-Opus-4.6, the same model gains no advantage when used as a baseline. The table below summarizes the relevant results from Table 2 of the manuscript:

Strudel-SynthLMD
MethodOnset F1 ↑Inst F1 ↑Rank ↓Onset F1 ↑Inst F1 ↑Rank ↓
Claude-Opus-4.60.500.424.410.280.214.47
Gemini-3.5-Flash0.500.413.750.220.174.37
GPT-5.50.570.502.760.270.234.27
Decomposer (8B)0.730.723.830.600.584.12

As shown in the table, Claude-Opus-4.6 is not the most faithful frontier LLM on the data it generated: on Strudel-Synth, its Onset F1 is 0.50, compared with 0.57 for GPT-5.5, and its Inst F1 is below GPT-5.5 on both datasets. On Rank, even though the judge is from the same model family (Claude-Opus-4.7), it is ranked below Gemini-3.5-Flash, GPT-5.5, and Decomposer on both datasets (e.g., 4.41 vs. 2.76 for GPT-5.5 on Strudel-Synth). This suggests that our evaluation does not favor the generator’s preferences.

AuthorsOpenReview ↗

Response to Reviewer Mamn (3/4)

(c) Are the gains specific to the synthetic data distribution, or do they generalize to an independent test set of real-world music?

Short answer: We find that the gains generalize to real-world music. In fact, Decomposer’s margin over the best frontier LLM is larger on held-out real-world LMD (+0.32 Onset F1) than on Strudel-Synth (+0.16) (Table 2). Beyond the training distributions, Decomposer also achieves higher Onset F1 than GPT-5.5 on four further real-world test sets (Section 3.4, Appendix H.1). We also test Decomposer on human-composed music from ModArchive (Appendix H.2), a broad real-world music spanning 51 genres.

Details:

Held-out real-world MIDI. Table 2 includes evaluation on a held-out LMD test set of real-world MIDI. There, Decomposer (8B) improves Onset F1 over the best frontier LLM by +0.32 (0.60 vs. 0.28), compared with +0.16 on Strudel-Synth (0.73 vs. 0.57). The gains are therefore larger on real-world data than on synthetic data.

Datasets beyond the training distributions. To further assess generalization, we tested Decomposer on four held-out datasets of human-authored music that were not used in training: longer LMD excerpts, GigaMIDI [2], NES-MDB [3], and Nottingham [4] (Section 3.4, Appendix H.1). Decomposer achieves higher Onset F1 than GPT-5.5 on all four. Furthermore, we ran a genre-level analysis on 4,463 human-composed pieces from ModArchive [5], covering 51 genres, which shows that Decomposer generalizes best to electronic music while struggling more with genres that have syncopated rhythms or dense note patterns, such as jazz (Appendix H.2). We believe these results show that the gains carry over to real-world music, and they also clarify where Decomposer works best and where it needs the most improvement.

[W2, Q2] Missing velocity evaluation

(a) Does the faithfulness metric account for velocity?

Short answer: Our faithfulness metric does not include velocity; it measures note-event agreement in pitch, onset, and instrument. We made this choice because pitch-onset evaluation is an established setting in transcription research [7, 8] and per-note velocity is rare in Strudel practice (only 3.1% of human-written Strudel programs set it per note). We have revised the main text to state this scope explicitly (Sections 1 and 2.2).

Details:

While our framework can be extended to handle velocity, in this work we left it out of the faithfulness metric, for the two reasons below.

Pitch-onset reconstruction is an established evaluation setting. Prior work on melody transcription represents and evaluates notes as onset-pitch pairs [7], and a listening study found that onset-only note-level F-measure aligned best with human judgments of transcription quality among the standard metrics examined [8]. These findings support this choice as a meaningful measure of reconstruction, although it does not capture all aspects of musical expression.

Per-note velocity is uncommon in the datasets considered. Explicit per-note velocity control is relatively uncommon in both Strudel data and the real-world LMD data. Of 688 publicly shared human-written programs we collected, only 61 (8.9%) use `.velocity()’ and only 21 (3.1%) assign it per note. The corresponding proportions in Strudel-Synth are 6.2% (1,321/21,174) and 3.1% (651/21,174). On the input side, 71.4% of the LMD pieces we use have no within-track velocity variation, limiting the prevalence of note-level dynamic variation in this evaluation setting. The existing MIDI-to-Strudel converter [9], our heuristic baseline, also omits velocity.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Common Response

Dear reviewers and AC,

We sincerely appreciate your valuable time and effort spent reviewing our manuscript.

We propose Decomposer, a framework that recovers readable, executable Strudel programs from MIDI through synthetic supervision and execution-based reinforcement learning. Reviewers found our work well-motivated and compelling (33uj, VyZG, aRzi), highlighting its practical relevance (Mamn), useful dataset (33uj, VyZG), substantial performance gains (33uj, VyZG, aRzi), independent human evaluation (33uj, aRzi), and clear presentation (all).

We appreciate your constructive feedback on our manuscript. In response to the comments, we have carefully revised and enhanced the manuscript as follows:

  • Clarified the reconstruction scope (Sections 1 and 2.2)
  • Clarified reward and evaluation independence from data generation (Section 3)
  • Distinguished reward metrics from readability evidence (Table 2, Section 3.2)
  • Expanded limitations and future work (Section 5).
  • Added matched-fidelity readability comparisons (Appendix J.1).
  • Analyzed superficial rubric satisfaction (Appendix J.2).

In the revised manuscript, these updates are temporarily highlighted in blue for your convenience to check.

We hope these updates address your concerns and make the contributions of Decomposer clearer.

Thank you very much,

Authors.

Dear reviewers,

As the discussion period approached the end, please take a moment to read the authors’ responses and share your thoughts on any remaining points of discussion. If the discussion has changed your assessment, please update your review accordingly.

Thank you for your time and contributions!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.