Awesome-LLM-Kernel-Agent

KO | EN

gitlite — search

#awesome-list #kubernetes #api #rag #automation #containers #cli #gpt #agents #artificial-intelligence

Awesome-LLM-Kernel-Agent

(★ 18)

A repository with academic works about Kernel generation with LLM Agent

File Explorer

ZIP Download

- - render-landscape.yml
- cover.png
- - categories.yaml
  - changelog.yaml
  - entries.yaml
  - mermaid_config.yaml
  - readme_locale.yaml
  - sources.yaml
  - timeline.yaml
  - timeline_dates.yaml
- - contribution_guide.md
  - taxonomy.md
- - landscape_category_map.en.mmd
  - landscape_category_map.mmd
  - landscape_category_map.zh.mmd
  - landscape_full.pdf
  - landscape_full.png
  - landscape_full.svg
  - landscape_report.drawio
  - landscape_report.pdf
  - landscape_report.png
  - landscape_report.svg
  - landscape_report_editable.pptx
  - landscape_timeline_full.en.mmd
  - landscape_timeline_full.mmd
  - landscape_timeline_full.zh.mmd
  - landscape_timeline_report.en.mmd
  - landscape_timeline_report.mmd
  - landscape_timeline_report.zh.mmd
- - fetch_candidates.py
  - generate_readme_zh.py
  - mermaid_lib.py
  - render_drawio.py
  - render_landscape.py
  - render_mermaid.py
  - render_pptx.py
  - sync_readme.py
  - validate_entries.py
- .gitignore
- Makefile
- README.md
- requirements.txt
.gitignore
README.md
README.zh-CN.md

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

