📄

Paper

DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels

by Haolei Bai, Lingcheng Kong, Xueyi Chen arxiv-paper--unknown--2602.11715

Free2AITools Nexus Index

37.0 Top 100%

S: Semantic 50

A: Authority 0

P: Popularity 0

R: Recency 100

Q: Quality 45

Tech Context

Vital Performance

0 DL / 30D

0.0%

Source →

High Impact - Citations

2024 Year

ArXiv Venue

- FNI Rank

Paper Information Summary
Entity Passport
Registry ID	arxiv-paper--unknown--2602.11715
License	ArXiv
Provider	hf

📜

Cite this paper

Academic & Research Attribution

BibTeX

@misc{arxiv_paper__unknown__2602.11715,
  author = {Haolei Bai, Lingcheng Kong, Xueyi Chen},
  title = {DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels Paper},
  year = {2026},
  howpublished = {\url{https://huggingface.co/papers/2602.11715}},
  note = {Accessed via Free2AITools Knowledge Fortress}
}

APA Style

Haolei Bai, Lingcheng Kong, Xueyi Chen. (2026). DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels [Paper]. Free2AITools. https://huggingface.co/papers/2602.11715

🔬Technical Deep Dive

Full Specifications [+]

⚖️ Free2AITools Nexus Index V2.0

Methodology Index Protocol

Semantic (S) 50

Authority (A) 0

Popularity (P) 0

Recency (R) 100

Quality (Q) 45

💬 Index Insight

FNI V2.0 for DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels: Semantic (S:50), Authority (A:0), Popularity (P:0), Recency (R:100), Quality (Q:45).

Free2AITools Nexus Index

Verification Authority

HuggingFace API GitHub Metadata Arxiv Citation DB System Audit

Unbiased Data Node Refresh: VFS Live

📝 Executive Summary

"Technical abstract for this publication is currently being indexed."

❝ Cite Node

@article{Unknown2026DICE:,
  title={DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels},
  author={},
  journal={arXiv preprint arXiv:arxiv-paper--unknown--2602.11715},
  year={2026}
}

Abstract & Analysis

DICE: Diffusion Large Language Models Excel at Generating CUDA Kernels

DICE : Diffusion Large Language Models Excel at Generating CUDA Kernels

Haolei Bai

Lingcheng Kong

Xueyi Chen

Jianmian Wang

Zhiqiang Tao

Huan Wang

Abstract

Diffusion large language models (dLLMs) have emerged as a compelling alternative to autoregressive (AR) LLMs, owing to their capacity for parallel token generation. This paradigm is particularly well-suited for code generation, where holistic structural planning and non-sequential refinement are critical. Despite this potential, tailoring dLLMs for CUDA kernel generation remains challenging, obstructed not only by the high specialization but also by the severe lack of high-quality training data. To address these challenges, we construct CuKe , an augmented supervised fine-tuning dataset optimized for high-performance CU DA ke rnels. On top of it, we propose a bi -phase c urated r einforcement l earning ( BiC-RL ) framework consisting of a CUDA kernel infilling stage and an end-to-end CUDA kernel generation stage. Leveraging this training framework, we introduce DICE , a series of di ffusion large language models designed for C UDA k e rnel generation, spanning three parameter scales, 1.7B, 4B, and 8B. Extensive experiments on KernelBench demonstrate that DICE significantly outperforms both autoregressive and diffusion LLMs of comparable scale, establishing a new state-of-the-art for CUDA kernel generation.

Machine Learning, ICML

https://deadlykitten4.github.io/DICE/

1

Introduction Large language models (LLMs) have shown powerful ability in a range of language tasks, and the dominant paradigm for LLMs is based on autoregressive modeling (Achiam et al., 2023 ; Grattafiori et al., 2024 ; Liu et al., 2024 ; Guo et al., 2025 ; Yang et al., 2025 ; Comanici et al., 2025 ) for a long time. Recently, diffusion large language models (dLLMs) (Nie et al., 2025 ; Zhu et al., 2025 ; Xie et al., 2025b ; Peng et al., 2025 ) have emerged as a compelling alternative, achieving comparable or even better performance than similarly sized AR LLMs and faster inference speed. Different from the token-by-token generation mechanism introduced by AR LLMs, dLLMs mask the generated sequence and then refine the sequence through iterative denoising steps, which can account for global information and provide remarkably fast inference speed (DeepMind, 2025 ; Labs et al., 2025 ; Song et al., 2025 ) .

Although dLLMs are rarely designed explicitly for code generation, their native bidirectional attention and iterative refinement paradigm align well with the inherently non-sequential nature of code generation (Gong et al., 2025 ; Li et al., 2025d ; Ni et al., 2025b ) , which often demands repeated back-and-forth refinement (Xie et al., 2025a ) . Commercial dLLMs, such as Gemini Diffusion (DeepMind, 2025 ) , Mercury Coder (Labs et al., 2025 ) , and Seed Diffusion (Song et al., 2025 ) , have demonstrated that diffusion-based code models not only match AR LLMs in accuracy across a wide range of standard code evaluation benchmarks, but also deliver substantially faster inference speed.

Despite the remarkable abilities shown by open-source dLLMs designed for code generation (Gong et al., 2025 ; Xie et al., 2025b ; Peng et al., 2025 ) , the specialized and computationally intensive task of kernel generation remains underexplored in the dLLM field, in stark contrast to the fruitful explorations on AR LLMs (Ouyang et al., 2025 ; Baronio et al., 2025 ; Fisches et al., 2025 ; Li et al., 2025c ) . Recent studies (Ni et al., 2025a ; Prabhudesai et al., 2025 ) demonstrate the superior data efficiency of dLLMs, especially under data-bound conditions. Given the scarcity of high-quality kernel data (Kong et al., 2025 ) , dLLMs are uniquely positioned to leverage their architectural advantages for this task. Aiming to bridge the gap, this paper introduces DICE , a series of dLLMs tailored for CUDA kernel generation, spanning parameter sizes of 1.7B, 4B, and 8B. Our key contributions are summarized as follows:

Figure 1 : Overview of DICE . The framework enhances CUDA kernel generation robustness in dLLMs by leveraging TraceRL. This hierarchical approach integrates: (1) Bi-phase Curated Reinforcement Learning framework , a progressive RL training strategy that consists of kernel infilling and end-to-end kernel generation stages to ensure functional correctness and high performance of generated CUDA kernels, and (2) Data Scheduling , transitioning training data from basic single operations to complex whole-model structures during the two RL stages. A valid reward will only be returned when the generated CUDA kernel can be compiled and functions correctly.

•

We propose BiC-RL , a new reinforcement learning paradigm for the CUDA kernel generation task that features a hierarchical progression from easy to hard across both the CUDA kernel data and task complexity.

• We introduce CuKe , a specifically curated supervised fine-tuning dataset that contains a large number of high-performance CUDA kernels.

• Leveraging BiC-RL, we present DICE , which is the first specialized dLLM designed for CUDA kernel generation, to our best knowledge.

• Extensive experiment results demonstrate that DICE achieves strong performance against both autoregressive and diffusion LLMs.

2

Preliminary

2.1

Autoregressive Language Models Autoregressive LLMs estimate the probability of a sequence 𝐱 = [ x 1 , x 2 , … , x L ] \mathbf{x}=[x^{1},x^{2},\dots,x^{L}] by factorizing the joint distribution into conditional probabilities:

text

   p     (  𝐱  )    =    ∏   ℓ  =  1   L    p     (    x  ℓ   ∣    x     <  ℓ    ;  θ    )      ,   p(\mathbf{x})=\prod_{\ell=1}^{L}p(x^{\ell}\mid x^{<\ell};\theta),

(1)

where θ \theta denotes the model parameters and x

Figure 2 : The inference paradigm of diffusion large language models. Left Part : The sequence is divided into several blocks, where the block length equals four in this figure. The block diffusion mechanism enables models to generate autoregressively between blocks, while parallel discrete decoding within blocks. All the KV cache from previous blocks will be reused. Right Part : An actual step-by-step generation trajectory for an example CUDA kernel. While the overall trend remains autoregressive, we can clearly observe lots of non-autoregressive behavior during the generation process.

2.2

Block Diffusion Language Models The block diffusion mechanism, also named semi-autoregressive diffusion decoding, has been widely adopted by several works (Arriola et al., 2025 ; Fathi et al., 2025 ; Han et al., 2023 ) , as it enables variable-length generation and the KV cache mechanism. This hybrid approach decomposes a sequence 𝐱 \mathbf{x} into B B contiguous, non-overlapping blocks, denoted as [ x 1 , x 2 , … , x B ] [x^{1},x^{2},\dots,x^{B}] , where each block contains L ′ L^{\prime} tokens. The model follows an intra-block autoregressive while maintaining inter-block non-autoregressivity (Cheng et al., 2025 ) . Consequently, the training objective is formulated as a weighted cross-entropy loss over these blocks:

text

 ℒ     (  θ  )    \displaystyle\mathcal{L}(\theta)    
   =   −   𝔼    x  ∼   p  data    ,   b  ∼    U     [  1  ,  B  ]    ,  t        \displaystyle=-\mathbb{E}_{x\sim p_{\text{data}},b\sim U[1,B],t}

(2)

text

  [     1  t         ∑   ℓ  =  1    L  ′      𝟏     [    x  t   b  ,  ℓ    =  [M]   ]      log  ⁡   p  θ       (    x  0   b  ,  ℓ    ∣    x  t  b   ,   x     <  b      )      ]   ,   \displaystyle\phantom{=-}\biggl[\frac{1}{t}\sum_{\ell=1}^{L^{\prime}}\mathbf{1}[{x}_{t}^{b,\ell}=\text{[M]}]\log p_{\theta}({x}_{0}^{b,\ell}\mid{x}_{t}^{b},x^{


  where     L  ′   L^{\prime}    is the block size,  [M]  denotes the special  [MASK]  token,     x  t  b   {x}{t}^{b}    represents the corrupted sequence for block    b  b   , and     x  0   b  ,  ℓ    {x}{0}^{b,\ell}    signifies the    ℓ  \ell   -th original token within that block. Thus, the model is trained to reconstruct the original block     x  b   x^{b}    from its noised version     x  t  b   {x}_{t}^{b}   , conditioned on the preceding uncorrupted blocks     x
An illustration of the dLLM generation paradigm is shown in Figure   2  . The left part shows the decoding mechanism, which hybridizes inter-block autoregression with intra-block diffusion to facilitate multi-token parallel decoding. The right part displays an actual generation order of a CUDA kernel, colored according to the temporal generation sequence. Notably, the presence of non-contiguous color blocks throughout the code suggests a non-autoregressive generation process. This observation indicates that kernel generation transcends strict left-to-right sequential dependencies, instead exhibiting significant non-autoregressive properties that align with human programming practices.
3
CuKe Dataset Construction 
To address the scarcity of high-performance data in the field of CUDA kernel generation, we introduce CuKe, an augmented dataset that is substantially improved on top of the ConCuR dataset  (Kong et al.,  2025 ) . We enhance the original dataset from the following two dimensions:
High-Performance Sample. 
While the SFT dataset of cudaLLM  2   provides numerous PyTorch-CUDA pairs, we notice that only 86% exhibit a speedup over their PyTorch equivalents. Furthermore, speedups near     1.0  ×   1.0\times    are often statistically unreliable in GPU environments, as they can be confounded by pseudo-speedup factors such as kernel launch overhead, cache states, or measurement jitter. To ensure that our model learns CUDA kernels with the actual speedup effect, we apply a strict     2.0  ×   2.0\times    speedup threshold as a robust filter. This filtration process guarantees that every data pair represents a substantial and verifiable performance improvement over standard PyTorch implementations. The application of this acceleration threshold yields a refined set of 1,425 high-quality PyTorch-CUDA pairs, ensuring that the model is aligned with truly optimized kernels rather than marginal or statistically noisy improvements.
Structural Diversity. 
Beyond isolated operations, we argue that kernel generation should target the core components of AI systems. To this end, we incorporate complex structures from mainstream LLMs, such as Attention submodules and MLP blocks. To enhance the adaptability of models, we vary the input dimensions for these structures, as the underlying CUDA optimization logic often shifts significantly with tensor shapes. We curate 291 such structural samples and utilize Mercury Coder  (Labs et al.,  2025 )  to generate optimized CUDA kernels. Each candidate is executed up to five times, and only those demonstrating a confirmed speedup are retained. This validation yields 36 functionally verified instances that achieved demonstrable acceleration. Combining the samples from these two diverse dimensions results in a final, high-quality training set of 6,303 samples.
4
Methodology 
In this section, we formalize bi-phase curated reinforcement learning ( BiC-RL ), a training framework that splits reinforcement learning into two progressive stages. Leveraging this hierarchical training paradigm, we develop  DICE , a series of diffusion large language models specially designed for CUDA kernel generation. An overview of the end-to-end framework is illustrated in Figure   1  .
4.1
DICE 
4.1.1
Supervised Fine-tuning 
   Figure 3 :   Our defined CUDA kernel components: the prefix, the suffix, and the core implementation, which is a C++ snippet.  
Empirical results indicate that even state-of-the-art reasoning models, such as Qwen3  (Yang et al.,  2025 )  and Seed-Coder-Reasoning  (Seed et al.,  2025 ) , struggle to generate functionally correct CUDA kernels. This performance gap highlights the difficulty of this task. Consequently, incorporating supervised fine-tuning (SFT) as a cold-start initialization phase is essential to establish the necessary foundational alignment. Specifically, we optimize the model following the block diffusion objective defined in Equation   2  .
4.1.2
BiC-RL 
To further extend the capabilities of DICE in CUDA kernel generation and mitigate the deceptive behavior, we propose a bi-phase curated reinforcement learning framework built upon TraceRL  (Wang et al.,  2025 ) . This framework operates in two dimensions. In the data dimension, we leverage Mercury Coder  (Labs et al.,  2025 )  to categorize the training data into hierarchical difficulty levels, progressing from fundamental operations to complex model structures. In the training dimension, the reinforcement learning process is split into two sequential stages: an initial CUDA kernel infilling stage, followed by an end-to-end CUDA kernel generation stage. This progressive paradigm ensures that the model masters the core implementation of the kernel before transitioning to end-to-end kernel generation.
Kernel In-filling Stage. 
Recent works  (Woo et al.,  2025 )  and community blog  1    1  1  https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/     have highlighted the presence of hacking shortcuts in generated kernels. We characterize this phenomenon as  deceptive behavior , a prevalent issue in generated kernels that remains nontrivial for automated evaluation scripts to detect. Specifically, we identify three primary types: ① the model adheres to prompt-provided example kernel while defaulting to high-level PyTorch functions for the forward pass, effectively bypassing the kernel; ② the model generates a valid custom CUDA kernel but fails to implement the necessary invocation logic; and ③ the custom kernel is omitted from the forward function, precluding its execution during compilation.
To address these challenges, we decompose the optimized CUDA kernel into a tripartite structure: the prefix, the core implementation, and the suffix. As illustrated in Figure   3  , the prefix establishes the execution environment and global dependencies, primarily consisting of library imports (e.g.,  torch ,  cpp_extension ) that define the necessary namespace. The suffix acts as the structural wrapper; it encompasses the low-level CUDA source strings, the  load_inline  compilation logic, and the  nn.Module  class that integrates the kernel into a neural network architecture. And the core implementation part is the main logic of the CUDA kernel ( elementwise_add_source  function in this example) that the model needs to generate. By providing this scaffold, we ensure the model is grounded in the software stack and architectural constraints, allowing it to focus exclusively on the core logic while precluding the possibility of deceptive behavior.
Kernel Generation Stage. 
Once the model has mastered the optimization of core logic for CUDA kernels during the infilling stage, we transition to a full-scale generation objective. In this subsequent phase, we train the model to perform end-to-end generation; given a high-level PyTorch reference, the model must generate the complete implementation of the corresponding CUDA kernel, including all necessary invocation logic. This progression ensures that the foundational knowledge acquired during infilling is successfully scaled to the complete CUDA kernel generation.
5
Experimental Results 
   Table 1 :   Main results on KernelBench across 8B and similar scale models. We report Execution Correctness (Exec) and speedup metrics (    fast  1   \text{fast}{1}    and     fast  2   \text{fast}{2}   ). We compare Autoregressive and Diffusion LLMs, featuring general, code, and reasoning models. The best and second-best results are highlighted in  bold  and  underline , respectively. Results of commercial models are shown in  gray  for reference.  
  Model
  Type
  #Params
  Level1
  Level2
  Level3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Autoregressive LLMs  
  Gemini-3-Pro  
  General  
    
      
        text
        
      
      14.0  14.0    
    
     6.0  6.0     /    5.0  5.0    

    
      
        text
        
      
      14.0  14.0    
    
     7.0  7.0     /    4.0  4.0    

    
      
        text
        
      
      8.0  8.0    
    
     4.0  4.0     /    2.0  2.0    
  Claude-Sonnet-4  
  Code  
    
      
        text
        
      
      44.0  44.0    
    
     10.0  10.0     /    6.0  6.0    

    
      
        text
        
      
      48.0  48.0    
    
     24.0  24.0     /    18.0  18.0    

    
      
        text
        
      
      4.0  4.0    
    
     0.0  0.0     /    0.0  0.0    
  Deepseek-Coder-Instruct-v1.5
  Code  
   7  7    B 

    
      
        text
        
      
      13.0  13.0    
    
     2.0  2.0     /     0.0  0.0   

    
      
        text
        
      
      7.0  7.0    
    
     2.0  2.0     /     1.0  1.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen2.5-Coder-Instruct
  Code  
   7  7    B 

    
      
        text
        
      
      15.0  15.0    
    
     1.0  1.0     /     1.0  1.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      4.0  4.0    
    
     0.0  0.0     /     0.0  0.0   
  Seed-Coder-Reasoning
  Code  
   8  8    B 

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen3
  Reasoning (General)  
   8  8    B 

    
      
        text
        
      
      8.0  8.0    
    
     1.0  1.0     /     0.0  0.0   

    
      
        text
        
      
      25.0  25.0    
    
     11.0  11.0     /     6.0  6.0   

    
      
        text
        
      
      4.0  4.0    
    
     2.0  2.0     /      2.0  ¯   \underline{2.0}   
  cudaLLM
  Reasoning (CUDA)  
   8  8    B 
  46.0  
 12.0   /   7.0 

    
      
        text
        
      
       34.0  ¯   \underline{34.0}    

12.0  ¯   \underline{12.0}     /   6.0 

6.0  6.0    

4.0  ¯   \underline{4.0}     /     0.0  0.0   
    
    Diffusion LLMs  
  Mercury-Coder-Small  
  Code  
    
      
        text
        
      
      26.0  26.0    
    
     16.0  16.0     /    4.0  4.0    

    
      
        text
        
      
      44.0  44.0    
    
     22.0  22.0     /    9.0  9.0    

    
      
        text
        
      
      24.0  24.0    
    
     12.0  12.0     /    10.0  10.0    
  LLaDA-Instruct
  General  
   8  8    B 

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  LLaDA-1.5
  General  
   8  8    B 

    
      
        text
        
      
      1.0  1.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Dream-v0-Instruct
  General  
   7  7    B 

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      2.0  2.0    
    
     2.0  2.0     /      2.0  ¯   \underline{2.0}   
  SDAR-Chat
  General  
   8  8    B 

    
      
        text
        
      
      6.0  6.0    
    
     2.0  2.0     /     1.0  1.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  WeDLM
  General  
   8  8    B 

    
      
        text
        
      
      14.0  14.0    
    
     1.0  1.0     /     1.0  1.0   

    
      
        text
        
      
      1.0  1.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  DiffuCoder-Instruct
  Code  
   7  7    B 

    
      
        text
        
      
      1.0  1.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Dream-Coder-v0-Instruct
  Code  
   7  7    B 

    
      
        text
        
      
      1.0  1.0    
    
     1.0  1.0     /     0.0  0.0   

    
      
        text
        
      
      8.0  8.0    
    
     8.0  8.0     /      5.0  ¯   \underline{5.0}   

    
      
        text
        
      
      6.0  6.0    
    
     0.0  0.0     /     0.0  0.0   
  Stable-DiffCoder
  Code  
   8  8    B 

    
      
        text
        
      
      27.0  27.0    
    
     7.0  7.0     /     4.0  4.0   

    
      
        text
        
      
      5.0  5.0    
    
     4.0  4.0     /     1.0  1.0   

    
      
        text
        
      
       10.0  ¯   \underline{10.0}    
    
     6.0  6.0     /      2.0  ¯   \underline{2.0}   
  Trado-Instruct
  Code & Math  
   8  8    B 

    
      
        text
        
      
      4.0  4.0    
    
     2.0  2.0     /     0.0  0.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      6.0  6.0    

4.0  ¯   \underline{4.0}     /     0.0  0.0   
    
   \rowcolor  DICE
  DICE 
  Kernel (CUDA)  
   8  8    B 

    
      
        text
        
      
       40.0  ¯   \underline{40.0}    

9.0  ¯   \underline{9.0}     /      5.0  ¯   \underline{5.0}   
    
    39.0  
 14.0   /     0.0  0.0   
  16.0  
 8.0   /   4.0 
5.1
Training and Evaluation Setups 
Training Details. 
We initialize our training from SDAR  (Cheng et al.,  2025 ) , utilizing our curated CuKe dataset for the supervised fine-tuning phase.
For the reinforcement learning phase, we sample PyTorch codes from the cudaLLM repository  2    2  2  https://huggingface.co/ByteDance-Seed/cudaLLM-8B     , 992 programs are selected for the kernel infilling stage, while 4,000 programs are utilized for the end-to-end kernel generation stage. For TraceRL  (Wang et al.,  2025 )  RL training, we sample 64 problems with 16 generated responses for each problem at each step. The policy network is optimized with a learning rate of     1  ×   10   −  6     1\times 10^{-6}   , with     ϵ  =  0.2   \epsilon=0.2    and     β  =  0.01   \beta=0.01   . All experiments are conducted on 8 NVIDIA A100 GPUs.
   Table 2 :   Main results on KernelBench across 4B and similar scale models. We report Execution Correctness (Exec) and speedup metrics (    fast  1   \text{fast}{1}    and     fast  2   \text{fast}{2}   ). We compare Autoregressive and Diffusion LLMs, featuring general, code, and reasoning models. The best and second-best results are highlighted in  bold  and  underline , respectively.  
  Model
  Type
  #Params
  Level1
  Level2
  Level3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Llama-3.2-Instruct
  General
  3B
    1.0  1.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  SDAR-Chat
  General  
   4  4    B 

    
      
        text
        
      
       5.0  ¯   \underline{5.0}    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      1.0  1.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      4.0  4.0    
    
     0.0  0.0     /     0.0  0.0   
  Trado-Instruct
  Code & Math
  4B
    1.0  1.0    
   1.0  1.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen2.5-Coder-Instruct
  Code
  3B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      1.0  1.0    
    
     1.0  1.0     /     1.0  1.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Phi-4-Mini-Reasoning
  Reasoning
  4B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen3
  Reasoning
  4B
    3.0  3.0    

    
      
        text
        
      
      2.0  ¯   \underline{2.0}     /      2.0  ¯   \underline{2.0}   
    
    29.0  

    
      
        text
        
      
      14.0  ¯   \underline{14.0}     /      4.0  ¯   \underline{4.0}   
    
    14.0  

    
      
        text
        
      
      2.0  ¯   \underline{2.0}     /     0.0  0.0   
    
   \rowcolor  DICE
  DICE 
  Kernel (CUDA)  
   4  4    B 
  27.0  
 13.0   /   4.0 

    
      
        text
        
      
       24.0  ¯   \underline{24.0}    
    
   15.0   /   9.0 

    
      
        text
        
      
       12.0  ¯   \underline{12.0}    
    
   6.0   /   4.0 
   Table 3 :   Main results on KernelBench across 1.7B and similar scale models. We report Execution Correctness (Exec) and speedup metrics (    fast  1   \text{fast}{1}    and     fast  2   \text{fast}{2}   ). We compare Autoregressive and Diffusion LLMs, featuring general, code, and reasoning models. The best and second-best results are highlighted in  bold  and  underline , respectively.  
  Model
  Type
  #Params
  Level1
  Level2
  Level3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Gemma-2-It
  General
  2B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  SDAR-Chat
  General  
   1.7  1.7    B 

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen2.5-Coder-Instruct
  Code
  1.5B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Deepseek-Coder-Instruct
  Code
  1.3B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  Qwen3
  Reasoning
  1.7B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
       1.0  ¯   \underline{1.0}    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
 \rowcolor  DICE
  DICE 
  Kernel (CUDA)  
   1.7  1.7    B 
  24.0  
 12.0   /   3.0 
  6.0  
 3.0   /   2.0 
  10.0  
 6.0   /   4.0 
   Table 4 :   Evaluation results of DICE models across three parameter scales, 1.7B, 4B, and 8B, at different training stages. And comparison with the RL baseline. The best results are highlighted in  bold  in the respective parameter scales.  
  Model
  Level 1
  Level 2
  Level 3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    SDAR-Chat-8B
    6.0  6.0    
   2.0  2.0     /     1.0  1.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

SFT
34.0  34.0

 16.0   /     4.0  4.0   

    
      
        text
        
      
      18.0  18.0    
    
     11.0  11.0     /   8.0 

    
      
        text
        
      
      16.0  16.0    
    
     2.0  2.0     /     0.0  0.0   

SFT + RL (baseline)
31.0  31.0

   13.0  13.0     /     4.0  4.0   

    
      
        text
        
      
      18.0  18.0    
    
     9.0  9.0     /     6.0  6.0   
  18.0  
   6.0  6.0     /     4.0  4.0   

SFT + RL (kernel infilling)
38.0  38.0

   11.0  11.0     /     4.0  4.0   

    
      
        text
        
      
      20.0  20.0    
    
     11.0  11.0     /     6.0  6.0   

    
      
        text
        
      
      16.0  16.0    
    
     6.0  6.0     /     6.0  6.0   
 \rowcolor  DICE
  DICE-8B 
  40.0  
   9.0  9.0     /   5.0 
  39.0  
 14.0   /     0.0  0.0   

    
      
        text
        
      
      16.0  16.0    
    
   8.0   /   4.0 
  SDAR-Chat-4B
    5.0  5.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      1.0  1.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      4.0  4.0    
    
     0.0  0.0     /     0.0  0.0   

SFT
29.0  29.0

   17.0  17.0     /     6.0  6.0   

    
      
        text
        
      
      21.0  21.0    
    
   16.0   /     5.0  5.0   

    
      
        text
        
      
      10.0  10.0    
    
     2.0  2.0     /     0.0  0.0   

SFT + RL (baseline)
  29.0

 17.0   /   6.0 

    
      
        text
        
      
      20.0  20.0    
    
     11.0  11.0     /     6.0  6.0   

    
      
        text
        
      
      10.0  10.0    
    
     4.0  4.0     /     2.0  2.0   

SFT + RL (kernel infilling)
27.0  27.0

   13.0  13.0     /     4.0  4.0   

    
      
        text
        
      
      23.0  23.0    
    
     14.0  14.0     /     7.0  7.0   

    
      
        text
        
      
      12.0  12.0    
    
     6.0  6.0     /     4.0  4.0   
 \rowcolor  DICE
  DICE-4B 

    
      
        text
        
      
      27.0  27.0    
    
     13.0  13.0     /     4.0  4.0   
  24.0  
   15.0  15.0     /   9.0 
  12.0  
 6.0   /   4.0 
  SDAR-Chat-1.7B
    0.0  0.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

SFT
10.0  10.0

   3.0  3.0     /     2.0  2.0   

    
      
        text
        
      
      2.0  2.0    
    
     2.0  2.0     /     2.0  2.0   

    
      
        text
        
      
      2.0  2.0    
    
     0.0  0.0     /     0.0  0.0   

SFT + RL (baseline)
23.0  23.0

   11.0  11.0     /     2.0  2.0   

    
      
        text
        
      
      4.0  4.0    
    
     2.0  2.0     /     1.0  1.0   

    
      
        text
        
      
      8.0  8.0    
    
     6.0  6.0     /     2.0  2.0   

SFT + RL (kernel infilling)
  25.0

 13.0   /     3.0  3.0   

    
      
        text
        
      
      5.0  5.0    
    
     3.0  3.0     /     2.0  2.0   

    
      
        text
        
      
      6.0  6.0    
    
     6.0  6.0     /     2.0  2.0   
 \rowcolor  DICE
  DICE-1.7B 

    
      
        text
        
      
      24.0  24.0    
    
     12.0  12.0     /   3.0 
  6.0  
 3.0   /   2.0 
  10.0  
 6.0   /   4.0 
   Table 5 :   Performance comparison of SDAR-Chat-8B trained on the SFT dataset of cudaLLM, ConCuR, and our curated CuKe datasets. The best and second-best results are highlighted in  bold  and  underline , respectively.   
  Dataset
  Size
  Level 1
  Level 2
  Level 3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    cudaLLM
  8,920
    24.0  24.0    

    
      
        text
        
      
      15.0  ¯   \underline{15.0}     /   5.0 

7.0  7.0    
    
     5.0  5.0     /     1.0  1.0   

    
      
        text
        
      
      2.0  2.0    

2.0  ¯   \underline{2.0}     /     0.0  0.0   
    
    ConCuR
  4,842
     31.0  ¯   \underline{31.0}    

    
      
        text
        
      
      15.0  ¯   \underline{15.0}     /     2.0  2.0   

 16.0  ¯   \underline{16.0}    
    
   12.0   /   9.0 

    
      
        text
        
      
       12.0  ¯   \underline{12.0}    
    
     0.0  0.0     /     0.0  0.0   
 \rowcolor  DICE
  CuKe 
  6,303
  34.0  
 16.0   /     4.0  4.0   
  18.0  

    
      
        text
        
      
      11.0  ¯   \underline{11.0}     /      8.0  ¯   \underline{8.0}   
    
    16.0  
 2.0   /     0.0  0.0   
   Table 6 :   Performance comparison of DiffuCoder-Instruct-7B and DICE-8B, while excluding deceptive behaviour.   
  Model  
  Robust   
  Check   
  Level 1
  Level 2
  Level 3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    DiffuCoder-Instruct
  ✗
    12.0  12.0    
   6.0  6.0     /     4.0  4.0   

    
      
        text
        
      
      46.0  46.0    
    
     25.0  25.0     /     13.0  13.0   

    
      
        text
        
      
      44.0  44.0    
    
     24.0  24.0     /     0.0  0.0   
  ✓
    1.0  1.0    
   0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   

    
      
        text
        
      
      0.0  0.0    
    
     0.0  0.0     /     0.0  0.0   
  DICE  
 \cellcolor  DICE-1 ✗ 
 \cellcolor  DICE-1     40.0  40.0   
 \cellcolor  DICE-1     9.0  9.0     /     5.0  5.0   
 \cellcolor  DICE-1     43.0  43.0   
 \cellcolor  DICE-1     14.0  14.0     /     0.0  0.0   
 \cellcolor  DICE-1     34.0  34.0   
 \cellcolor  DICE-1     14.0  14.0     /     8.0  8.0   
 \cellcolor  DICE ✓ 
 \cellcolor  DICE     40.0  40.0   
 \cellcolor  DICE     9.0  9.0     /     5.0  5.0   
 \cellcolor  DICE     39.0  39.0   
 \cellcolor  DICE     14.0  14.0     /     0.0  0.0   
 \cellcolor  DICE     16.0  16.0   
 \cellcolor  DICE     8.0  8.0     /     4.0  4.0   
Evaluation Benchmark and Metrics. 
We evaluate DICE and other models on KernelBench  (Ouyang et al.,  2025 ) , which is divided into three levels, covering a total of 250 tasks. Level 1 contains 100 single-kernel operators (e.g.,  Convolution ), Level 2 contains 100 fusion patterns (e.g.,  Matmul + Sigmoid ), and Level 3 includes 50 full model architectures (e.g.,  Mamba ). The model will be given a one-shot prompt, as presented in Appendix   A  , to guide it to generate a CUDA kernel based on the given PyTorch reference. The primary evaluation metrics are functional correctness, which assesses whether the generated kernels compile and execute equivalently to the PyTorch implementations, and     fast  p   \text{fast}_{p}   , which measures the speedup performance over the PyTorch implementation, defined as follows:

    
      
        text
        
      
         fast  p   =    1  N       ∑   i  =  1   N    𝟙     (    correct  i   ∧   {    SpeedUp  i   >  p   }    )       ,   \text{fast}_{p}=\frac{1}{N}\sum_{i=1}^{N}\mathbbm{1}(\text{correct}_{i}\land\{\text{SpeedUp}_{i}>p\}),    
    
    (3)  
where    N  N    is the number of tasks in each level,    p  p    denotes the speedup factor, for example,     fast  2   \text{fast}_{2}    indicates that the generated kernels are both correct and at least twice as fast as the PyTorch implementation.
Compared Models. 
To evaluate the effectiveness of DICE, we conduct a comprehensive comparison, including general, code-based, and reasoning models across AR and diffusion LLMs, and a model designed for CUDA kernel generation:
 • 
1.7B Scale Models:  We evaluate Gemma-2-2B-It  (Team et al.,  2024 ) , SDAR-1.7B-Chat  (Cheng et al.,  2025 ) , Qwen2.5-Coder-1.5B-Instruct  (Hui et al.,  2024 ) , DeepSeek-Coder-1.3B-Instruct  (Guo et al.,  2024 ) , and Qwen3-1.7B  (Yang et al.,  2025 ) .
 • 
4B Scale Models:  Our selection covers Llama-3.2-3B-Instruct  3    3  3  https://huggingface.co/meta-llama/Llama-3.2-3B-Instruct    , SDAR-4B-Chat  (Cheng et al.,  2025 ) , TraDo-4B-Instruct  (Wang et al.,  2025 ) , Qwen2.5-Coder-3B-Instruct  (Hui et al.,  2024 ) , Phi-4-Mini-Reasoning-4B  (Xu et al.,  2025 ) , and Qwen3-4B  (Yang et al.,  2025 ) .
 • 
8B Scale Models:  The AR LLMs comprise DeepSeek-Coder-7B-Instruct-v1.5  (Guo et al.,  2024 ) , Qwen2.5-Coder-7B-Instruct  (Hui et al.,  2024 ) , and Seed-Coder-8B-Reasoning  (Seed et al.,  2025 ) . We also include cudaLLM-8B  2  , which is designed for CUDA kernel generation, and a reasoning model Qwen3-8B  (Yang et al.,  2025 ) . Regarding dLLMs, we evaluate both general models such as LLaDA-8B-Instruct  (Nie et al.,  2025 ) , LLaDA-1.5  (Zhu et al.,  2025 ) , Dream-v0-Instruct-7B  (Ye et al.,  2025 ) , SDAR-8B-Chat  (Cheng et al.,  2025 ) , WeDLM-8B-Instruct  (Liu et al.,  2025 ) , and code models including Dream-Coder-v0-Instruct-7B  (Xie et al.,  2025b ) , DiffuCoder-7B-Instruct  (Gong et al.,  2025 ) , TraDo-8B-Instruct  (Wang et al.,  2025 ) , and Stable-DiffCoder-8B-Instruct  (Fan et al.,  2026 ) .
Beyond this, we also compare with commercial models, including Gemini-3-Pro  (Comanici et al.,  2025 ) , Claude-Sonnet-4  4    4  4  https://www.anthropic.com/news/claude-4    , and Mercury-Coder-Small  (Labs et al.,  2025 ) .
Evaluation Details. 
We evaluate all models using their default inference configurations, just varying the maximum output token length. Specifically, for AR LLMs, we set a maximum generation length of 32,768 for reasoning models and 4,096 for general and code models to fully utilize their capabilities. Regarding dLLMs, those subject to fixed-length generation sequence constraints (LLaDA, Dream, and DiffuCoder) are evaluated with a maximum of 1,024 output tokens. This threshold is empirically sufficient for complete CUDA kernel generation. Conversely, for dLLMs featuring adaptive stopping mechanisms, such as SDAR, TraDo, WeDLM, Stable-DiffCoder, and our DICE series, we set a maximum generation length of 4,096 tokens, as these models can terminate generation upon completion. More experimental details are provided in Appendix   B  .
5.2
Experimental Results 
Main Results on KernelBench. 
Tables   1  ,   2  , and   3   summarize the performance of our DICE models across the 8B, 4B, and 1.7B scales. These results validate the effectiveness of our method, as our models consistently demonstrate the state-of-the-art performance against both autoregressive and diffusion LLMs. Specifically, DICE-8B achieves comparable results with cudaLLM, which is noteworthy given that cudaLLM utilizes substantially larger datasets and more output tokens. Detailed comparison analysis with cudaLLM is discussed in Appendix   C  . Furthermore, DICE-8B completely exceeds the strong commercial model, Gemini-3-Pro. And the DICE-4B model successfully outperforms several 8B-scale models. In the smaller parameter scale, while most 1.7B-scale models fail to generate functionally correct kernels, DICE-1.7B demonstrates high performance, particularly on Level 1 tasks, showcasing the robustness of our training paradigm at smaller scales.
Analysis of Multiple Training Stages. 
The evaluation results of different training stages presented in Table   4   quantify the incremental performance enhancements of our hierarchical BiC-RL framework. Across all parameter scales, the supervised fine-tuning phase establishes the necessary baseline competence for CUDA kernel generation. This stage is particularly critical for the 1.7B model, which struggles to generate functionally correct kernels without SFT. Notably, the kernel infilling stage effectively improves model performance. The resulting DICE model family consistently outperforms RL baselines across most metrics, validating the effectiveness of our training paradigm.
   Figure 4 :   RL training trajectory comparison of BiC-RL framework and baseline RL on 8B model.  
Analysis of Supervised Fine-tuning Dataset. 
We evaluate the impact of different training datasets on the supervised fine-tuning of SDAR-Chat-8B  (Cheng et al.,  2025 ) , specifically comparing the SFT dataset of cudaLLM, the original ConCuR dataset  (Kong et al.,  2025 ) , and our curated CuKe dataset. The comparative performance results are detailed in Table   6  . Empirical results indicate that fine-tuning with our curated CuKe dataset consistently yields superior performance across these metrics. Crucially, these findings underscore a data-efficient scaling law in the specialized kernel generation area: model ability is not primarily driven by high data volume, but by the strategic integration of high-performance samples.
   Figure 5 :   Comparison of correctness trends for BiC-RL and baseline RL of 8B model on KernelBench Level 2.  
Effectiveness of BiC-RL Framework. 
We analyze the RL training trajectories of our proposed BiC-RL framework against the RL baseline, with the comparative results illustrated in Figure   4  . In this table, correctness denotes the online success rate, the percentage of functionally accurate kernels generated relative to the training samples at each step of the RL process. Following the completion of the foundational kernel infilling phase, the model exhibits a significantly higher initial correctness in the generation stage compared to the baseline. Notably, we can observe a clear upward trend, representing a performance improvement and convergence stability facilitated by our hierarchical training paradigm. By decomposing the complexity level of the task, our framework enables the model to progressively master CUDA kernel generation while effectively avoiding the optimization plateaus that frequently occur in RL training.
Figure   5   illustrates the comparative evaluation results for the 8B model trained by the BiC-RL framework against the RL baseline. Evaluations are conducted on the KernelBench Level 2 every ten training steps. As shown, the BiC-RL framework demonstrates a consistent improvement in execution correctness, reflecting a stable alignment with the kernel generation task. In contrast, the baseline RL exhibits stochastic instability, and it is difficult to observe training gains, highlighting the key function of the kernel infilling stage and data scheduling during training.
Analysis of Deceptive Behaviour. 
Following the discussion in Section   4.1.2  , we provide a comparative analysis to quantify the impact of deceptive behavior on model evaluation. Empirical results suggest that such behavior is pervasive across most models. However, its prevalence correlates strongly with model ability and task complexity. Specifically, the lower the ability of the models and the higher the task difficulty, the more severe these deceptive behaviors become. Table   6   contrasts the performance of DiffuCoder-Instruct-7B  (Gong et al.,  2025 )  and our DICE-8B, presenting the performance difference when deceptive samples are strictly excluded, where the robust check indicates the inspection for deceptive behaviour. Notably, DiffuCoder-Instruct-7B exhibits serious deceptive behavior, particularly at Levels 2 and 3. In contrast, DICE-8B demonstrates robustness on Level 1 and 2, only showing deceptive behaviour at Level 3, which is the most difficult task in KernelBench  (Ouyang et al.,  2025 ) . This underscores the effectiveness of our BiC-RL framework in precluding deceptive behaviors during generation. Representative qualitative examples of these behaviors, ranging from example-matching to bypassed invocations, are detailed in Appendix   D  .
6
Related Work 
Diffusion Large Language Models. 
The paradigm of large language models has been dominated by autoregressive  (Achiam et al.,  2023 ; Liu et al.,  2024 ; Yang et al.,  2025 )  for a long time, but the emergence of diffusion large language models  (Nie et al.,  2025 ; Zhu et al.,  2025 ; DeepMind,  2025 ; Labs et al.,  2025 ; Ye et al.,  2025 )  has broken this, offering a new choice for language models. Unlike autoregressive methods, which use a strict left-to-right, token-by-token decoding process, dLLMs first generate multiple masks, then gradually denoise the masked sequence during decoding, which allows for simultaneous sampling and decoding of multiple tokens. Moreover, dLLMs employ a bidirectional attention mechanism to more comprehensively understand the context. Advancing models, such as LLaDA  (Nie et al.,  2025 ) , an 8B-parameter diffusion language model trained from scratch, and Dream  (Ye et al.,  2025 ) , a 7B-parameter model initialized from pre-trained AR-based model weights. SDAR  (Cheng et al.,  2025 )  synergistically combines the advantages of diffusion and autoregressive. TraDo  (Wang et al.,  2025 )  proposes TraceRL, deriving the first long-CoT dLLM, which achieves strong performance over models of comparable parameter size. More recently, WeDLM  (Liu et al.,  2025 )  represents the first dLLM to surpass industrial autoregressive engines while maintaining high performance on reasoning tasks.
dLLMs for Code Generation.  Code generation is a crucial and relatively challenging task for dLLMs, while it is still under exploration. CodeFusion  (Singh et al.,  2023 )  is the first to propose a diffusion-based language model for code generation, but it is limited to small-scale models and simple tasks. Recently, DiffuCoder  (Gong et al.,  2025 )  demonstrates remarkable capabilities in code generation. Dream-Coder  (Xie et al.,  2025b )  further improves the performance, and Stable-DiffCoder  (Fan et al.,  2026 )  achieves the current best performance. Open-dCoder  (Peng et al.,  2025 )  competes with much larger dLLMs, despite being only 0.5B parameters. Moreover, commercial dLLMs, like Gemini Diffusion  (DeepMind,  2025 ) , Mercury Coder  (Labs et al.,  2025 ) , and Seed Diffusion  (Song et al.,  2025 ) , have demonstrated that dLLMs can achieve performance comparable to leading autoregressive code models while offering significantly faster generation speeds. However, when it comes to more challenging domains such as kernel generation, the potential of dLLMs remains largely unexplored.
LLM Kernel Generation.  The advancement of LLMs has shifted the focus from general programming to hardware-specific task, kernel generation. Central to this progress is the development of specialized benchmarks, such as KernelBench  (Ouyang et al.,  2025 ) , MultiKernelBench  (Wen et al.,  2025 ) , TritonBench  (Li et al.,  2025b ) , and FlashInfer-Bench  (Xing et al.,  2026 ) , which provide standardized environments for evaluating functional correctness and execution efficiency. Beyond evaluation, recent research emphasizes improving generation quality through sophisticated training paradigms and reasoning alignment. Specifically, Kevin  (Baronio et al.,  2025 ) , TritonRL  (Woo et al.,  2025 ) , and AutoTriton  (Li et al.,  2025c )  employ reinforcement learning to navigate models to effectively generate high-performance GPU kernels. More recently, agentic systems such as Astra  (Wei et al.,  2025 ) , CudaForge  (Zhang et al.,  2025 ) , and KernelEvolve  (Liao et al.,  2025 )  have introduced iterative refinement workflows to achieve near-expert performance. On the other hand,  Kong et al. ( 2025 )  notices the data scarcity issue of high-quality kernels and proposes ConCuR, an SFT dataset especially for CUDA kernel generation. Despite this progress toward kernel generation, how dLLMs can be effectively leveraged to address this challenging task remains an underexplored domain.
7
Conclusion 
In this paper, we curate the  CuKe  dataset to provide a robust foundation for supervised fine-tuning, mitigating the scarcity of high-quality training data in this domain. Then we introduce  BiC-RL , which is specifically designed for CUDA kernel generation. Combining kernel infilling and end-to-end kernel generation stages can effectively improve training efficiency and enhance convergence. Our extensive experiments demonstrate that each training stage contributes significantly to stable convergence, and their combination yields substantial performance improvements. By integrating these components, we develop  DICE , a family of diffusion large language models spanning three parameter scales, opening up a new perspective for this specialized area.
Impact Statement
The goal of this work is to advance the field of CUDA kernel generation. Specifically, we curate the  CuKe  dataset, a new reinforcement learning framework,  BiC-RL , and a series of models called  DICE , aiming to automate and CUDA kernel generation. By significantly lowering the technical barrier for high-performance computing (HPC) optimization, our research has the potential to accelerate the development of efficient AI systems and scientific computing tools. From a sustainability perspective, the improved kernel efficiency directly contributes to reduced energy consumption in large-scale data centers. We believe that by releasing our whole pipeline, we foster an open-source ecosystem that promotes the development of high-performance AI infrastructure.
References
 Achiam et al. (2023) 
Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al.
 Gpt-4 technical report.
  arXiv preprint arXiv:2303.08774 , 2023.
 Arriola et al. (2025) 
Arriola, M., Gokaslan, A., Chiu, J. T., Yang, Z., Qi, Z., Han, J., Sahoo, S. S., and Kuleshov, V.
 Block diffusion: Interpolating between autoregressive and diffusion language models.
  arXiv preprint arXiv:2503.09573 , 2025.
 Baronio et al. (2025) 
Baronio, C., Marsella, P., Pan, B., Guo, S., and Alberti, S.
 Kevin: Multi-turn rl for generating cuda kernels.
 In  ES-FoMo III: 3rd Workshop on Efficient Systems for Foundation Models , 2025.
 Cheng et al. (2025) 
Cheng, S., Bian, Y., Liu, D., Zhang, L., Yao, Q., Tian, Z., Wang, W., Guo, Q., Chen, K., Qi, B., et al.
 Sdar: A synergistic diffusion-autoregression paradigm for scalable sequence generation.
  arXiv preprint arXiv:2510.06303 , 2025.
 Comanici et al. (2025) 
Comanici, G., Bieber, E., Schaekermann, M., Pasupat, I., Sachdeva, N., Dhillon, I., Blistein, M., Ram, O., Zhang, D., Rosen, E., et al.
 Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities.
  arXiv preprint arXiv:2507.06261 , 2025.
 DeepMind (2025) 
DeepMind, G.
 Gemini diffusion, 2025.
 URL  https://blog.google/technology/google-deepmind/gemini-diffusion .
 Fan et al. (2026) 
Fan, C., Heng, W., Li, B., Liu, S., Song, Y., Su, J., Qu, X., Shen, K., and Wei, W.
 Stable-diffcoder: Pushing the frontier of code diffusion large language model.
  arXiv preprint arXiv:2601.15892 , 2026.
 Fathi et al. (2025) 
Fathi, N., Scholak, T., and Noël, P.-A.
 Unifying autoregressive and diffusion-based sequence generation.
  arXiv preprint arXiv:2504.06416 , 2025.
 Fisches et al. (2025) 
Fisches, Z. V., Paliskara, S., Guo, S., Zhang, A., Spisak, J., Cummins, C., Leather, H., Synnaeve, G., Isaacson, J., Markosyan, A., and Saroufim, M.
 Kernelllm: Making kernel development more accessible, 2025.
 URL  https://huggingface.co/facebook/KernelLLM .
 Gong et al. (2025) 
Gong, S., Zhang, R., Zheng, H., Gu, J., Jaitly, N., Kong, L., and Zhang, Y.
 Diffucoder: Understanding and improving masked diffusion models for code generation.
  arXiv preprint arXiv:2506.20639 , 2025.
 Grattafiori et al. (2024) 
Grattafiori, A., Dubey, A., Jauhri, A., Pandey, A., Kadian, A., Al-Dahle, A., Letman, A., Mathur, A., Schelten, A., Vaughan, A., et al.
 The llama 3 herd of models.
  arXiv preprint arXiv:2407.21783 , 2024.
 Guo et al. (2024) 
Guo, D., Zhu, Q., Yang, D., Xie, Z., Dong, K., Zhang, W., Chen, G., Bi, X., Wu, Y., Li, Y., et al.
 Deepseek-coder: When the large language model meets programming–the rise of code intelligence.
  arXiv preprint arXiv:2401.14196 , 2024.
 Guo et al. (2025) 
Guo, D., Yang, D., Zhang, H., Song, J., Zhang, R., Xu, R., Zhu, Q., Ma, S., Wang, P., Bi, X., et al.
 Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
  arXiv preprint arXiv:2501.12948 , 2025.
 Han et al. (2023) 
Han, X., Kumar, S., and Tsvetkov, Y.
 Ssd-lm: Semi-autoregressive simplex-based diffusion language model for text generation and modular control.
 In  ACL , 2023.
 Hui et al. (2024) 
Hui, B., Yang, J., Cui, Z., Yang, J., Liu, D., Zhang, L., Liu, T., Zhang, J., Yu, B., Lu, K., et al.
 Qwen2. 5-coder technical report.
  arXiv preprint arXiv:2409.12186 , 2024.
 Kong et al. (2025) 
Kong, L., Wei, J., Shen, H., and Wang, H.
 Concur: Conciseness makes state-of-the-art kernel generation.
  arXiv preprint arXiv:2510.07356 , 2025.
 Labs et al. (2025) 
Labs, I., Khanna, S., Kharbanda, S., Li, S., Varma, H., Wang, E., Birnbaum, S., Luo, Z., Miraoui, Y., Palrecha, A., et al.
 Mercury: Ultra-fast language models based on diffusion.
  arXiv preprint arXiv:2506.17298 , 2025.
 Li et al. (2025a) 
Li, C., Zhang, Y., Li, J., Cai, L., and Li, G.
 Beyond autoregression: An empirical study of diffusion large language models for code generation.
  arXiv preprint arXiv:2509.11252 , 2025a.
 Li et al. (2025b) 
Li, J., Li, S., Gao, Z., Shi, Q., Li, Y., Wang, Z., Huang, J., WangHaojie, W., Wang, J., Han, X., et al.
 Tritonbench: Benchmarking large language model capabilities for generating triton operators.
 In  ACL Findings , 2025b.
 Li et al. (2025c) 
Li, S., Wang, Z., He, Y., Li, Y., Shi, Q., Li, J., Hu, Y., Che, W., Han, X., Liu, Z., et al.
 Autotriton: Automatic triton programming with reinforcement learning in llms.
  arXiv preprint arXiv:2507.05687 , 2025c.
 Li et al. (2025d) 
Li, T., Chen, M., Guo, B., and Shen, Z.
 A survey on diffusion language models.
  arXiv preprint arXiv:2508.10875 , 2025d.
 Liao et al. (2025) 
Liao, G., Qin, H., Wang, Y., Golden, A., Kuchnik, M., Yetim, Y., Ang, J. J., Fu, C., He, Y., Hsia, S., et al.
 Kernelevolve: Scaling agentic kernel coding for heterogeneous ai accelerators at meta.
  arXiv preprint arXiv:2512.23236 , 2025.
 Liu et al. (2024) 
Liu, A., Feng, B., Xue, B., Wang, B., Wu, B., Lu, C., Zhao, C., Deng, C., Zhang, C., Ruan, C., et al.
 Deepseek-v3 technical report.
  arXiv preprint arXiv:2412.19437 , 2024.
 Liu et al. (2025) 
Liu, A., He, M., Zeng, S., Zhang, S., Zhang, L., Wu, C., Jia, W., Liu, Y., Zhou, X., and Zhou, J.
 Wedlm: Reconciling diffusion language models with standard causal attention for fast inference.
  arXiv preprint arXiv:2512.22737 , 2025.
 Ni et al. (2025a) 
Ni, J., Liu, Q., Dou, L., Du, C., Wang, Z., Yan, H., Pang, T., and Shieh, M. Q.
 Diffusion language models are super data learners.
  arXiv preprint arXiv:2511.03276 , 2025a.
 Ni et al. (2025b) 
Ni, J., Liu, Q., Du, C., Dou, L., Yan, H., Wang, Z., Pang, T., and Shieh, M. Q.
 Training optimal large diffusion language models.
  arXiv preprint arXiv:2510.03280 , 2025b.
 Nie et al. (2025) 
Nie, S., Zhu, F., You, Z., Zhang, X., Ou, J., Hu, J., Zhou, J., Lin, Y., Wen, J.-R., and Li, C.
 Large language diffusion models.
 In  NeurIPS , 2025.
 Ouyang et al. (2025) 
Ouyang, A., Guo, S., Arora, S., Zhang, A. L., Hu, W., Ré, C., and Mirhoseini, A.
 Kernelbench: Can llms write efficient gpu kernels?
 In  ICML , 2025.
 Peng et al. (2025) 
Peng, Z., Zhang, S., Tong, A., and contributors.
 Open-dllm: Open diffusion large language models, 2025.
 URL  https://github.com/pengzhangzhi/Open-dLLM .
 Prabhudesai et al. (2025) 
Prabhudesai, M., Wu, M., Zadeh, A., Fragkiadaki, K., and Pathak, D.
 Diffusion beats autoregressive in data-constrained settings.
  arXiv preprint arXiv:2507.15857 , 2025.
 Seed et al. (2025) 
Seed, B., Zhang, Y., Su, J., Sun, Y., Xi, C., Xiao, X., Zheng, S., Zhang, A., Liu, K., Zan, D., et al.
 Seed-coder: Let the code model curate data for itself.
  arXiv preprint arXiv:2506.03524 , 2025.
 Singh et al. (2023) 
Singh, M., Cambronero, J., Gulwani, S., Le, V., Negreanu, C., and Verbruggen, G.
 Codefusion: A pre-trained diffusion model for code generation.
 In  EMNLP , 2023.
 Song et al. (2025) 
Song, Y., Zhang, Z., Luo, C., Gao, P., Xia, F., Luo, H., Li, Z., Yang, Y., Yu, H., Qu, X., et al.
 Seed diffusion: A large-scale diffusion language model with high-speed inference.
  arXiv preprint arXiv:2508.02193 , 2025.
 Team et al. (2024) 
Team, G., Riviere, M., Pathak, S., Sessa, P. G., Hardin, C., Bhupatiraju, S., Hussenot, L., Mesnard, T., Shahriari, B., Ramé, A., et al.
 Gemma 2: Improving open language models at a practical size.
  arXiv preprint arXiv:2408.00118 , 2024.
 Wang et al. (2025) 
Wang, Y., Yang, L., Li, B., Tian, Y., Shen, K., and Wang, M.
 Revolutionizing reinforcement learning framework for diffusion large language models.
  arXiv preprint arXiv:2509.06949 , 2025.
 Wei et al. (2025) 
Wei, A., Sun, T., Seenichamy, Y., Song, H., Ouyang, A., Mirhoseini, A., Wang, K., and Aiken, A.
 Astra: A multi-agent system for gpu kernel performance optimization.
 In  NeurIPS 2025 Fourth Workshop on Deep Learning for Code , 2025.
 Wen et al. (2025) 
Wen, Z., Zhang, Y., Li, Z., Liu, Z., Xie, L., and Zhang, T.
 Multikernelbench: A multi-platform benchmark for kernel generation.
  arXiv eprints, pp. arXiv–2507 , 2025.
 Woo et al. (2025) 
Woo, J., Zhu, S., Nie, A., Jia, Z., Wang, Y., and Park, Y.
 Tritonrl: Training llms to think and code triton without cheating.
  arXiv preprint arXiv:2510.17891 , 2025.
 Xie et al. (2025a) 
Xie, Z., Chen, L., Mao, W., Xu, J., Kong, L., et al.
 Teaching language models to critique via reinforcement learning.
  arXiv preprint arXiv:2502.03492 , 2025a.
 Xie et al. (2025b) 
Xie, Z., Ye, J., Zheng, L., Gao, J., Dong, J., Wu, Z., Zhao, X., Gong, S., Jiang, X., Li, Z., et al.
 Dream-coder 7b: An open diffusion language model for code.
  arXiv preprint arXiv:2509.01142 , 2025b.
 Xing et al. (2026) 
Xing, S., Zhai, Y., Jiang, A., Dong, Y., Wu, Y., Ye, Z., Ruan, C., Huang, Y., Zhang, Y., Yin, L., et al.
 Flashinfer-bench: Building the virtuous cycle for ai-driven llm systems.
  arXiv preprint arXiv:2601.00227 , 2026.
 Xu et al. (2025) 
Xu, H., Peng, B., Awadalla, H., Chen, D., Chen, Y.-C., Gao, M., Kim, Y. J., Li, Y., Ren, L., Shen, Y., et al.
 Phi-4-mini-reasoning: Exploring the limits of small reasoning language models in math.
  arXiv preprint arXiv:2504.21233 , 2025.
 Yang et al. (2025) 
Yang, A., Li, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Gao, C., Huang, C., Lv, C., et al.
 Qwen3 technical report.
  arXiv preprint arXiv:2505.09388 , 2025.
 Ye et al. (2025) 
Ye, J., Xie, Z., Zheng, L., Gao, J., Wu, Z., Jiang, X., Li, Z., and Kong, L.
 Dream 7b: Diffusion large language models.
  arXiv preprint arXiv:2508.15487 , 2025.
 Zhang et al. (2025) 
Zhang, Z., Wang, R., Li, S., Luo, Y., Hong, M., and Ding, C.
 Cudaforge: An agent framework with hardware feedback for cuda kernel optimization.
  arXiv preprint arXiv:2511.01884 , 2025.
 Zhu et al. (2025) 
Zhu, F., Wang, R., Nie, S., Zhang, X., Wu, C., Hu, J., Zhou, J., Chen, J., Lin, Y., Wen, J.-R., et al.
 Llada 1.5: Variance-reduced preference optimization for large language diffusion models.
  arXiv preprint arXiv:2505.19223 , 2025.
Appendix A
One-shot Prompt Templates 
The one-shot prompt for the kernel infilling RL stage is illustrated as follows. We incorporate a comprehensive contextual demonstration to guide the model in generating the core C++ code while maintaining logic alignment with the provided prefix and suffix. The  example_pytorch_reference  and  example_generated_cuda_kernel  in these prompts are the same as defined in KernelBench  (Ouyang et al.,  2025 ) , which is the element-wise addition operation.
For the subsequent end-to-end kernel generation stage, the corresponding one-shot prompt is as follows. The structure of this prompt adheres strictly to the benchmark specifications defined in KernelBench, ensuring that our reinforcement learning objectives remain aligned with standard evaluation protocols.
Appendix B
Experimental Details 
B.1
Supervised Fine-tuning Details 
 We choose the SDAR model family  (Cheng et al.,  2025 )  as our base models, which contain models across three parameter scales (1.7B, 4B, and 8B). As mentioned in Section   5.1  , we conduct supervised fine-tuning on our curated CuKe dataset for three epochs using 8 NVIDIA A100 GPUS, with a learning rate of     1.0  ×   10   −  5     1.0\times 10^{-5}   .
B.2
RL Sampling Details 
During the reinforcement learning stage, we employ a block size of 4 and the dynamic decoding strategy introduced in SDAR  (Cheng et al.,  2025 ) , with a threshold     τ  =  0.9   \tau=0.9   . The inference hyperparameters are set at       t    o    p   −  p   =  1.0   top-p=1.0   ,       t    o    p   −  k   =  0   top-k=0   , and      t    e    m    p    e    r    a    t    u    r    e   =  1.0   temperature=1.0   . We train for 20 steps in the kernel infilling phase and 100 steps during the end-to-end kernel generation phase. For each step, we sample 64 problems, each with 16 generated responses.
B.3
Evaluation Details 
In this section, we provide details on evaluation configurations to ensure a rigorous, transparent comparison across dLLMs.
 • 
For LLaDA-Instruct  (Nie et al.,  2025 )  and LLaDA-1.5  (Zhu et al.,  2025 ) , we set a maximum of 1,024 generated tokens, with a block size of 32 and a temperature of 0.0. The overall steps are equal to the generation sequence length.
 • 
For Dream-v0-Instruct  (Ye et al.,  2025 )  and Dream-Coder-v0-Instruct  (Xie et al.,  2025b ) , we set a maximum of 1,024 generated tokens, with temperatures of 0.2 and 0.1. The overall steps are equal to the generation sequence length.
 • 
For DiffuCoder-Instruct  (Gong et al.,  2025 ) , we set a maximum of 1,024 generated tokens, with a temperature of 0.3. The overall steps are equal to the generation sequence length.
 • 
For SDAR-Chat  (Cheng et al.,  2025 ) , Trado-Instruct  (Wang et al.,  2025 ) , and our DICE models, we employ the static decoding introduced in SDAR. We use a threshold       t    o    p   −  p   =  1.0   top-p=1.0   ,       t    o    p   −  k   =  1   top-k=1   , and      t    e    m    p    e    r    a    t    u    r    e   =  1.0   temperature=1.0   , with a default block size of 4 and a maximum of 4,096 generated tokens.
 • 
For WeDLM  (Liu et al.,  2025 ) , we set a maximum of 4,096 generated tokens, leveraging the optimized wedlm engine to accelerate inference, with a temperature of 0.2.
 • 
For Stable-DiffCoder  (Fan et al.,  2026 ) , we set a maximum of 4,096 generated tokens, with a block size of 4 and a temperature of 0.0.
Appendix C
Results Comparison 
We conduct a multi-dimensional comparison between cudaLLM and DICE, as summarized in Table   7  . As cudaLLM is a reasoning model, we set a substantial maximum generation length to 32,768 tokens to accommodate its extensive Chain-of-Thought (CoT) contents. Furthermore, cudaLLM utilizes high-volume training data, leveraging 8,920 samples for supervised fine-tuning and 71,996 samples for reinforcement learning. In contrast, DICE operates within a more constrained generation window of 4,096 tokens and employs a compact training set of only 6,303 SFT and 4,992 RL samples. Despite this reduction in data volume and computational budget, DICE achieves performance parity with cudaLLM. Notably, our model demonstrates superior performance on relatively difficult tasks (Levels 2 and 3), while remaining highly competitive, though marginally suboptimal, on Level 1.
   Table 7 :   Comparison results of cudaLLM and DICE on KernelBench. Tokens indicate the maximum output tokens, SFT and RL represent the training data volume in each stage.  
  Model
  Language
  #Params  
  #Tokens   
  SFT
  RL
  Level 1
  Level 2
  Level 3  
  Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    Exec  

    
      
        text
        
      
      fast  1   \textbf{fast}_{\textbf{1}}     /      fast  2   \textbf{fast}_{\textbf{2}}   
    
    cudaLLM
  CUDA
  8B
  32,768
  8,920
  71.996
  46.0  
 12.0   /   7.0 

    
      
        text
        
      
      34.0  34.0    
    
     12.0  12.0     /   6.0 

    
      
        text
        
      
      6.0  6.0    
    
     4.0  4.0     /     0.0  0.0   
 \rowcolor  DICE
  DICE 
  CUDA
  8B
  4,096
  6,303
  4,992
    40.0  40.0    
   9.0  9.0     /     5.0  5.0   
  39.0  
 14.0   /     0.0  0.0   
  16.0  
 8.0   /   4.0 
Appendix D
Case Study of Deceptive Behaviour 
In this section, we present representative case studies of deceptive behavior in generated kernels. In the following generated CUDA kernel, the model replicates the element-wise addition example provided in the prompt, while the actual tensor multiplication is performed by the high-level  torch.matmul  function within the forward pass. Although the model is tasked with generating a specialized matrix multiplication kernel, it exhibits superficial structural mimicry without implementing the requisite low-level logic.

    
      
        text
        
      
            Similarly, in the following case, the model generates a custom CUDA kernel but fails to instantiate it within the  ModelNew  constructor, opting instead to utilize high-level PyTorch operators for the final implementation.
                   



      In the following case, the model generates a custom CUDA kernel and initializes it in the  ModelNew  constructor, but it is not called in the forward function, utilizing high-level PyTorch operators for the final implementation. Formally, these instances constitute a failure to fulfill the core CUDA kernel generation objective; however, due to the limitations of current evaluation frameworks, such outputs are erroneously categorized as functionally correct. Consequently, rigorous verification is essential to exclude these false positives and ensure the accuracy of the evaluation results.

 
  📦Data Source: hf
🔄 Daily sync (03:00 UTC)
AI Summary: Based on hf metadata. Not a recommendation.

📊 FNI Methodology
📚 Knowledge Baseℹ️ Verify with original source

    🛡️ Paper Transparency Report 
 Technical metadata sourced from upstream repositories.
 
  
 
Open Metadata
 
 
    🆔 Identity & Source 
    id 
 arxiv-paper--unknown--2602.11715
 
  slug 
 unknown--2602.11715
 
  source 
 hf
 
  author 
 Haolei Bai, Lingcheng Kong, Xueyi Chen
 
  license 
 ArXiv
 
  tags 
 paper, research, llm, diffusion
 
 
 
  ⚙️ Technical Specs 
    architecture 
 null
 
  params billions 
 null
 
  context length 
 null
 
  pipeline tag 
 
 
 
 
  📊 Engagement & Metrics 
    downloads 
 0
 
  stars 
 0
 
  forks 
 0
 
 
 
 
  
Data indexed from public sources. Updated daily.

Metadata CoverageWe index Quick Start, Datasets Used, and Benchmarks via upstream pipelines. Sections are hidden when empty for this entity -- not all source providers expose every field.

Cite this paper

🔬Technical Deep Dive

⚖️ Free2AITools Nexus Index V2.0

💬 Index Insight

Verification Authority

📝 Executive Summary

❝ Cite Node

Abstract & Analysis

Abstract

1

2

2.1

2.2

3

4

4.1

4.1.1

4.1.2

5

Gemini-3-Pro General

Claude-Sonnet-4 Code

Mercury-Coder-Small Code

5.1

5.2

6

7

Impact Statement

References

Appendix A

Appendix B

B.1

B.2

B.3

Appendix C

Appendix D

🛡️ Paper Transparency Report

🆔 Identity & Source

⚙️ Technical Specs

📊 Engagement & Metrics