acceptodds
Under review as a conference paper at ICLR 2027

SynKer: Synthesize, Kernelize, Reinforce - Teaching GPU Kernel Generation to Small Language Models

Abstract

Combining test-time scaling with verifier execution feedback has demonstrated glimpses of frontier language models (LMs) being able to generate GPU kernels. However, small LMs still lack the capability to robustly produce compilable backend-specific code. We argue that this is largely due to a lack of diverse training environments and validated kernel datasets, representative of the target domain. To this end, we introduce SynKer, a general recipe for improving LM kernel generation capabilities via synthetic task and solution generation: By evolving and translating natural-language task descriptions, we generate a large-scale set of diverse target operations. We then leverage evolutionary test-time search to generate an end-to-end validated kernel dataset across target backends. Finally, we use the resulting dataset to post-train open-source LMs of different families and scales using supervised fine-tuning and reinforcement learning. The resulting set of task environments contains 2365 validated and configurable synthetic tasks and a kernel archive consisting of approximately 100k kernels across three backends. We demonstrate that the synthetic data enables effective post-training across a range of LMs. We further find that, under supervised fine-tuning (SFT), increased task diversity improves both validation performance and generalization to the held-out task, while the resulting SFT checkpoints provide better initializations for the subsequent reinforcement learning process. Together, these results indicate that SynKer offers a practical and effective pipeline to improve the LMs kernel generation capabilities.

Primary area:
foundation or frontier models, including LLMs
Keywords:
kernel generation, large lanauge model, machine learning, evolutionary algorithm

Reviews

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

SynKer presents a pipeline for generating synthetic GPU-kernel tasks, searching for verified implementations, and post-training language models on the resulting archive. Task descriptions evolve from a seed, while evolutionary kernel search produces CUDA, Triton, and HIP implementations checked by execution. The resulting resource contains 2,365 task environments and 105,689 verified kernel triples. SFT experiments study task diversity and evaluate held-out BackendBench correctness; exploratory RL experiments examine training behavior under different initializations.

Critical strengths
  1. The verified multi-backend task and kernel archive is a useful potential research resource. Building configurable environments together with implementations and verification feedback addresses an important bottleneck in kernel-generation training.

  2. The fixed-kernel-budget task-diversity study is more informative than simply scaling the number of examples. Combined with held-out BackendBench results, it provides evidence that broader task coverage can improve the usefulness of synthetic training data. I lean toward acceptance primarily for this resource and empirical contribution.

Critical weaknesses
  1. The pipeline combines established task generation, evolutionary search, and post-training methods. Its main novelty seems to be the verified multi-backend resource, rather than a new algorithm.

  2. The downstream results mainly support the dataset and SFT stage; the RL evidence is still exploratory. The paper does not yet show that RL improves held-out performance or that the fine-tuned models generate faster kernels.

Questions for authors
  1. Beyond combining synthetic task generation, existing evolutionary code search, and standard post-training, what is the distinctive methodological contribution of SynKer? Please identify which design decision is necessary for the reported findings and is not inherited from the underlying components.

  2. The task-generation novelty filter is based on task-description similarity. What evidence in the existing analysis shows that the resulting diversity reflects different computational structures or kernel implementation requirements, rather than primarily different application descriptions? How does that distinction affect the interpretation of the fixed-budget diversity study?

  3. Should the central contribution be understood as a verified multi-backend resource and an SFT data-diversity finding, or as a validated end-to-end SFT-plus-RL method? Given the exploratory status of RL and the correctness-focused downstream evaluation, which conclusions are specifically attributable to the RL stage rather than the dataset and SFT initialization?

1 comment
AuthorsOpenReview ↗

Response to Reviewer oH3R

Thank you for highlighting the two main contributions of our paper: the verified multi-backend archive and the fixed-budget task-diversity study. Totally agree with you to distinguish between data construction, SFT and RL. Thank you for taking the time!

“Beyond combining synthetic task generation, existing evolutionary code search, and standard post-training, what is the distinctive methodological contribution of SynKer?”

Algorithm 1 in Section 3 and Appendix A detail our task generation procedure, which starts with a single seed task and iteratively mutates task descriptions. We screen the proposals against the verified multi-backend archive and create an executable PyTorch reference with configurable inputs/correctness tests for each proposal. This allows us to verify candidates on all three backends. We leverage the existing ShinkaEvolve search to obtain multiple implementations for each task. This allows us to disentangle tasks & implementations, which is crucial for our fixed-budget study of task diversity.

While we do not claim that any single generation step is crucial, this approach allows us to treat the same task as a verification for all three backends.