![Awesome LLM Kernel Agent Cover](https://raw.githubusercontent.com/qhy991/Awesome-LLM-Kernel-Agent/main/assets/cover.png)

### _A Curated Collection of LLM-Driven GPU Kernel Generation & Optimization Research_

[![Awesome](https://awesome.re/badge.svg)](https://awesome.re)
[![Last Updated](https://img.shields.io/badge/Last%20Updated-August%202026-blue.svg)](https://github.com/qhy991/Awsome-LLM-Kernel-Agent)
[![Papers](https://img.shields.io/badge/Papers-110+-green.svg)](https://raw.githubusercontent.com/qhy991/Awesome-LLM-Kernel-Agent/main/)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://raw.githubusercontent.com/qhy991/Awesome-LLM-Kernel-Agent/main/CONTRIBUTING.md)

[中文 README](README.zh-CN.md)

[📖 Introduction](#-introduction) • [📚 Papers](#-research-papers) • [🗺️ Landscape](#-landscape-map) • [🎯 Benchmarks](#-datasets-and-benchmarks) • [🧰 Tools](#-open-source-tools--frameworks) • [🛠️ Resources](#-traditional-kernel-optimization) • [🤝 Contributing](#-contributing)

</div>

---

## 📖 Introduction

Welcome to **Awesome LLM Kernel Agent** – a comprehensive collection of cutting-edge research on using Large Language Models (LLMs) for GPU kernel generation and optimization. This repository tracks the rapidly evolving field where AI meets high-performance computing.

### 🎯 What is LLM-Based Kernel Generation?

GPU kernel programming (CUDA, Triton, HIP, etc.) requires deep expertise in parallel computing, memory hierarchies, and hardware architectures. Recent advances in LLMs have opened new possibilities for **automating kernel development** through:

- 🤖 **Agentic Systems**: Multi-agent frameworks that iteratively design, optimize, and verify kernels
- 🎓 **Reinforcement Learning**: Training models to discover optimal kernel implementations
- 🔧 **Fine-tuning**: Specialized models trained on kernel code datasets
- 🔄 **Iterative Optimization**: Feedback-driven refinement using profiling and benchmarking

### 👥 Who Should Use This?

- **Researchers** exploring AI for systems and HPC
- **ML Engineers** optimizing deep learning workloads
- **GPU Developers** interested in automated kernel generation
- **Students** learning about the intersection of AI and computer architecture

### 📊 Repository Statistics

- **Total Papers**: 110+
- **Latest Addition**: August 2026
- **Coverage**: CUDA, Triton, HIP, Metal, NPU, TPU
- **Approaches**: Agent-based, RL, Fine-tuning, RAG, Prompt Engineering

---

## 🗺️ Landscape Map

GitHub **natively renders Mermaid** in README files. The landscape is maintained in [`llm_kernel_agent_landscape/`](llm_kernel_agent_landscape/): **edit YAML → generate Mermaid → sync to README**.

```bash
cd llm_kernel_agent_landscape && make all   # validate + render + sync README
```

### Curated Timeline

```mermaid
timeline
    title LLM Kernel Agent Field Timeline (Curated)
    2023-09 : Comparing Llama-2 and GPT-3 LLMs for HPC kernels generation
    2025-02 : KernelBench
             : TritonBench
             : Adaptive Self-improvement LLM Agentic System for ML Library Development
    2025-06 : CUDA-LLM
             : GPU Kernel Scientist
             : Kevin
    2025-07 : AutoTriton
             : CUDA-L1
             : GEAK
             : MultiKernelBench
    2025-09 : Sparse CUDA
             : Astra
             : Robust-KBench
    2025-11 : CudaForge
             : AccelOpt
             : KForge
    2025-12 : cuPilot
             : MinExec Kernel
             : CUDA-L2
    2026-01 : AscendKernelGen
             : AscendCraft
    2026-02 : Dr. Kernel
             : OptiML
    2026-03 : AutoKernel
             : KernelFoundry
             : DRTriton
             : CUDABench
             : Model2Kernel
    2026-04 : KEET
             : Kernel Contracts
             : Xe-Forge
    2026-05 : KernelBenchX
             : FastKernels
    2026-06 : SOLAR
             : daVinci-kernel
             : AutoMegaKernel
             : MusaCoder
    2026-08 : CAKE
             : Zomboss
             : Contract-Grade Verifier
```

<details>
<summary>Full timeline (all curated entries + pending items)</summary>

```mermaid
timeline
    title LLM Kernel Agent Full Timeline (All Curated Entries)
    2023-09 : Comparing Llama-2 and GPT-3 LLMs for HPC kernels generation
    2024-06 : Stack v2 HPC
             : FlagGems
             : ParEval
    2025-02 : AI CUDA Engineer
             : AI-CUDA Archive
             : KernelBench
             : TritonBench
             : EquiBench
             : Adaptive Self-improvement LLM Agentic System for ML Library Development
    2025-04 : ComputeEval
    2025-05 : KernelBook
    2025-06 : Kevin
             : KernelLLM
             : CUDA-LLM
             : GPU Kernel Scientist
             : FlashInfer
             : HeCBench
    2025-07 : AutoTriton
             : CUDA-L1
             : GEAK
             : MultiKernelBench
             : NPUEval
    2025-08 : CudaLLM
             : SwizzlePerf
    2025-09 : Sparse CUDA
             : Astra
             : Robust-KBench
             : KB-samples
    2025-10 : TritonRL
             : ConCuR
             : Transfer CUDA
             : STARK
             : EvoEngineer
    2025-11 : QiMeng-Kernel
             : CudaForge
             : AccelOpt
             : KernelBand
             : BackendBench
             : KForge
             : KernelEvolve
             : KernelFalcon
    2025-12 : CUDA-L2
             : TritonForge
             : GPUFLOPBench
             : cuPilot
             : MinExec Kernel
    2026-01 : MaxCode
             : AscendKernelGen
             : Liger-Kernel
             : FlashInfer-Bench
             : AscendCraft
    2026-02 : CUDA Agent
             : Dr. Kernel
             : K-Search
             : RooflineBench
             : OptiML
    2026-03 : InCoder-32B
             : KernelSkill
             : StitchCUDA
             : CUCo
             : CUDABench
             : SOL-ExecBench
             : KernelCraft
             : AutoKernel
             : KernelMem
             : AKO4ALL
             : KernelFoundry
             : DRTriton
             : Model2Kernel
             : KernelOwl
    2026-04 : FACT
             : ARGUS
             : AdaExplore
             : Kernel Contracts
             : CuTeGen
    2026-05 : KEET
             : FastKernels
             : KernelBenchX
             : Xe-Forge
    2026-06 : MusaCoder
             : AutoMegaKernel
             : daVinci-kernel
             : SOLAR
             : KernelBench-Verified
    2026-07 : Harness Engineering
             : Atrex-Kernel-Agent
             : KernelGenBench
    2026-08 : AsmEvo
             : CAKE
             : Zomboss
             : PTXBench
             : Contract-Grade Verifier
```

</details>

<details>
<summary>Category map (5-column flowchart)</summary>

```mermaid
flowchart TB
 subgraph llm4kernel["Model / Post-training"]
 direction TB
 autotrion["AutoTriton SFT + RL / Triton"]
 qimen_kernel["QiMeng-Kernel Hierarchical kernel model"]
 cuda_l1["CUDA-L1 Contrastive RL"]
 cuda_l2["CUDA-L2 RL for HGEMM"]
 concur["ConCuR Concise fine-tuning"]
 cudallm["CudaLLM CUDA fine-tuning"]
 kevin["Kevin Multi-turn RL"]
 sparse_cuda["Sparse CUDA Sparse + RL"]
 transfer_cuda["Transfer CUDA RAG transfer"]
 tritonforge["TritonForge SFT + RL"]
 tritonrl["TritonRL RL for Triton"]
 ascendcraft["AscendCraft DSL-guided transcompilation"]
 ascend_kernelgen["AscendKernelGen NPU adaptation"]
 asmevo["AsmEvo Verified assembly-level optimization"]
 cake["CAKE Compiler-agent co-design"]
 cuda_agent["CUDA Agent Large-scale agentic RL"]
 cutegen["CuTeGen CuTe generate-test-refine"]
 drtriton["DRTriton Synthetic-data RL"]
 dr_kernel["Dr. Kernel Triton RL"]
 incoder32b["InCoder-32B Industrial code LLM"]
 kernelllm["KernelLLM Kernel-specialized LLM"]
 maxcode["MaxCode Max-reward RL"]
 musacoder["MusaCoder Full-stack CUDA/MUSA RL"]
 zomboss["Zomboss Compiler-mediated verified DSE"]
 end
 subgraph agent4kernel["Agentic Workflow"]
 direction TB
 cuda_llm["CUDA-LLM Prompt + execution feedback"]
 ai_cuda_engineer["AI CUDA Engineer Iterative discovery"]
 accelopt["AccelOpt Self-improving agent"]
 astra["Astra Multi-agent workflow"]
 cudaforge["CudaForge Hardware feedback"]
 evoengineer["EvoEngineer Code evolution"]
 geak["GEAK Triton agent + bench"]
 gpu_kernel_scientist["GPU Kernel Scientist Iterative optimization"]
 kernelband["KernelBand Hardware-aware MAB"]
 minimal_exec_kernel["MinExec Kernel Hotspot extraction"]
 robust_kbench["Robust-KBench Agentic verification"]
 stark["STARK Multi-agent team"]
 swizzleperf["SwizzlePerf Hardware-aware LLM"]
 cupilot["cuPilot Strategy-coordinated evolution"]
 argus["ARGUS Data-flow invariants"]
 adaexplore["AdaExplore Failure-driven search"]
 atrex_kernel_agent["Atrex-Kernel-Agent Production trace-driven optimization"]
 autokernel["AutoKernel Iterative agent-driven search"]
 automegakernel["AutoMegaKernel Megakernel agent harness"]
 cuco["CUCo Compute-comm co-design"]
 fact["FACT 3-stage agentic"]
 harness_engineering["Harness Engineering Evidence-backed harness and controller"]
 k_search["K-Search Co-evolving world model"]
 keet["KEET Profiling explanation"]
 kernel_contracts["Kernel Contracts Correctness specification"]
 kernelfoundry["KernelFoundry Hardware-aware evolution"]
 kernelskill["KernelSkill Multi-agent + memory"]
 model2kernel["Model2Kernel Symbolic execution safety"]
 optiml["OptiML Two-stage synthesis"]
 solar["SOLAR SOL performance analysis"]
 stitchcuda["StitchCUDA Multi-agent + RL"]
 xe_forge["Xe-Forge Intel GPU multi-stage"]
 davinci_kernel["daVinci-kernel Co-evolving skill library"]
 end
 subgraph datasets["Data Assets"]
 direction TB
 flaggems["FlagGems Triton kernel library"]
 stack_v2_hpc["Stack v2 HPC Code corpus"]
 ai_cuda_archive["AI-CUDA Archive Engineer trajectories"]
 flashinfer["FlashInfer Inference kernels"]
 kb_samples["KB-samples Benchmark samples"]
 kernelbook["KernelBook PyTorch→Triton pairs"]
 liger_kernel["Liger-Kernel Kernel library"]
 end
 subgraph benchmarks["Evaluation"]
 direction TB
 pareval["ParEval Parallel code eval"]
 backendbench["BackendBench Backend generalization"]
 computeeval["ComputeEval CUDA LLM eval"]
 equibench["EquiBench Equivalence checking"]
 gpuflopbench["GPUFLOPBench FLOP reasoning"]
 hecbench["HeCBench Heterogeneous suite"]
 kernelbench["KernelBench Correctness + speedup"]
 multikernelbench["MultiKernelBench Multi-backend"]
 npueval["NPUEval NPU kernel eval"]
 tritonbench["TritonBench Triton operators"]
 cudabench["CUDABench Text-to-CUDA"]
 contract_grade_verifier["Contract-Grade Verifier Adversarial correctness verification"]
 fastkernels["FastKernels Production inference alignment"]
 flashinfer_bench["FlashInfer-Bench Inference virtuous cycle"]
 kernelbench_verified["KernelBench-Verified Robust KernelBench evaluation"]
 kernelbenchx["KernelBenchX Failure analysis"]
 kernelcraft["KernelCraft Emerging hardware"]
 kernelgenbench["KernelGenBench Multi-source and multi-chip evaluation"]
 ptxbench["PTXBench Architecture-specific PTX evaluation and adaptation"]
 rooflinebench["RooflineBench Roofline analysis"]
 sol_execbench["SOL-ExecBench Speed-of-light"]
 end
 subgraph systems___platforms["Integrated Systems"]
 direction TB
 kforge["KForge Cross-platform synthesis"]
 kernelevolve["KernelEvolve Evolutionary system"]
 kernelfalcon["KernelFalcon Deep agents"]
 ako4all["AKO4ALL Agentic optimization"]
 kernelmem["KernelMem Memory + multi-agent"]
 kernelowl["KernelOwl Self-evolving platform"]
 end
```

</details>

### Maintenance Quick Reference

| Goal | Edit file |
|:-----|:---------|
| Add paper / system | `data/entries.yaml` |
| Adjust curated timeline | `data/timeline.yaml` |
| Adjust full-timeline dates | `data/timeline_dates.yaml` (`overrides` / `external`) |
| Change README markers / titles | `data/mermaid_config.yaml` |

<details>
<summary>Optional: YAML → SVG category map (slides / PPT)</summary>

```bash
cd llm_kernel_agent_landscape && make svg pptx drawio
```

</details>

---

## 📚 Research Papers

### 🤖 LLM-Based Kernel Generation Methods

> This section covers methods that use LLMs to automatically generate and optimize GPU kernels across various platforms.

<details open>
<summary>📋 View All Methods (70 papers)</summary>

</details>

---

### 🧠 Agent Methodology & Techniques

> General agentic and reasoning techniques applicable to kernel generation and systems optimization.

---

### 📊 Datasets and Benchmarks

> Evaluation benchmarks and datasets for assessing LLM-generated kernel quality and performance.

---

### 🛠️ Traditional Kernel Optimization

> Manual kernel optimization techniques, DSLs, and educational resources for understanding GPU programming fundamentals.

| Title                                                                                                                                                                                                |  Date   |                                  Topics & Resources                                   |
| :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-----: | :-----------------------------------------------------------------------------------: |
| [**Evaluating CUDA Tile for AI Workloads on Hopper and Blackwell GPUs**](https://arxiv.org/abs/2604.23466)                                                                                          | 2026-04 | `First Author: Divakar Kumar Yadav` `Corresponding Author: Deepak Kumar` `University of Wisconsin-Milwaukee` `Illinois Institute of Technology` |
| [**Execution-Centric Characterization of FP8 Matrix Cores, Asynchronous Execution, and Structured Sparsity on AMD MI300A**](https://arxiv.org/abs/2602.10262)                                      | 2026-02 |                    `AMD-GPU` `MI300A` `FP8` `Asynchronous-Execution` `Structured-Sparsity`                    |
| [**Fast and Fusiest: An Optimal Fusion-Aware Mapper for Accelerator Modeling and Evaluation**](https://arxiv.org/abs/2602.15166)                                                                  | 2026-02 |                    `Accelerator-Modeling` `Fusion` `Mapper` `Optimization`                    |
| [**CuTe — NVIDIA CUTLASS Documentation**](https://docs.nvidia.com/cutlass/latest/media/docs/cpp/cute/index.html)                                                                                     | 2025-12 |                          `CUDA` `Layout` `Tensor` `Library`                           |
| [**NineToothed: A DSL based on Triton**](https://github.com/InfiniTensor/ninetoothed)                                                                                                                |  2025   |        `Triton` `DSL` • [GitHub](https://github.com/InfiniTensor/ninetoothed)         |
| [**Helion: A Python-embedded DSL for ML Kernels**](https://github.com/pytorch/helion)                                                                                                                |  2025   |             `PyTorch` `DSL` • [GitHub](https://github.com/pytorch/helion)             |
| [**HipKittens: Fast and Furious AMD Kernels**](https://arxiv.org/abs/2511.08083)                                                                                                                     | 2025-11 |        `AMD-GPU` `HIP` • [GitHub](https://github.com/HazyResearch/HipKittens)         |
| [**FlashMoBA: Optimizing Mixture of Block Attention**](https://arxiv.org/abs/2511.11571)                                                                                                             | 2025-11 |   `CUDA` `Attention` `Sparse` • [GitHub](https://github.com/mit-han-lab/flash-moba)   |
| [**TileLang: A Compiler for Tile-Based Accelerators**](https://arxiv.org/abs/2504.17577)                                                                                                             | 2025-04 |           `DSL` `Compiler` • [GitHub](https://github.com/tile-ai/tilelang)            |
| [**Can Tensor Cores Benefit Memory-Bound Kernels? (No!)**](https://arxiv.org/abs/2502.16851)                                                                                                         | 2025-02 |                        `Tensor-Core` `Memory-Bound` `Analysis`                        |
| [**ThunderKittens: A DSL for High-Performance Tensor Computations**](https://arxiv.org/abs/2410.20399)                                                                                               | 2024-10 | `CUDA` `Tensor-Core` `DSL` • [GitHub](https://github.com/HazyResearch/ThunderKittens) |
| [**How To Write A Fast Matrix Multiplication From Scratch With Tensor Cores**](https://alexarmbr.github.io/2024/08/10/How-To-Write-A-Fast-Matrix-Multiplication-From-Scratch-With-Tensor-Cores.html) | 2024-08 |                            `Tutorial` `Tensor-Core` `GEMM`                            |
| [**Tensor Kernels (TK)**](https://hazyresearch.stanford.edu/blog/2024-05-12-tk)                                                                                                                      | 2024-05 |                          `Blog` `Tensor-Core` `Optimization`                          |
| [**CUDA Matrix Multiplication**](https://siboehm.com/articles/22/CUDA-MMM)                                                                                                                           | 2022-06 |                               `Tutorial` `CUDA` `GEMM`                                |

---

## 🌟 Community & Resources

### 🧰 Open-Source Tools & Frameworks

> Agentic kernel optimization systems and hands-on CUDA engineering resources.

| Title                                                                                                                                 |  Date   | Code | Topics |
| :------------------------------------------------------------------------------------------------------------------------------------ | :-----: | :--: | :----: |
| ![Star](https://img.shields.io/github/stars/TongmingLAIC/AKO4ALL.svg?style=social&label=Star) [**AKO4ALL: Agentic Kernel Optimization for All**](https://github.com/TongmingLAIC/AKO4ALL) | 2026-03 | [GitHub](https://github.com/TongmingLAIC/AKO4ALL) | `Agent` `CUDA` `Triton` `NCU` `Iterative-Optimization` `KernelBench` |
| ![Star](https://img.shields.io/github/stars/0satan0/KernelMem.svg?style=social&label=Star) [**KernelMem: Automatic CUDA Kernel Generation and Optimization with Memory**](https://github.com/0satan0/KernelMem) |    -    | [GitHub](https://github.com/0satan0/KernelMem) | `CUDA` `Multi-Agent` `Memory` `NCU` `NSYS` `KernelBench` |
| [**vitamin-cuda: Hands-on CUDA Learning Path with PyTorch Extensions**](https://github.com/WingEdge777/vitamin-cuda)                  |    -    | [GitHub](https://github.com/WingEdge777/vitamin-cuda) | `CUDA` `Tutorial` `PyTorch` `Learning` |

---

### 📰 Industry Blogs & News

| Title                                                                                                                                                                                               |  Date   |                  Topics                   |
| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-----: | :---------------------------------------: |
| [**Benchmarking LLMs on AI-Generated CUDA Code with ComputeEval 2025.2**](https://developer.nvidia.com/blog/benchmarking-llms-on-ai-generated-cuda-code-with-computeeval-2025-2/)                   | 2025-11 | `NVIDIA` `ComputeEval` `CUDA` `Benchmark` |
| [**Announcing ComputeEval, an Open Source Framework for Evaluating LLMs on CUDA**](https://developer.nvidia.com/blog/announcing-computeeval-an-open-source-framework-for-evaluating-llms-on-cuda/)  | 2025-04 | `NVIDIA` `ComputeEval` `CUDA` `Framework` |
| [**Automating GPU Kernel Generation with DeepSeek-R1 and Inference Time Scaling**](https://developer.nvidia.com/blog/automating-gpu-kernel-generation-with-deepseek-r1-and-inference-time-scaling/) |  2025   |       `NVIDIA` `DeepSeek-R1` `CUDA`       |

### 🏆 Competitions & Challenges

---

## 🤝 Contributing

We welcome contributions! If you know of a paper, tool, or resource that should be included, please:

1. **Fork** this repository
2. **Add** your entry following the existing format
3. **Submit** a pull request with a brief description

### Contribution Guidelines

- Ensure the paper/resource is relevant to LLM-based kernel generation or GPU optimization
- Include proper citation with title, venue, date, and links
- Add appropriate topic tags
- Maintain chronological order (newest first)
- Check for duplicates before submitting

---

## 📄 Citation

If you find this repository useful for your research, please consider citing:

```bibtex
@misc{awesome-llm-kernel-agent,
  author = {Haiyan Qin},
  title = {Awesome LLM Kernel Agent: A Curated Collection of LLM-Driven GPU Kernel Generation Research},
  year = {2025},
  publisher = {GitHub},
  url = {https://github.com/qhy991/Awsome-LLM-Kernel-Agent}
}
```

---

## 📜 License

[![CC0](https://licensebuttons.net/p/zero/1.0/88x31.png)](https://creativecommons.org/publicdomain/zero/1.0/)

This work is licensed under a [Creative Commons Zero v1.0 Universal](LICENSE) license.

---

**⭐ If you find this repository helpful, please consider giving it a star! ⭐**

Maintained with ❤️ by the community

_Last Updated: August 2026_

</div>

Awesome-LLM-Kernel-Agent

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Awesome-LLM-Kernel-Agent

Owner Repos

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README