Show HN: Open-source AMDGCN kernels for optimizing LLM inference Netra Kernel, an open-source ahead-of-time GPU kernel compiler for AMD, achieved 78,498.66 output tokens per second mean throughput serving Qwen3.6-35B-A3B-FP8 on eight AMD MI350X GPUs, within 0.32% of the locked baseline, with all 15,360 exact request checks passed and 18/18 generated kernels identical to locked versions. The compiler targets gfx950 /wave64 for high-throughput FP8 inference, specializing model operations into fixed-contract raw-assembly kernels packaged as loadable Netra Engines. Ahead-of-time GPU kernels for production inference on AMD. Netra Kernel compiles model operations into fixed-contract raw-assembly kernels and packages them as loadable Netra Engines . It brings a TensorRT-style workflow for profiles, tactics, layout planning, static memory planning, and engine building, applied to native AMD GPU kernels. Compile for the exact serving contract. Launch only specialized kernels at runtime. The first production backend targets gfx950 /wave64, with a focus on high-throughput FP8 inference for large language models. Get started get-started · Explore the architecture /NetraRuntime/netra-kernel/blob/main/docs/compiler/architecture.md · Read the engine format /NetraRuntime/netra-kernel/blob/main/docs/compiler/engine-format.md · Integrate another engine /NetraRuntime/netra-kernel/blob/main/docs/integrating-an-inference-engine.md · Contribute /NetraRuntime/netra-kernel/blob/main/CONTRIBUTING.md Native performance without a model-locked codebase. Kernels remain schedule-specific raw assembly, while contracts and templates make proven mechanisms reusable across compatible Qwen, Gemma, Llama, and future model operations. Predictable serving. Shapes, data types, layouts, quantization, launch dimensions, LDS, workspaces, and epilogues are resolved ahead of time. A minimal hot path. Engine initialization loads modules, resolves symbols, binds stable memory, and optionally captures HIP graphs. Serving reuses cached handles on a caller-owned stream. Safe specialization. Exact profile guards prevent approximate dispatch. Unsupported contracts return an explicit framework fallback. Evidence-based optimization. Tactics carry maturity, numerical semantics, deterministic ranking, and correctness and performance evidence. Netra is intentionally not one dynamically generic GPU kernel. Generality lives in the compiler and kernel library; generated machine code is fully specialized. The initial production target is Qwen3.6-35B-A3B-FP8 serving on eight AMD MI350X GPUs. | Deployment | Result | |---|---| | 8× MI350X, DP8, dFlash | 78,498.66 output tokens/s mean | | Exact request/input/output/token/cache checks | 15,360 / 15,360 passed | Generated versus locked kernel .text | 18 / 18 identical | The modular engine result was within 0.32% of the locked 78,748.15 tokens/s baseline and passed the no-regression statistical gate. These numbers describe this exact checkpoint, hardware topology, graph configuration, request set, and five-run measurement; they are not a universal performance claim. See the machine-readable serving validation /NetraRuntime/netra-kernel/blob/main/docs/compiler/gfx950-qwen36-modular-serving-validation-20260818.json and validation methodology /NetraRuntime/netra-kernel/blob/main/docs/compiler/validation.md . Model or canonical graph │ ▼ Netra Compiler contracts · profiles · layouts · tactics · memory plan │ ▼ Specialized raw assembly + Netra Engine fixed symbols · fixed launches · graph recipe · fallbacks │ ▼ Netra Runtime cached HIP handles · stable bindings · caller-owned stream The Python compiler accepts an explicit model description or canonical graph, validates its numerical and layout semantics, selects compatible tactics, and emits deterministic engine artifacts. The core compiler has no mandatory third-party Python dependencies. The gfx950 library is organized into reusable assembler includes and focused schedule templates for routed MoE, attention, routing, GDN, and dense operations. Tactic parameters are assembler-time constants; specialization never introduces runtime shape branches. An engine contains contracts, selected tactics, launch metadata, static memory and layout plans, generated sources, optional code objects, and a deterministic HIP graph recipe. Engine output is reproducible and contains no semantic timestamps or machine-specific build paths. The HIP runtime exposes a stable C ABI for loading an engine, querying profiles, binding persistent and boundary buffers, and launching on a caller-provided stream. Direct fixed launches remain available when graph capture is disabled. The installed SDK exports libnetra engine.so.1 ,