“What evidence in the existing analysis shows that the resulting diversity reflects different computational structures or kernel implementation requirements, rather than primarily different application descriptions?”

The novelty filter and Figure 2 both operate on description-level properties. Table 1 gives an overview of different computational requirements (lattice stencil update, 1-D cosine transform, point-cloud plane fitting) and how search is used to incentivize alternative implementations for the same task. Section 3 covers this in more detail. While there are different computations in the archive, we do not track how often tasks share an operator or implementation pattern.

Fig. 4-5 provides some evidence that there is a positive relationship between the number of executable tasks covered within a fixed example budget & SFT improvements. However, it says nothing about the contribution of any single computational pattern.

“Given the exploratory status of RL and the correctness-focused downstream evaluation, which conclusions are specifically attributable to the RL stage rather than the dataset and SFT initialization?”

Figure 5 reports the SFT-only results. For RL, we perform a new rebuttal evaluation on 114 held-out NVIDIA ComputeEval CUDA tasks. After SFT, Qwen3-32B has a pass@1 of 19.59% ± 1.34%. After RL, this improves to 22.81% ± 1.75% (mean ± SD over three runs). Note that this is with thinking disabled. We claim that our RL transfer results only hold for this setting. Appendix B.4 reports on the median speedups of search-generated kernels versus eager mode for PyTorch. We observe that Triton and CUDA benefit from 4.37× and 10.37× speedup, respectively. Note that we do not evaluate the runtime of the kernels generated by fine-tuned models.

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

SynKer trains smaller language models to write GPU kernels. The method creates PyTorch tasks, then repeatedly changes and tests code to produce CUDA, Triton, and HIP implementations. The authors report 2,365 tasks and about 106,000 kernel implementations that pass their tests. They use supervised fine-tuning and also try reinforcement learning, which trains models using rewards.

The authors measure validation loss, a score for predicting reference code, on separate tasks for Qwen3 and Gemma4. They also test generated Triton code on BackendBench for Qwen3. The main finding is that more distinct training tasks improve results at a similar number of examples. The reinforcement-learning results mainly show progress during training, not better performance on new tasks.

Critical strengths

The proposed dataset can support research across several kernel programming languages. It includes tasks with adjustable inputs, several implementations per task, and scientific-computing examples beyond standard neural-network operations. The authors also use execution tests to assess generated code. Clearer counts and filtering rules can help establish the dataset’s quality and usefulness.

The comparison of task coverage is the strongest result. Training groups A, B, and C use more distinct tasks while keeping about 15,000 examples per language. The authors report lower Qwen3 validation loss and better BackendBench results. This supports the value of varied tasks without increasing the number of examples.

Critical weaknesses

The main evaluation numbers and dataset counts do not match the stated method. Section 4.3 defines pass@1 as the percentage of 271 operations where one generated kernel passes every test. Figure 5 reports 8.42%, but 23 successes out of 271 gives 8.49%, and success counts must be whole numbers. Table 1 implies about 1,863 solved Triton tasks, but 1,754 training tasks plus 200 validation tasks total 1,954. Different counting methods, dataset versions, or reporting errors can explain these gaps, but the paper does not explain them. These gaps reduce confidence in the results and require clarification, not an assumption of misconduct.

The paper lacks comparisons against existing kernel data or simpler methods that generate and test code. A comparison using KernelBook data, the same starting model, and the same training budget can help show what SynKer adds. Earlier work such as KernelLLM already trains a smaller model on paired PyTorch and Triton examples. The reinforcement-learning results show training progress, not added gains on tasks excluded from training. Section 4.3 reports no measurable reward gain from mixing Triton and CUDA, despite the discussion’s claim that mixing languages helps. These gaps weaken the broader claims, although the supervised fine-tuning results remain promising.

Questions for authors

What exact set of operations and counting method produced Figure 5? Please give the success counts and explain any averages or excluded operations. How do these results match the stated test of one generated kernel for each of 271 operations?

How do the solved-task counts in Table 1 match the training and validation counts in Section 4.3 and Table 5? Did different dataset versions or filters produce these counts? When you mix languages during training, do you exclude the same validation tasks from every language?

Do you have comparisons using existing paired data with the same starting model and training budget? Do you have comparisons against a simpler method that repeatedly generates and tests code? These results can show whether SynKer adds value beyond training models for this specific task.

Do results on new tasks show extra gains from reinforcement learning or mixed-language training? If not, can you limit these claims to the training results shown?

1 comment
AuthorsOpenReview ↗

Response to Reviewer 5Ciq

