wafer

Product Introduction

1. Definition: Wafer is an integrated GPU development stack (IDE plugin) that consolidates profiling, compiler exploration, and documentation tools directly within code editors like VSCode and Cursor. It targets CUDA/CuteDSL workflows for NVIDIA GPU kernel optimization.
2. Core Value Proposition: Eliminates context switching between fragmented tools (e.g., separate profilers, browser-based docs) by embedding the entire GPU development lifecycle—coding, profiling, optimization, and debugging—into a single IDE environment.

Main Features

1. NCU Profiler Integration:

   • How it works: Executes NVIDIA Compute Utility (NCU) hardware-level profiling within the IDE. Displays metrics like SM/DRAM throughput, kernel duration, and optimization bottlenecks (e.g., underutilized grids) via interactive timelines and summaries.
   • Technologies: Leverages NVIDIA hardware counters (e.g., B200 GPUs), sampling PM metrics, and visualizes wave occupancy/SM efficiency.

2. Compiler Explorer:

   • How it works: Compiles CUDA/CuteDSL code to PTX/SASS in real-time, mapping outputs to source lines. Shows assembly-level optimizations (e.g., register usage, instruction scheduling) without leaving the editor.
   • Technologies: Integrates NVIDIA NVVM compiler (e.g., PTX generation for sm_100+ architectures) with Godbolt-like functionality.

3. GPU Documentation Search:

   • How it works: Semantic search across NVIDIA docs (CUDA, CUTLASS, optimization guides) using natural language queries (e.g., "Enable PDL in CUTLASS"). Returns API references/best practices in-editor.
   • Technologies: Curated GPU knowledge base with vector search for low-latency retrieval.

4. AI Optimization Agent:

   • How it works: Analyzes NCU profiles to suggest kernel optimizations (e.g., grid sizing, unrolling). Generates code diffs, sweeps hyperparameters (tile sizes/thread counts), and calls tools autonomously.
   • Technologies: Tool-calling AI fine-tuned for GPU workflows, with diff-based review.

5. GPU Workspaces:

   • How it works: Maintains persistent CPU containers while provisioning GPUs on-demand during execution. Reduces cloud costs by ~95% via fractional GPU usage.
   • Technologies: Container orchestration for CPU/GPU decoupling, cloud resource optimization.

Problems Solved

1. Pain Point: Fragmented tooling forces developers to juggle editors, profilers (e.g., NSight), compiler explorers, and browser tabs—slowing iteration cycles by 10x.
2. Target Audience:
   • CUDA kernel engineers optimizing HPC/AI workloads.
   • ML researchers tuning low-level GPU ops (e.g., tensor cores).
   • Performance specialists debugging SM occupancy/memory bottlenecks.
3. Use Cases:
   • Real-time profiling during kernel development to fix underutilized grids.
   • On-demand PTX/SASS inspection to validate compiler optimizations.
   • Cost-efficient prototyping via burstable GPU workspaces.

Unique Advantages

1. Differentiation: Unifies disjointed tools (e.g., NSight + Godbolt + docs) into one workflow, unlike siloed alternatives. Integrates AI for proactive optimization vs. reactive manual analysis.
2. Key Innovation: Persistent CPU + on-demand GPU model slashes cloud costs, while IDE-native tooling enables <1s context switches (vs. 5-10min in traditional setups).

Frequently Asked Questions (FAQ)

1. How does Wafer reduce GPU development costs?
   Wafer’s persistent CPU workspaces spin up GPUs only during code execution, cutting cloud expenses by ~95% versus always-on instances.

2. Which NVIDIA GPUs and tools does Wafer support?
   Supports B200+ GPUs with NCU profiling, PTX/SASS compilation, and full CUDA/CUTLASS documentation.

3. Can Wafer automate GPU kernel optimization?
   Yes, its AI agent analyzes NCU profiles to suggest hyperparameter tuning (e.g., thread counts), generate code diffs, and validate optimizations.

4. Does Wafer work with local IDEs or only cloud?
   Available as extensions for local IDEs (VSCode, Cursor) with hybrid cloud execution for GPU workloads.

5. How does Wafer’s compiler explorer differ from Godbolt?
   Provides GPU-specific PTX/SASS mapping to source code and integrates results into AI-driven optimization workflows—all within the IDE.