[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-RightNow-AI--autokernel":3,"tool-RightNow-AI--autokernel":61},[4,18,26,36,44,53],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",145895,2,"2026-04-08T11:32:59",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":32,"last_commit_at":42,"category_tags":43,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",108111,"2026-04-08T11:23:26",[14,15,13],{"id":45,"name":46,"github_repo":47,"description_zh":48,"stars":49,"difficulty_score":32,"last_commit_at":50,"category_tags":51,"status":17},4721,"markitdown","microsoft\u002Fmarkitdown","MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。\n\n在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。\n\n这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器",93400,"2026-04-06T19:52:38",[52,14],"插件",{"id":54,"name":55,"github_repo":56,"description_zh":57,"stars":58,"difficulty_score":10,"last_commit_at":59,"category_tags":60,"status":17},4487,"LLMs-from-scratch","rasbt\u002FLLMs-from-scratch","LLMs-from-scratch 是一个基于 PyTorch 的开源教育项目，旨在引导用户从零开始一步步构建一个类似 ChatGPT 的大型语言模型（LLM）。它不仅是同名技术著作的官方代码库，更提供了一套完整的实践方案，涵盖模型开发、预训练及微调的全过程。\n\n该项目主要解决了大模型领域“黑盒化”的学习痛点。许多开发者虽能调用现成模型，却难以深入理解其内部架构与训练机制。通过亲手编写每一行核心代码，用户能够透彻掌握 Transformer 架构、注意力机制等关键原理，从而真正理解大模型是如何“思考”的。此外，项目还包含了加载大型预训练权重进行微调的代码，帮助用户将理论知识延伸至实际应用。\n\nLLMs-from-scratch 特别适合希望深入底层原理的 AI 开发者、研究人员以及计算机专业的学生。对于不满足于仅使用 API，而是渴望探究模型构建细节的技术人员而言，这是极佳的学习资源。其独特的技术亮点在于“循序渐进”的教学设计：将复杂的系统工程拆解为清晰的步骤，配合详细的图表与示例，让构建一个虽小但功能完备的大模型变得触手可及。无论你是想夯实理论基础，还是为未来研发更大规模的模型做准备",90106,"2026-04-06T11:19:32",[35,15,13,14],{"id":62,"github_repo":63,"name":64,"description_en":65,"description_zh":66,"ai_summary_zh":67,"readme_en":68,"readme_zh":69,"quickstart_zh":70,"use_case_zh":71,"hero_image_url":72,"owner_login":73,"owner_name":74,"owner_avatar_url":75,"owner_bio":76,"owner_company":77,"owner_location":77,"owner_email":78,"owner_twitter":79,"owner_website":80,"owner_url":81,"languages":82,"stars":87,"forks":88,"last_commit_at":89,"license":90,"difficulty_score":91,"env_os":92,"env_gpu":93,"env_ram":94,"env_deps":95,"category_tags":103,"github_topics":105,"view_count":32,"oss_zip_url":77,"oss_zip_packed_at":77,"status":17,"created_at":111,"updated_at":112,"faqs":113,"releases":114},5511,"RightNow-AI\u002Fautokernel","autokernel","Autoresearch for GPU kernels. Give it any PyTorch model, go to sleep, wake up to optimized Triton kernels.","AutoKernel 是一款专为 GPU 内核优化设计的自动化研究工具。它能接收任意 PyTorch 模型，自动识别计算瓶颈，并生成经过高度优化的 Triton 或 CUDA C++ 内核代码，让用户在休息醒来后即可获得性能显著提升的模型。\n\n该工具主要解决了深度学习开发中手动编写和优化底层 GPU 内核门槛高、耗时长的痛点。传统方式需要专家耗费大量时间进行微调和基准测试，而 AutoKernel 通过自主智能体模拟“研究团队”的工作流：先对模型进行性能剖析定位瓶颈，再提取关键算子，随后由智能体循环执行“修改代码 - 运行基准测试 - 验证正确性 - 保留或回滚”的过程，直至找到最优解。整个过程基于阿姆达尔定律智能调度优化顺序，确保整体加速效果最大化。\n\nAutoKernel 特别适合 AI 基础设施工程师、高性能计算研究人员以及希望深入优化模型推理速度的开发者使用。其独特亮点在于内置了严谨的五阶段正确性验证机制（涵盖数值稳定性、确定性等），并配有详尽的优化策略文档，使智能体能连续运行十小时以上而不迷失方向。只需简单的命令行操作，即可将原本复杂的内核调优工作转化为全自动化的流程，大幅提","AutoKernel 是一款专为 GPU 内核优化设计的自动化研究工具。它能接收任意 PyTorch 模型，自动识别计算瓶颈，并生成经过高度优化的 Triton 或 CUDA C++ 内核代码，让用户在休息醒来后即可获得性能显著提升的模型。\n\n该工具主要解决了深度学习开发中手动编写和优化底层 GPU 内核门槛高、耗时长的痛点。传统方式需要专家耗费大量时间进行微调和基准测试，而 AutoKernel 通过自主智能体模拟“研究团队”的工作流：先对模型进行性能剖析定位瓶颈，再提取关键算子，随后由智能体循环执行“修改代码 - 运行基准测试 - 验证正确性 - 保留或回滚”的过程，直至找到最优解。整个过程基于阿姆达尔定律智能调度优化顺序，确保整体加速效果最大化。\n\nAutoKernel 特别适合 AI 基础设施工程师、高性能计算研究人员以及希望深入优化模型推理速度的开发者使用。其独特亮点在于内置了严谨的五阶段正确性验证机制（涵盖数值稳定性、确定性等），并配有详尽的优化策略文档，使智能体能连续运行十小时以上而不迷失方向。只需简单的命令行操作，即可将原本复杂的内核调优工作转化为全自动化的流程，大幅提升研发效率。","# AutoKernel\n\n[![Discord](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FDiscord-Join%20us-5865F2?logo=discord&logoColor=white)](https:\u002F\u002Fdiscord.gg\u002FUfEyc72t)\n\n**Autoresearch for GPU kernels.** Give it any PyTorch model, go to sleep, wake up to optimized Triton or CUDA C++ kernels.\n\n![AutoKernel Progress](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FRightNow-AI_autokernel_readme_18212f72a48c.png)\n\nInspired by [@karpathy\u002Fautoresearch](https:\u002F\u002Fgithub.com\u002Fkarpathy\u002Fautoresearch) -- which demonstrated autonomous AI agents for LLM training research. AutoKernel applies the same philosophy to GPU kernel optimization: agent modifies one file, runs a fixed evaluation, keeps or reverts, repeats forever.\n\n## How It Works\n\nGive AutoKernel any PyTorch model. It will:\n\n1. **Profile** the model to find which GPU kernels are bottlenecks\n2. **Extract** each bottleneck as a standalone Triton or CUDA C++ kernel\n3. **Optimize** each kernel autonomously (edit, benchmark, keep\u002Frevert -- forever)\n4. **Verify** end-to-end correctness and report the total speedup\n\nThe agent reads `program.md` -- the \"research org code\" -- which contains comprehensive instructions for autonomous operation. It edits `kernel.py` one kernel at a time, runs `bench.py` (fixed benchmark with 5-stage correctness checks + roofline analysis), and either keeps or reverts the change. The orchestrator decides when to move to the next kernel using Amdahl's law.\n\nEach experiment takes ~90 seconds. That's ~40 experiments\u002Fhour, ~320 overnight, across all kernels.\n\n## Quick Start\n\n**Requirements:** NVIDIA GPU (tested on H100\u002FA100\u002FRTX 4090), Python 3.10+, [uv](https:\u002F\u002Fdocs.astral.sh\u002Fuv\u002F).\n\n```bash\n# Install uv (if you don't have it)\ncurl -LsSf https:\u002F\u002Fastral.sh\u002Fuv\u002Finstall.sh | sh\n\n# Clone and setup\ngit clone https:\u002F\u002Fgithub.com\u002FRightNow-AI\u002Fautokernel.git\ncd autokernel\nuv sync\n\n# One-time setup: test data + baselines\nuv run prepare.py\n\n# Profile a model (ships with GPT-2, LLaMA, BERT -- no transformers needed)\nuv run profile.py --model models\u002Fllama_7b.py --class-name LlamaModel \\\n --input-shape 1,512 --dtype float16\n\n# Extract top bottleneck kernels\nuv run extract.py --top 5\n\n# Verify benchmark works\nuv run bench.py\n```\n\n## Running the Agent\n\nSpin up Claude, Codex, or any coding agent in this directory:\n\n```\nRead program.md and let's kick off a new experiment. Start with setup.\n```\n\nThe agent will:\n1. Profile your model and present the optimization plan\n2. Create a branch (e.g., `autokernel\u002Fmar10-llama7b`)\n3. Optimize each bottleneck kernel in priority order\n4. Verify end-to-end correctness and report total speedup\n\n`program.md` is intentionally comprehensive so the agent can run 10+ hours without getting stuck. It includes a 6-tier optimization playbook, decision framework, crash handling, and Amdahl's law reasoning.\n\n## The Pipeline\n\n```\n                 profile.py              extract.py           bench.py (loop)         verify.py\nAny PyTorch  ──>  Rank kernels  ──>  Generate baseline  ──>  Optimize each  ──>  End-to-end\n   model          by GPU time       Triton\u002FCUDA kernels     kernel (agent)       verification\n```\n\n| Tool | What it does |\n|------|-------------|\n| `profile.py` | Profiles any PyTorch model with `torch.profiler`, ranks kernels by GPU time, classifies as compute\u002Fmemory-bound |\n| `extract.py` | Extracts top-N bottleneck kernels into standalone Triton or CUDA C++ kernel files (`--backend triton\\|cuda`) |\n| `orchestrate.py` | Multi-kernel scheduler: decides which kernel to optimize next using Amdahl's law, tracks aggregate progress |\n| `bench.py` | Fixed benchmark: 5-stage correctness (smoke, shape sweep, numerical stability, determinism, edge cases) + performance + roofline |\n| `verify.py` | Plugs optimized kernels back into the model, checks end-to-end correctness, reports total speedup |\n\n## Supported Kernels\n\n9 kernel types covering the core operations of modern deep learning:\n\n| Kernel | Description | Key Metric |\n|--------|-------------|------------|\n| **matmul** | Dense matrix multiplication (M x K) @ (K x N) | TFLOPS |\n| **softmax** | Row-parallel numerically stable softmax | GB\u002Fs |\n| **layernorm** | Layer normalization with affine transform | GB\u002Fs |\n| **rmsnorm** | RMS normalization (LLaMA-style) | GB\u002Fs |\n| **flash_attention** | Scaled dot-product attention with causal masking | TFLOPS |\n| **fused_mlp** | SwiGLU-style fused MLP (gate + up + down) | TFLOPS |\n| **cross_entropy** | Fused cross entropy loss | GB\u002Fs |\n| **rotary_embedding** | Rotary position embeddings (RoPE) | GB\u002Fs |\n| **reduce** | Parallel reduction (sum) | GB\u002Fs |\n\nEach has a PyTorch reference in `reference.py`, a starter Triton kernel in `kernels\u002F`, and a starter CUDA C++ kernel in `kernels\u002Fcuda\u002F`.\n\n## Example Models\n\nSelf-contained model definitions ship with AutoKernel (no `transformers` library needed):\n\n| Model | File | Params | Usage |\n|-------|------|--------|-------|\n| GPT-2 Small | `models\u002Fgpt2.py` | 124M | `--class-name GPT2 --input-shape 1,1024` |\n| LLaMA (compact) | `models\u002Fllama_7b.py` | 160M | `--class-name LlamaModel --input-shape 1,512` |\n| LLaMA 7B | `models\u002Fllama_7b.py` | 7B | `--class-name LlamaModel7B --input-shape 1,2048` |\n| BERT-base | `models\u002Fbert_base.py` | 110M | `--class-name BertModel --input-shape 8,512` |\n| Custom | `models\u002Fcustom.py` | -- | Template for your own model |\n\nFor HuggingFace models (`uv sync --extra models`):\n\n```bash\nuv run profile.py --module transformers --class-name AutoModelForCausalLM \\\n --pretrained meta-llama\u002FLlama-2-7b-hf --input-shape 1,2048 --dtype float16\n```\n\n## KernelBench Integration\n\nAutoKernel integrates with [KernelBench](https:\u002F\u002Fgithub.com\u002FScalingIntelligence\u002FKernelBench),\nthe standard benchmark for evaluating AI-generated GPU kernels (250+ problems across 4 difficulty\nlevels). While most KernelBench evaluations use one-shot LLM generation, AutoKernel runs\n**50-300+ iterative refinement experiments per problem** -- systematically exploring the\noptimization space instead of guessing.\n\n```bash\n# Install KernelBench dependencies\nuv sync --extra kernelbench\n\n# Fetch Level 1 problems from HuggingFace\nuv run kernelbench\u002Fbridge.py fetch --source hf --level 1\n\n# Set up a specific problem for optimization\nuv run kernelbench\u002Fbridge.py setup --level 1 --problem 1 --source hf\n\n# Evaluate (correctness + speedup vs PyTorch reference)\nuv run kernelbench\u002Fbench_kb.py\n\n# Batch score an entire level (computes fast_p metric)\nuv run kernelbench\u002Fscorer.py --level 1\n```\n\nThe agent reads `kernelbench\u002Fprogram_kb.md` for KernelBench-specific optimization instructions:\nhow to write `ModelNew` classes, when to use CUDA C++ vs Triton, fusion strategies per problem\nlevel, and the edit-bench-keep\u002Frevert loop adapted for the KernelBench `fast_p` metric.\n\n| Tool | What it does |\n|------|-------------|\n| `kernelbench\u002Fbridge.py` | Loads problems from HuggingFace or local repo, caches them, generates starter `kernel.py` |\n| `kernelbench\u002Fbench_kb.py` | Evaluates `ModelNew` vs `Model`: 5-trial correctness + CUDA event timing + stability + determinism |\n| `kernelbench\u002Fscorer.py` | Batch evaluation across a level, computes `fast_p` at thresholds (1.0x, 1.5x, 2.0x, 3.0x, 5.0x) |\n| `kernelbench\u002Fprogram_kb.md` | Agent instructions for KernelBench mode |\n\n## HuggingFace Kernels Export\n\nExport optimized kernels to the [HuggingFace Hub](https:\u002F\u002Fhuggingface.co\u002Fdocs\u002Fkernels\u002Fen\u002Findex)\nfor easy distribution. Users can then load your kernels with a single line:\n\n```python\nfrom kernels import get_kernel\nmodule = get_kernel(\"your-username\u002Fkernel-name\")\n```\n\n```bash\n# Export an optimized CUDA kernel\nuv run export_hf.py --name my_matmul\n\n# Upload to Hub (requires `pip install kernels` and `huggingface-cli login`)\ncd workspace\u002Fhf_export\u002Fmy_matmul\nkernels upload . --repo_id your-username\u002Fmy_matmul\n```\n\n## Project Structure\n\n```\nautokernel\u002F\n  kernel.py             the file the agent modifies (one kernel at a time)\n  program.md            agent instructions -- the \"research org code\"\n\n  bench.py              fixed benchmark + 5-stage correctness harness\n  reference.py          PyTorch reference implementations (ground truth)\n  prepare.py            one-time setup: test data, baselines\n\n  profile.py            profile any PyTorch model, rank kernels by GPU time\n  extract.py            extract bottleneck kernels into workspace\u002F\n  orchestrate.py        multi-kernel scheduler (Amdahl's law)\n  verify.py             end-to-end model verification + speedup report\n  export_hf.py          export optimized kernels to HuggingFace Kernels format\n  analysis.py           experiment visualization (generates https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FRightNow-AI_autokernel_readme_18212f72a48c.png)\n\n  kernels\u002F              starter Triton kernels (9 types)\n  kernels\u002Fcuda\u002F         starter CUDA C++ kernels (9 types, tensor core accelerated)\n  kernelbench\u002F          KernelBench integration (bridge, eval harness, scorer)\n  models\u002F               self-contained model definitions (GPT-2, LLaMA, BERT)\n  workspace\u002F            runtime artifacts (gitignored)\n```\n\n## Design Choices\n\n**Dual backend: Triton + CUDA C++.** Triton for fast iteration (Python-like syntax, compiles in seconds). CUDA C++ for maximum performance (direct access to tensor cores via `wmma`, PTX intrinsics, shared memory bank-conflict-free layouts). Triton regularly reaches 80-95% of cuBLAS; CUDA C++ can match or exceed it. Both backends share the same `kernel_fn()` interface -- `bench.py` runs identically on either.\n\n**Correctness first.** The benchmark checks kernel output against PyTorch before measuring performance. A fast but wrong kernel is immediately reverted. This prevents the agent from \"optimizing\" by producing garbage.\n\n**Amdahl's law orchestration.** The orchestrator prioritizes by impact. A 1.5x speedup on a 60% kernel (1.25x end-to-end) beats a 3x speedup on a 5% kernel (1.03x end-to-end). It moves on when diminishing returns set in.\n\n**Single file to modify.** The agent only touches `kernel.py`. Scope stays manageable, diffs reviewable, reverts clean.\n\n**TSV logging.** Results go to a plain `results.tsv` file. Human-readable, git-friendly, trivially parseable, no infrastructure.\n\n## Results Format\n\nEvery experiment is logged to `results.tsv` (tab-separated):\n\n| Column | Description |\n|--------|-------------|\n| `experiment` | Sequential experiment number (0 = baseline) |\n| `tag` | Short identifier |\n| `kernel_type` | Which kernel (e.g., `matmul`) |\n| `throughput_tflops` | Measured throughput (higher is better) |\n| `latency_us` | Execution time in microseconds |\n| `pct_peak` | Percentage of GPU theoretical peak |\n| `speedup_vs_pytorch` | Speedup vs PyTorch\u002FcuBLAS |\n| `correctness` | PASS, FAIL, TIMEOUT, or CRASH |\n| `peak_vram_mb` | Peak GPU memory usage |\n| `description` | What was tried |\n\n## Credits\n\nThis project is **autoresearch for GPU kernels** -- directly inspired by Andrej Karpathy's [autoresearch](https:\u002F\u002Fgithub.com\u002Fkarpathy\u002Fautoresearch), the original experiment in autonomous AI research agents for LLM training. Karpathy showed that an AI agent can run hundreds of experiments overnight, methodically exploring a search space and logging every result. AutoKernel applies that same loop -- agent edits one file, runs a fixed evaluation, keeps or reverts -- to the domain of GPU kernel optimization with Triton and native CUDA C++.\n\n**KernelBench** integration is based on the work of Simon Guo, Sean Resta, et al. at Stanford's Scaling Intelligence Lab. Their paper [\"KernelBench: Can LLMs Write GPU Kernels?\"](https:\u002F\u002Farxiv.org\u002Fabs\u002F2502.10517) (2025) established the standard benchmark for evaluating AI-generated GPU kernels. AutoKernel extends this by applying iterative optimization (300+ experiments per problem) instead of one-shot generation. KernelBench dataset and evaluation protocol: [ScalingIntelligence\u002FKernelBench](https:\u002F\u002Fgithub.com\u002FScalingIntelligence\u002FKernelBench).\n\nBuilt by [RightNow AI](https:\u002F\u002Fwww.rightnowai.co). For enterprise GPU optimization, check out [RightNow Enterprise](https:\u002F\u002Fwww.rightnowai.co\u002Fforge).\n\n## Changelog\n\n### v1.3.0\n- AMD ROCm GPU support: MI300X, MI325X, MI350X, MI355X detection and specs (thanks [@andyluo7](https:\u002F\u002Fgithub.com\u002Fandyluo7))\n- Fixed `verify.py` SyntaxError on Python 3.13+\n- Fixed CUDA flash_attention ignoring `sm_scale` parameter\n- Fixed CUDA cross_entropy returning wrong dtype\n- Fixed Triton rotary_embedding broadcasting truncation\n- Fixed Triton reduce output shape for non-last-dim reductions\n\n### v1.2.0\n- Enhanced profiler: `--export-trace`, `--memory-snapshot`, `--torch-compile-log` flags\n- HuggingFace Kernels export via `export_hf.py`\n\n### v1.1.0\n- Native CUDA C++ backend with 9 starter kernels (tensor cores, warp intrinsics, shared memory tiling)\n- KernelBench integration (250+ standardized GPU kernel problems)\n- `--backend triton|cuda` flag for `extract.py`\n\n### v1.0.0\n- Initial release: Triton kernel optimization pipeline with 5-stage correctness harness\n\nSee [CHANGELOG.md](CHANGELOG.md) for full details.\n\n## License\n\nMIT\n","# AutoKernel\n\n[![Discord](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FDiscord-Join%20us-5865F2?logo=discord&logoColor=white)](https:\u002F\u002Fdiscord.gg\u002FUfEyc72t)\n\n**针对 GPU 内核的自动研究工具。** 只需提供任意 PyTorch 模型，然后安心入睡，醒来时即可获得优化后的 Triton 或 CUDA C++ 内核。\n\n![AutoKernel 进度](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FRightNow-AI_autokernel_readme_18212f72a48c.png)\n\n灵感来源于 [@karpathy\u002Fautoresearch](https:\u002F\u002Fgithub.com\u002Fkarpathy\u002Fautoresearch) —— 该工具展示了用于大语言模型训练研究的自主 AI 代理。AutoKernel 将同样的理念应用于 GPU 内核优化：代理会修改单个文件，运行固定的评估流程，决定保留或回滚更改，并无限循环重复这一过程。\n\n## 工作原理\n\n向 AutoKernel 提供任意 PyTorch 模型，它将执行以下步骤：\n\n1. **性能剖析**：识别哪些 GPU 内核是性能瓶颈。\n2. **提取瓶颈内核**：将每个瓶颈内核单独提取为独立的 Triton 或 CUDA C++ 内核。\n3. **自主优化**：对每个内核进行持续优化（编辑、基准测试、保留或回滚——直至满意）。\n4. **端到端验证**：确保整体正确性，并报告总加速效果。\n\n代理会读取 `program.md` 文件——即“研究组织代码”——其中包含详细的自主操作指南。它会逐个内核编辑 `kernel.py` 文件，运行 `bench.py` 脚本（包含五阶段正确性检查和 Roofline 分析的固定基准测试），并根据结果决定是否保留或回滚更改。调度器会利用阿姆达尔定律来判断何时切换到下一个内核。\n\n每次实验大约耗时 90 秒，因此每小时可完成约 40 次实验，整夜下来则能完成约 320 次，覆盖所有内核。\n\n## 快速入门\n\n**要求**：NVIDIA GPU（已测试 H100\u002FA100\u002FRTX 4090）、Python 3.10+、[uv](https:\u002F\u002Fdocs.astral.sh\u002Fuv\u002F)。\n\n```bash\n# 安装 uv（如果尚未安装）\ncurl -LsSf https:\u002F\u002Fastral.sh\u002Fuv\u002Finstall.sh | sh\n\n# 克隆并设置环境\ngit clone https:\u002F\u002Fgithub.com\u002FRightNow-AI\u002Fautokernel.git\ncd autokernel\nuv sync\n\n# 一次性设置：测试数据与基线\nuv run prepare.py\n\n# 对模型进行性能剖析（内置 GPT-2、LLaMA、BERT 模型，无需 transformers 库）\nuv run profile.py --model models\u002Fllama_7b.py --class-name LlamaModel \\\n --input-shape 1,512 --dtype float16\n\n# 提取前 5 个瓶颈内核\nuv run extract.py --top 5\n\n# 验证基准测试是否正常运行\nuv run bench.py\n```\n\n## 启动代理\n\n在此目录下启动 Claude、Codex 或任何编码代理：\n\n```\n请阅读 program.md，我们开始新的实验吧。先从设置开始。\n```\n\n代理将执行以下操作：\n1. 对您的模型进行性能剖析，并给出优化计划。\n2. 创建一个分支（例如 `autokernel\u002Fmar10-llama7b`）。\n3. 按优先级顺序优化每个瓶颈内核。\n4. 验证端到端正确性，并报告总加速效果。\n\n`program.md` 文件内容详尽，旨在让代理能够连续运行 10 小时以上而不会卡住。它包含了六层优化策略、决策框架、异常处理机制以及基于阿姆达尔定律的推理逻辑。\n\n## 流程概述\n\n```\n                 profile.py              extract.py           bench.py (循环)         verify.py\n任意 PyTorch  ──>  按 GPU 时间排序内核  ──>  生成基线  ──>  优化每个  ──>  端到端\n   模型          内核        Triton\u002FCUDA 内核     内核（代理）       验证\n```\n\n| 工具 | 功能 |\n|------|-------------|\n| `profile.py` | 使用 `torch.profiler` 对任意 PyTorch 模型进行性能剖析，按 GPU 时间对内核排序，并分类为计算密集型或内存密集型。 |\n| `extract.py` | 将前 N 个瓶颈内核提取为独立的 Triton 或 CUDA C++ 内核文件（通过 `--backend triton\\|cuda` 指定后端）。 |\n| `orchestrate.py` | 多内核调度器：使用阿姆达尔定律决定下一个优化的内核，并跟踪整体进度。 |\n| `bench.py` | 固定基准测试：包括五阶段正确性检查（烟雾测试、形状扫描、数值稳定性、确定性、边界情况）以及性能和 Roofline 分析。 |\n| `verify.py` | 将优化后的内核重新集成到模型中，检查端到端正确性，并报告总加速效果。 |\n\n## 支持的内核类型\n\n涵盖现代深度学习核心操作的 9 种内核类型：\n\n| 内核 | 描述 | 关键指标 |\n|--------|-------------|------------|\n| **matmul** | 密集矩阵乘法 (M x K) @ (K x N) | TFLOPS |\n| **softmax** | 行并行数值稳定的 softmax | GB\u002Fs |\n| **layernorm** | 带仿射变换的层归一化 | GB\u002Fs |\n| **rmsnorm** | RMS 归一化（LLaMA 风格） | GB\u002Fs |\n| **flash_attention** | 缩放点积注意力，带因果掩码 | TFLOPS |\n| **fused_mlp** | SwiGLU 风格的融合 MLP（门控 + 上升 + 下降） | TFLOPS |\n| **cross_entropy** | 融合交叉熵损失 | GB\u002Fs |\n| **rotary_embedding** | 旋转位置嵌入（RoPE） | GB\u002Fs |\n| **reduce** | 并行规约（求和） | GB\u002Fs |\n\n每种内核在 `reference.py` 中都有 PyTorch 参考实现，在 `kernels\u002F` 目录中有 Triton 初始内核，在 `kernels\u002Fcuda\u002F` 目录中有 CUDA C++ 初始内核。\n\n## 示例模型\n\nAutoKernel 自带了自包含的模型定义（无需 `transformers` 库）：\n\n| 模型 | 文件 | 参数量 | 使用方法 |\n|-------|------|--------|-------|\n| GPT-2 Small | `models\u002Fgpt2.py` | 1.24 亿 | `--class-name GPT2 --input-shape 1,1024` |\n| LLaMA（精简版） | `models\u002Fllama_7b.py` | 1.6 亿 | `--class-name LlamaModel --input-shape 1,512` |\n| LLaMA 7B | `models\u002Fllama_7b.py` | 70 亿 | `--class-name LlamaModel7B --input-shape 1,2048` |\n| BERT-base | `models\u002Fbert_base.py` | 1.1 亿 | `--class-name BertModel --input-shape 8,512` |\n| 自定义 | `models\u002Fcustom.py` | -- | 您可以在此基础上构建自己的模型模板。 |\n\n对于 HuggingFace 模型（需运行 `uv sync --extra models`）：\n\n```bash\nuv run profile.py --module transformers --class-name AutoModelForCausalLM \\\n --pretrained meta-llama\u002FLlama-2-7b-hf --input-shape 1,2048 --dtype float16\n```\n\n## KernelBench 集成\n\nAutoKernel 与 [KernelBench](https:\u002F\u002Fgithub.com\u002FScalingIntelligence\u002FKernelBench) 集成，后者是评估 AI 生成 GPU 内核的标准基准测试平台（涵盖 4 个难度级别的 250 多个问题）。虽然大多数 KernelBench 评估采用一次性的 LLM 生成方式，但 AutoKernel 每个问题会进行 **50–300+ 次迭代优化实验**——系统性地探索优化空间，而非随机猜测。\n\n```bash\n# 安装 KernelBench 的依赖\nuv sync --extra kernelbench\n\n# 从 HuggingFace 获取 Level 1 问题\nuv run kernelbench\u002Fbridge.py fetch --source hf --level 1\n\n# 设置特定问题以进行优化\nuv run kernelbench\u002Fbridge.py setup --level 1 --problem 1 --source hf\n\n# 评估（正确性及相对于 PyTorch 参考的加速效果）\nuv run kernelbench\u002Fbench_kb.py\n\n# 批量评分整个级别（计算 fast_p 指标）\nuv run kernelbench\u002Fscorer.py --level 1\n```\n\n代理会读取 `kernelbench\u002Fprogram_kb.md` 文件，以获取 KernelBench 特定的优化指导：\n如何编写 `ModelNew` 类、何时使用 CUDA C++ 或 Triton、针对不同问题级别的融合策略，\n以及为 KernelBench 的 `fast_p` 指标量身定制的编辑-保留\u002F回滚循环。\n\n| 工具 | 功能 |\n|------|-------------|\n| `kernelbench\u002Fbridge.py` | 从 HuggingFace 或本地仓库加载问题，缓存并生成初始 `kernel.py` 文件 |\n| `kernelbench\u002Fbench_kb.py` | 对比评估 `ModelNew` 和 `Model`：进行 5 次正确性测试 + CUDA 事件计时 + 稳定性 + 确定性 |\n| `kernelbench\u002Fscorer.py` | 在一个级别内批量评估，并在不同阈值下（1.0x、1.5x、2.0x、3.0x、5.0x）计算 `fast_p` |\n| `kernelbench\u002Fprogram_kb.md` | 针对 KernelBench 模式的代理操作指南 |\n\n## HuggingFace 内核导出\n\n将优化后的内核导出到 [HuggingFace Hub](https:\u002F\u002Fhuggingface.co\u002Fdocs\u002Fkernels\u002Fen\u002Findex)，便于分发。用户只需一行代码即可加载您的内核：\n\n```python\nfrom kernels import get_kernel\nmodule = get_kernel(\"your-username\u002Fkernel-name\")\n```\n\n```bash\n# 导出一个优化后的 CUDA 内核\nuv run export_hf.py --name my_matmul\n\n# 上传至 Hub（需先安装 `pip install kernels` 并登录 HuggingFace）\ncd workspace\u002Fhf_export\u002Fmy_matmul\nkernels upload . --repo_id your-username\u002Fmy_matmul\n```\n\n## 项目结构\n\n```\nautokernel\u002F\n  kernel.py             代理每次修改的文件（一次只改一个内核）\n  program.md            代理的操作说明——“研究组织代码”\n\n  bench.py              固定的基准测试 + 5 阶段正确性测试框架\n  reference.py          PyTorch 参考实现（真实结果）\n  prepare.py            一次性设置：测试数据、基线\n\n  profile.py            分析任意 PyTorch 模型，按 GPU 时间对内核排序\n  extract.py            将瓶颈内核提取到 workspace\u002F 目录\n  orchestrate.py        多内核调度器（阿姆达尔定律）\n  verify.py             端到端模型验证 + 加速效果报告\n  export_hf.py          将优化后的内核导出为 HuggingFace Kernels 格式\n  analysis.py           实验可视化（生成 https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FRightNow-AI_autokernel_readme_18212f72a48c.png）\n\n  kernels\u002F              初始 Triton 内核（9 种类型）\n  kernels\u002Fcuda\u002F         初始 CUDA C++ 内核（9 种类型，支持 Tensor Core 加速）\n  kernelbench\u002F          KernelBench 集成（桥接、评估框架、评分器）\n  models\u002F               自包含的模型定义（GPT-2、LLaMA、BERT）\n  workspace\u002F            运行时生成的中间文件（已忽略在 Git 中）\n```\n\n## 设计选择\n\n**双后端：Triton + CUDA C++。** Triton 适合快速迭代（类似 Python 的语法，编译只需几秒）。CUDA C++ 则用于追求极致性能（通过 `wmma`、PTX 内建指令和共享内存无冲突布局直接访问 Tensor Core）。Triton 的性能通常能达到 cuBLAS 的 80%-95%；而 CUDA C++ 则可以持平甚至超越 cuBLAS。两种后端共享相同的 `kernel_fn()` 接口——`bench.py` 在两者上都能以相同方式运行。\n\n**正确性第一。** 基准测试会在测量性能之前先对比内核输出与 PyTorch 结果。如果内核速度很快但结果错误，则会立即回滚。这样可以防止代理通过生成无效结果来“优化”。\n\n**阿姆达尔定律调度。** 调度器会根据影响优先级排序。例如，在占总耗时 60% 的内核上实现 1.5 倍加速（整体加速 1.25 倍），远胜于在仅占 5% 的内核上实现 3 倍加速（整体加速仅 1.03 倍）。当收益递减时，调度器会停止进一步优化。\n\n**单一可修改文件。** 代理仅需修改 `kernel.py` 文件。这样范围可控，差异易于审查，回滚也更干净。\n\n**TSV 日志记录。** 结果会保存到纯文本的 `results.tsv` 文件中。格式简单易读、适合 Git 管理且易于解析，无需额外基础设施。\n\n## 结果格式\n\n每次实验都会记录到 `results.tsv` 文件中（制表符分隔）：\n\n| 列名 | 描述 |\n|--------|-------------|\n| `experiment` | 实验序号（0 表示基线） |\n| `tag` | 简短标识符 |\n| `kernel_type` | 内核类型（如 `matmul`） |\n| `throughput_tflops` | 测得的吞吐量（越高越好） |\n| `latency_us` | 执行时间，单位为微秒 |\n| `pct_peak` | 占 GPU 理论峰值的比例 |\n| `speedup_vs_pytorch` | 相对于 PyTorch\u002FcuBLAS 的加速倍数 |\n| `correctness` | PASS、FAIL、TIMEOUT 或 CRASH |\n| `peak_vram_mb` | GPU 内存峰值用量 |\n| `description` | 尝试的内容 |\n\n## 致谢\n\n本项目是 **面向 GPU 内核的自动研究** —— 直接受到 Andrej Karpathy 的 [autoresearch](https:\u002F\u002Fgithub.com\u002Fkarpathy\u002Fautoresearch) 启发，该实验最初旨在探索由 AI 代理自主进行 LLM 训练的研究。Karpathy 证明了 AI 代理可以在一夜之间完成数百次实验，系统地探索搜索空间并记录每一步结果。AutoKernel 将这一流程应用到 GPU 内核优化领域，结合 Triton 和原生 CUDA C++，采用迭代优化的方式（每个问题进行 300 多次实验），而非一次性生成。\n\n**KernelBench** 集成基于斯坦福大学 Scaling Intelligence Lab 的 Simon Guo、Sean Resta 等人的工作。他们的论文《KernelBench：LLM 能否编写 GPU 内核？》（2025 年）确立了评估 AI 生成 GPU 内核的标准基准。AutoKernel 在此基础上进一步扩展，通过迭代优化（每个问题进行 300 多次实验）取代了一次性生成的方式。KernelBench 数据集及评估协议详见：[ScalingIntelligence\u002FKernelBench](https:\u002F\u002Fgithub.com\u002FScalingIntelligence\u002FKernelBench)。\n\n由 [RightNow AI](https:\u002F\u002Fwww.rightnowai.co) 构建。如需企业级 GPU 优化服务，请访问 [RightNow Enterprise](https:\u002F\u002Fwww.rightnowai.co\u002Fforge)。\n\n## 更改日志\n\n### v1.3.0\n- 支持 AMD ROCm GPU：检测并记录 MI300X、MI325X、MI350X、MI355X 的规格信息（感谢 [@andyluo7](https:\u002F\u002Fgithub.com\u002Fandyluo7)）\n- 修复了 `verify.py` 在 Python 3.13+ 上的 SyntaxError\n- 修复了 CUDA flash_attention 忽视 `sm_scale` 参数的问题\n- 修复了 CUDA cross_entropy 返回错误数据类型的问题\n- 修复了 Triton rotary_embedding 广播截断的问题\n- 修复了 Triton reduce 在非最后一维归约时输出形状不正确的问题\n\n### v1.2.0\n- 增强了性能分析工具：新增 `--export-trace`、`--memory-snapshot`、`--torch-compile-log` 标志\n- 新增通过 `export_hf.py` 导出至 HuggingFace Kernels 的功能\n\n### v1.1.0\n- 增加了原生 CUDA C++ 后端，包含 9 个初始内核（支持 Tensor Core、Warp 指令和共享内存分块）\n- 集成了 KernelBench（250 多个标准化的 GPU 内核问题）\n- 为 `extract.py` 添加了 `--backend triton|cuda` 标志\n\n### v1.0.0\n- 初始版本：基于 Triton 的内核优化流水线，配备 5 阶段正确性测试框架\n\n完整详情请参阅 [CHANGELOG.md](CHANGELOG.md)。\n\n## 许可证\n\nMIT","# AutoKernel 快速上手指南\n\nAutoKernel 是一个用于 GPU 内核自动优化的开源工具。它借鉴了自主 AI 研究代理的理念，能够自动分析 PyTorch 模型，识别性能瓶颈，并通过迭代实验自动生成优化后的 Triton 或 CUDA C++ 内核。\n\n## 环境准备\n\n在开始之前，请确保您的开发环境满足以下要求：\n\n*   **硬件**：NVIDIA GPU（已在 H100\u002FA100\u002FRTX 4090 上测试）。\n    *   *注：最新版本已支持 AMD ROCm GPU (MI300X 等)。*\n*   **系统**：Linux 或 macOS。\n*   **Python**：版本 3.10 或更高。\n*   **包管理器**：[uv](https:\u002F\u002Fdocs.astral.sh\u002Fuv\u002F)（推荐，用于快速管理依赖和虚拟环境）。\n\n## 安装步骤\n\n使用 `uv` 进行安装是最快捷的方式。以下是具体命令：\n\n```bash\n# 1. 安装 uv (如果尚未安装)\ncurl -LsSf https:\u002F\u002Fastral.sh\u002Fuv\u002Finstall.sh | sh\n\n# 2. 克隆仓库并进入目录\ngit clone https:\u002F\u002Fgithub.com\u002FRightNow-AI\u002Fautokernel.git\ncd autokernel\n\n# 3. 同步依赖并创建虚拟环境\nuv sync\n\n# 4. 一次性初始化设置（生成测试数据和基线）\nuv run prepare.py\n```\n\n## 基本使用\n\n以下是针对一个 PyTorch 模型进行自动内核优化的标准流程。本示例以内置的 LLaMA 模型为例。\n\n### 1. 性能剖析 (Profile)\n首先对模型进行剖析，找出占用 GPU 时间最多的内核瓶颈。\n\n```bash\nuv run profile.py --model models\u002Fllama_7b.py --class-name LlamaModel \\\n --input-shape 1,512 --dtype float16\n```\n*支持内置模型：GPT-2, LLaMA, BERT。无需安装庞大的 `transformers` 库即可运行内置模型。*\n\n### 2. 提取瓶颈内核 (Extract)\n根据剖析结果，提取排名靠前的瓶颈内核，生成独立的 Triton 或 CUDA C++ 文件。\n\n```bash\n# 提取前 5 个最耗时的内核\nuv run extract.py --top 5\n```\n\n### 3. 验证基准测试 (Verify Benchmark)\n在启动 AI 代理之前，先确保基准测试脚本能正常运行。\n\n```bash\nuv run bench.py\n```\n\n### 4. 运行 AI 代理 (Run Agent)\n启动您的编码代理（如 Claude、Codex 或其他支持代码生成的 LLM），并在项目根目录下输入以下指令：\n\n```text\nRead program.md and let's kick off a new experiment. Start with setup.\n```\n\n**代理将自动执行以下循环：**\n1.  读取 `program.md` 中的优化策略。\n2.  创建新的 Git 分支。\n3.  按优先级逐个修改 `kernel.py` 文件。\n4.  运行 `bench.py` 进行 correctness 检查（5 阶段验证）和性能测试。\n5.  根据结果保留或回退更改，并持续迭代优化。\n6.  最终通过 `verify.py` 报告端到端的加速比。\n\n> **提示**：每个实验约需 90 秒。代理可整夜运行，自动完成数百次迭代实验。\n\n### 可选：导出优化后的内核\n优化完成后，您可以将内核导出到 HuggingFace Hub 以便分享或使用：\n\n```bash\n# 导出 CUDA 内核\nuv run export_hf.py --name my_matmul\n\n# 上传到 Hub (需先登录: huggingface-cli login)\ncd workspace\u002Fhf_export\u002Fmy_matmul\nkernels upload . --repo_id your-username\u002Fmy_matmul\n```","某 AI 初创团队正在将自研的 7B 参数大语言模型部署到 H100 集群，却因推理延迟过高而面临上线瓶颈。\n\n### 没有 autokernel 时\n- **定位困难**：工程师需手动运行复杂的性能分析工具，在数百个算子中艰难排查耗时最长的“元凶”，往往耗费数天才能锁定瓶颈。\n- **优化门槛高**：针对识别出的瓶颈算子，资深工程师需手工编写并反复调试底层的 Triton 或 CUDA C++ 代码，对硬件架构知识要求极高且极易出错。\n- **验证繁琐**：每次修改内核后，必须人工设计多轮测试用例来验证数值正确性和边界情况，稍有不慎就会导致模型输出异常，迭代周期漫长。\n- **全局视野缺失**：难以直观判断单个算子的优化对整体模型速度的实际贡献，常出现“局部最优但整体提升微弱”的资源浪费情况。\n\n### 使用 autokernel 后\n- **自动诊断**：autokernel 一键扫描 PyTorch 模型，自动按 GPU 耗时排序并精准提取出前 5 个关键瓶颈算子，瞬间完成定位。\n- **无人值守优化**：autokernel 驱动 AI 代理自主编写、编译并基准测试优化的 Triton 内核，团队只需睡一觉，醒来即可获得经过数百次迭代的最优代码。\n- **严谨自测**：autokernel 内置五阶段自动化验证流程（含数值稳定性与确定性检查），确保每个新生成的内核在提速的同时严格保证数学等价性。\n- **智能调度**：基于阿姆达尔定律，autokernel 自动计算并优先优化对端到端延迟影响最大的算子，确保每一分算力投入都转化为实际的推理加速。\n\nautokernel 将原本需要资深专家数周完成的底层内核优化工作，转变为 overnight 的自动化流程，让团队能专注于模型算法本身而非硬件适配。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FRightNow-AI_autokernel_18212f72.png","RightNow-AI","RightNow","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002FRightNow-AI_841b6441.png","GPU AI Code Editor",null,"jaber@rightnowai.co","rightnowai_co","https:\u002F\u002Fwww.rightnowai.co\u002F","https:\u002F\u002Fgithub.com\u002FRightNow-AI",[83],{"name":84,"color":85,"percentage":86},"Python","#3572A5",100,1117,102,"2026-04-08T06:18:43","MIT",4,"Linux","必需 NVIDIA GPU (测试于 H100\u002FA100\u002FRTX 4090)，v1.3.0 更新支持 AMD ROCm GPU (MI300X\u002FMI325X 等)","未说明",{"notes":96,"python":97,"dependencies":98},"推荐使用 uv 进行依赖管理和环境同步。工具主要面向 NVIDIA GPU 优化，但最新版本已增加对 AMD ROCm 的支持。运行前需执行 prepare.py 进行一次性设置以生成测试数据和基线。代理程序（Agent）需要配置外部编码模型（如 Claude 或 Codex）才能自动执行优化循环。","3.10+",[99,100,101,102],"uv","torch","triton","transformers (可选)",[104,14],"其他",[106,107,108,109,110,101],"autoresearch","cuda","gpu","kernel-optimization","pytorch","2026-03-27T02:49:30.150509","2026-04-08T20:31:13.654595",[],[]]