Thank you for pointing out the configurable & execution-tested tasks for different kernel languages and the fixed-budget comparison of task coverage! (We had an error in our Figure 5 description.)

“What exact set of operations and counting method produced Figure 5? Please give the success counts and explain any averages or excluded operations.”

In Section 4.3 we correct our statement that the BackendBench evaluation covers 338 entries corresponding to 297 distinct bfloat16 OpInfo operations. This differs from our initial statement of 271 and reflects a counting error. For each operation, we sample one kernel and consider it successful only if all test cases pass. Figure 5 uses the same 297-operation denominator and counts the # of single attempts per operation. In the table we show the # of solved operations.

Qwen3BaseTier ATier BTier CTier D
8B017182313
14B45192519
32B54253130

In particular, 25/297 = 8.42% after rounding.

“How do the solved-task counts in Table 1 match the training and validation counts in Section 4.3 and Table 5? […] When you mix languages during training, do you exclude the same validation tasks from every language?

In Section 4.3 and Appendix C.2 we provide a breakdown of the number of solved synthetic Triton tasks. Table 1 shows that 1,863 tasks have been solved. Of these, 200 were used for validation and the remaining 1,663 for training. The 91 solved KernelBench tasks sum up to the 1,754 training tasks in Table 5. The last 200 task IDs are selected separately for each backend and pooled over languages. This guarantees a within-backend holdout & is separate from the downstream evaluation by BackendBench.

“Do you have comparisons using existing paired data with the same starting model and training budget? Do you have comparisons against a simpler method that repeatedly generates and tests code?”

During rebuttal we trained Qwen3 on 9,492 KernelBook examples (after length filtering to SynKer tier C), for three epochs and 447 optimizer steps. KernelBook reached 0.3% / 0% BackendBench pass@1 at 8B / 14B, versus 7.74% / 8.42% for SynKer. The example and step budgets match (tokens per epoch differ: 18.68M / 25.02M for KernelBook / SynKer). Table 1 reports the number of tasks solved by evolutionary search using a model ensemble. We leave it open to future work to perform a compute-matched comparison with independent generate-and-test attempts.

“Do results on new tasks show extra gains from reinforcement learning or mixed-language training?”

On 114 held-out NVIDIA ComputeEval CUDA tasks, Qwen3-32B with thinking disabled improved from 19.59% ± 1.34% after SFT to 22.81% ± 1.75% after RL (three-run mean pass@1 ± SD). This evaluates the RL step. We do not have held-out evidence for any language mixing gains. Triton-only and Triton+CUDA SFT initializations yield similar RL training rewards in Figure 6. We will correct the broader claim in Section 5.

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

The paper introduces a method called SynKer. In this paper, Synker has a three-stage pipeline for improving GPU kernel generation in small models. First, it evolves synthetic PyTorch task environments from a single seed task through LLM mutation/LLM diversity judge. Then, it runs ShinkaEvolve search over these tasks to collect about 100k verified kernels across CUDA, Triton, and HIP. Finally, it trains Qwen3 and Gemma4 models with LoRA and evaluates these models on BackendBench. The main finding is that task diversity matters more than kernel volume for SFT under a fixed budget.

Critical strengths
  1. The problem is well motivated and meaningful. It is very important to get scalable and execution-verified training data for kernel generation/optimization. The authors provide a multi-backend dataset which could be valuable to the community for further research.
  2. The diversity ablation is cleanly designed and meaningful. Tiers A–C fix the kernel budget while varying the number of tasks, which I think ensure a fair evaluation. Experiments in Tier D isolates the effect of data volume, also is a good point.
  3. The paper presents concrete and clear reward hacks observed during RL, such as no-op Triton kernels. It also discusses about limitations such as naive reference implementations.
Critical weaknesses
  1. The paper needs more benchmarks and baselines. The only downstream result is Triton pass@1 on BackendBench. There is no CUDA or HIP evaluation and no runtime evaluation, and the diversity claim relies mainly on synthetic validation loss. I think the paper also lacks comparisons to SFT on KernelBook at matched scale, to existing kernel-specialized models (Dr. Kernel, StitchCUDA,Kevin-32B).

  2. Data quality need to be ensured. The SFT corpus may contain exactly the hacks behaviors later observed during RL. I think the paper should report how many kernels are containing these possible hacks. In addition, the RL section evaluates only training reward, with no held-out evaluation after RL.

Questions for authors

Please see the weaknesses, thanks.

1 comment
AuthorsOpenReview ↗

Response to Reviewer 7bEK

Thank you for highlighting the importance of execution-verified training data across backends, the fixed-budget diversity ablation & providing concrete examples of reward hacking.

“The only downstream result is Triton pass@1 on BackendBench. There is no CUDA or HIP evaluation and no runtime evaluation, and the diversity claim relies mainly on synthetic validation loss.”

During rebuttal, we evaluated Qwen3-32B on 114 CUDA tasks from NVIDIA ComputeEval (release 2026-2). With thinking disabled, the mean pass@1 over three runs for the base model is 18.42% ± 1.52%, after SynKer SFT it becomes 19.59% ± 1.34% and finally after RL it reaches 22.81% ± 1.75% after RL (mean ± SD). This provides a held-out CUDA correctness result for RL. The downstream evidence for task diversity comes from Triton. At a fixed example budget, expanding from tier A to C (Figure 5):

  • 8B: 5.72% → 7.74%
  • 14B: 1.68% → 8.42%
  • 32B: 1.35% → 10.44%

Held-out HIP correctness and the runtime of model-generated kernels are still outstanding. Appendix B.4 reports timings for kernels produced by evolutionary search.

“I think the paper also lacks comparisons to SFT on KernelBook at matched scale, to existing kernel-specialized models (Dr. Kernel, StitchCUDA, Kevin-32B).”

We trained the same Qwen3 backbones on KernelBook using tier C's 9,492 usable examples and 447 optimizer steps. On BackendBench, KernelBook scores 0.3% at 8B and 0% at 14B, while SynKer reaches 7.74% and 8.42% respectively.

Note that the token counts per epoch differed (18.68M vs. 25.02M). One possible reason for this is that KernelBook examples rely on compiler-generated context, while BackendBench requires a self-contained implementation. On ComputeEval, Kevin-32B with an empty-think prefill reached 22.51% ± 3.32% at 1,233 output tokens on average. Our RL model reached 22.81% at 495 tokens. The difference can be attributed to Kevin’s technique of suppressing reasoning via empty-think prefill.

“The SFT corpus may contain exactly the hacks behaviors later observed during RL. I think the paper should report how many kernels are containing these possible hacks.”

We agree that matching reference outputs can miss a no-op kernel when PyTorch performs the computation. Section 3 details the execution checks used to admit SFT examples. Appendices C.5–C.7 detail the failure cases observed during RL and the corresponding judge used to flag them. This behavior is not corpora-wide, and we cannot infer its prevalence in SFT based on the RL examples.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Rebuttal Comments to all Reviewers

Thank you to all three reviewers for your feedback. Thank you for your many questions! SynKer provides an execution-verified archive, which includes CUDA, Triton and HIP runtimes. We evaluate the task coverage for a fixed training budget. Furthermore, we added two more comparisons and want to clarify the construction of the dataset as well as the evaluation procedure of the models.

SynKer's novelty lies in our method for generating executable tasks from a single seed. For each accepted task, we provide a configurable PyTorch reference implementation & tests to validate your code across backends (Section 3, Algorithm 1). Multiple verified implementations for each task are then collected using ShinkaEvolve. This provides a synthetic dataset of environments and solutions, which enables effective post-training.

This allows us to answer the Q: Does training on more distinct tasks help when the example budget is fixed? Figure 5 illustrates that increasing the task coverage from tier A to tier C improved the held-out Triton pass@1 for all three Qwen3 model sizes.

In addition to the main rebuttal experiments, we provide a set of supplementary experiments:

  • On 114 CUDA tasks of NVIDIA ComputeEval, Qwen3-32B reaches 18.42% pass@1 before any training (thinking disabled), 19.59% after SFT and 22.81% after RL (three-run means). This directly shows the return of an RL gain on held-out CUDA tasks. The runtime of the generated kernels is not precisely known.

  • On the KernelBook baseline, we train for the same # train examples and optimizer steps as SynKer. On BackendBench at 8B/14B, SynKer reaches 7.74%/8.42%. KernelBook reached 0.3% and 0% with the same backbones

In the denominator of the Figure 5 (Section 4.3) we had an error stating 297 operations. It should perform 297 operations (8.42% = 25 successes in 297 attempts). We have fixed the manuscript. More precise information on the SFT dataset can be found in Appendix C.2: The Triton counts are based on 1,863 solved synthetic tasks split into a training set of 1,663 and a validation set of 200. Additionally, 91 KernelBench tasks (total of 1,754) were used for training.

Finally, we want to clarify the language mixing claim made in Section 5. We evaluated whether adding CUDA to Triton during the SFT phase had any measurable effect on subsequent RL training reward. Figure 6 shows that it didn't.

Thank you very much for the feedback from the reviewers. Please feel free to ask any further questions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.