rocmate 0.1.0__py3-none-any.whl

rocmate/__init__.py

@@ -0,0 +1,2 @@
+"""rocmate — AMD GPU compatibility tooling for AI workloads."""
+__version__ = "0.1.0"

rocmate/_configs/tools/axolotl.yaml

@@ -0,0 +1,55 @@
+name: Axolotl
+description: Fine-tuning framework for LLMs supporting LoRA, QLoRA, and full fine-tuning.
+homepage: https://github.com/axolotl-ai-cloud/axolotl
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7900 XTX (24 GB) handles QLoRA fine-tuning of 7B–13B models comfortably.
+      Flash-attention 2 works via ROCm CK (install separately). bitsandbytes ROCm fork
+      required for quantized training.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "git clone https://github.com/axolotl-ai-cloud/axolotl && cd axolotl"
+      - "pip install torch --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "pip install packaging ninja && pip install flash-attn --no-build-isolation"
+      - "pip install -e '.[deepspeed]'"
+      - "accelerate launch -m axolotl.cli.train examples/llama-3/qlora.yml"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — QLoRA of 7B models fits in 16 GB. Same setup as gfx1100.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Same install as gfx1100. Use gradient_checkpointing: true in your YAML for memory savings."
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 6800/6900 — QLoRA of 7B works. Full fine-tuning requires gradient checkpointing.
+      Flash-attention fallback path is slower than RDNA3.
+    env_vars: {}
+    install_hints:
+      - "Same install as gfx1100."
+      - "Add gradient_checkpointing: true and micro_batch_size: 1 to your config."
+
+  gfx1102:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7600 (8 GB) — QLoRA of 7B is tight. Use per_device_train_batch_size: 1 and
+      gradient_checkpointing. Offload optimizer states to CPU if OOM.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Same install as gfx1100."
+      - "Config: micro_batch_size: 1, gradient_checkpointing: true, optimizer: adamw_8bit"

rocmate/_configs/tools/comfyui.yaml

@@ -0,0 +1,50 @@
+name: ComfyUI
+description: Node-based UI for Stable Diffusion and other image generation models.
+homepage: https://github.com/comfyanonymous/ComfyUI
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      Works well on RX 7900 XTX with PyTorch ROCm 6.2+. SDXL runs comfortably in 24 GB VRAM.
+      Flux.1 also works but requires careful memory management.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Linux: git clone https://github.com/comfyanonymous/ComfyUI && cd ComfyUI"
+      - "python -m venv venv && source venv/bin/activate"
+      - "pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "pip install -r requirements.txt && python main.py --listen"
+      - "Windows (HIP SDK): pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm6.2"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — same setup as gfx1100. 16 GB VRAM limits Flux.1; SDXL and SD 1.5 run well.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Same install as gfx1100."
+
+  gfx1102:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: RX 7600 — 8 GB VRAM is tight. SD 1.5 works; SDXL requires --lowvram flag and is slow.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Same install as gfx1100."
+      - "Launch with: python main.py --lowvram --listen"
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: SDXL is slow; SD 1.5 works fine. Memory pressure with larger models.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "10.3.0"
+    install_hints:
+      - "Same as gfx1100 install; expect ~3-4x slower SDXL generation."

rocmate/_configs/tools/exllamav2.yaml

@@ -0,0 +1,52 @@
+name: ExLlamaV2
+description: Fast inference library for GPTQ and EXL2 quantized LLMs, optimised for AMD GPUs via ROCm.
+homepage: https://github.com/turboderp/exllamav2
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7900 XTX — excellent performance. ExLlamaV2 is one of the fastest GPTQ/EXL2
+      backends on AMD. Mistral 7B EXL2 4bpw runs at ~80 tok/s. 24 GB allows 34B Q4.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "pip install torch --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "pip install exllamav2"
+      - "python test_inference.py -m /path/to/model -p \"Hello world\""
+      - "Or build from source for latest features: git clone https://github.com/turboderp/exllamav2 && pip install -e ."
+      - "cmake -DCMAKE_BUILD_TYPE=Release . && cmake --build . --target exl2 --config Release"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — works well. 16 GB VRAM suits 13B Q4 or 7B Q8 models.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "Same install as gfx1100."
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 6800/6900 — functional but kernel tuning may differ from RDNA3.
+      Performance is good for quantized models; throughput ~60-70 % of gfx1100.
+    env_vars: {}
+    install_hints:
+      - "pip install torch --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "pip install exllamav2"
+
+  gfx1102:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7600 (8 GB) — 7B EXL2 4bpw fits with room to spare. 13B Q4 is tight but possible.
+      Monitor VRAM with rocm-smi; context length may need reducing.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "pip install torch --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "pip install exllamav2"
+      - "Reduce max_seq_len if VRAM is exhausted."

rocmate/_configs/tools/faster-whisper.yaml

@@ -0,0 +1,35 @@
+name: faster-whisper
+description: Fast Whisper inference using CTranslate2. ROCm support via PyTorch backend.
+homepage: https://github.com/SYSTRAN/faster-whisper
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      faster-whisper itself targets CUDA; on AMD use the openai-whisper or whisperX
+      route with PyTorch + ROCm, or run faster-whisper on CPU with int8 quantization
+      (still fast for short clips). For GPU on AMD, use openai-whisper-rocm fork.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "pip install torch torchaudio --index-url https://download.pytorch.org/whl/rocm6.2"
+      - "Verify torch.cuda.is_available() returns True (yes, 'cuda' under ROCm)"
+      - "For pure faster-whisper: use device='cpu', compute_type='int8' as fallback"
+
+  gfx1101:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — same PyTorch ROCm approach as gfx1100. Transcription speed similar to gfx1100.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "pip install torch torchaudio --index-url https://download.pytorch.org/whl/rocm6.2"
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: PyTorch ROCm wheels available, but transcription is slower than gfx1100.
+    env_vars: {}
+    install_hints:
+      - "pip install torch torchaudio --index-url https://download.pytorch.org/whl/rocm6.2"

rocmate/_configs/tools/llama-cpp.yaml

@@ -0,0 +1,50 @@
+name: llama.cpp
+description: Efficient LLM inference in C++ with HIP backend for AMD GPUs.
+homepage: https://github.com/ggerganov/llama.cpp
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      Compile with GGML_HIP=ON. Runs well on RX 7900 XTX; Q4_K_M models up to 70B fit in 24 GB.
+      Pre-built HIP binaries available in GitHub releases.
+    env_vars: {}
+    install_hints:
+      - "Linux: git clone https://github.com/ggerganov/llama.cpp && cd llama.cpp"
+      - "cmake -B build -DGGML_HIP=ON && cmake --build build --config Release -j$(nproc)"
+      - "Windows: download pre-built HIP binary from GitHub Releases (look for 'hip' in filename)"
+      - "Verify GPU is used: ./build/bin/llama-cli -m model.gguf -p 'hello' --n-gpu-layers 99"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — same build as gfx1100. 16 GB VRAM; Q4_K_M models up to 32B.
+    env_vars: {}
+    install_hints:
+      - "Same build as gfx1100."
+
+  gfx1102:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7600 — 8 GB VRAM; Q4_K_M models up to 8B. Offload remaining layers to CPU with --n-gpu-layers.
+    env_vars: {}
+    install_hints:
+      - "Same build as gfx1100."
+      - "Use --n-gpu-layers 30 to partially offload larger models."
+
+  gfx1030:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 6800/6900 — works out of the box with HIP build. Performance slightly below gfx1100.
+    env_vars: {}
+    install_hints:
+      - "Same build as gfx1100."
+
+  gfx1201:
+    status: partial
+    tested_on_rocm: "7.x"
+    notes: RX 9070 — requires ROCm 7.x. HIP build may need HSA_OVERRIDE for gfx120x target.
+    env_vars: {}
+    install_hints:
+      - "Build with ROCm 7.x; report results to the rocmate project."

rocmate/_configs/tools/ollama.yaml

@@ -0,0 +1,66 @@
+name: Ollama
+description: Run large language models locally, with built-in ROCm support.
+homepage: https://ollama.com
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.3"
+    notes: >
+      Works out of the box on Linux with ROCm 6.x.
+      Tested on RX 7900 XTX (24 GB) running Qwen 2.5 14B and Llama 3.1 8B.
+    env_vars: {}
+    install_hints:
+      - "Linux: curl -fsSL https://ollama.com/install.sh | sh"
+      - "Windows: download the Ollama installer from https://ollama.com/download/windows (ships HIP libs)"
+      - "Verify with: ollama run llama3.1:8b (should hit GPU, not CPU)"
+      - "Watch GPU usage live: watch -n 1 rocm-smi"
+
+  gfx1030:
+    status: tested
+    tested_on_rocm: "6.3"
+    notes: Works on RX 6800/6900 with ROCm 6.x. Some older guides recommend HSA_OVERRIDE — no longer needed.
+    env_vars: {}
+    install_hints:
+      - "curl -fsSL https://ollama.com/install.sh | sh"
+
+  gfx1201:
+    status: partial
+    tested_on_rocm: "7.x"
+    notes: >
+      RX 9070 series needs HIP SDK 7.1+ with gfx120x rocblas libraries.
+      Official Ollama Windows installer ships these as of January 2026.
+    env_vars: {}
+    install_hints:
+      - "On Linux: requires ROCm 7.x — see https://rocm.docs.amd.com"
+      - "On Windows: AMD AI Bundle installer (Adrenalin 26.x+) ships compatible libs."
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.3"
+    notes: RX 7800 XT / RX 7700 XT — works out of the box on Linux with ROCm 6.x, same as gfx1100.
+    env_vars: {}
+    install_hints:
+      - "curl -fsSL https://ollama.com/install.sh | sh"
+
+  gfx1102:
+    status: tested
+    tested_on_rocm: "6.3"
+    notes: RX 7600 — works on Linux with ROCm 6.x. Lower VRAM (8 GB) limits model size; stick to ≤7B Q4.
+    env_vars: {}
+    install_hints:
+      - "curl -fsSL https://ollama.com/install.sh | sh"
+      - "Limit to models ≤7B Q4 due to 8 GB VRAM."
+
+  gfx1034:
+    status: partial
+    tested_on_rocm: "6.3"
+    notes: >
+      RX 5400/5500 series — ROCm does not officially support gfx1034.
+      Force compatibility with HSA_OVERRIDE_GFX_VERSION=10.3.0 (treats card as gfx1030).
+      Token generation is slow but functional for small models.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "10.3.0"
+    install_hints:
+      - "Set HSA_OVERRIDE before launching the Ollama service"
+      - "Limit to small models (≤7B Q4) due to lower memory bandwidth"

rocmate/_configs/tools/stable-diffusion-webui.yaml

@@ -0,0 +1,49 @@
+name: Stable Diffusion WebUI
+description: AUTOMATIC1111's browser UI for Stable Diffusion, with ROCm support via PyTorch.
+homepage: https://github.com/AUTOMATIC1111/stable-diffusion-webui
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      Works on RX 7900 XTX with PyTorch ROCm wheels. SDXL and SD 1.5 run well.
+      Flux.1 requires additional setup (install flux dependencies separately).
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui && cd stable-diffusion-webui"
+      - "Set TORCH_COMMAND before launch: export TORCH_COMMAND='pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm6.2'"
+      - "Linux launch: ./webui.sh"
+      - "Windows: set TORCH_COMMAND=pip install torch torchvision --index-url https://download.pytorch.org/whl/rocm6.2 && webui-user.bat"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — same setup as gfx1100. 16 GB VRAM; SDXL runs well, Flux.1 tight.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+      PYTORCH_HIP_ALLOC_CONF: "expandable_segments:True"
+    install_hints:
+      - "Same as gfx1100."
+
+  gfx1102:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: RX 7600 — 8 GB VRAM. SD 1.5 works; SDXL needs --medvram or --lowvram flag and is slow.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "Same as gfx1100."
+      - "Launch with: ./webui.sh --medvram"
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: RX 6800/6900 — works with HSA_OVERRIDE. SDXL slow; SD 1.5 fine. Use --medvram for stability.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "10.3.0"
+    install_hints:
+      - "Same install as gfx1100."
+      - "Launch with: ./webui.sh --medvram"

rocmate/_configs/tools/vllm.yaml

@@ -0,0 +1,60 @@
+name: vLLM
+description: High-throughput LLM inference server with continuous batching and PagedAttention.
+homepage: https://github.com/vllm-project/vllm
+
+chips:
+  gfx1100:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7900 XTX works well. vLLM pre-allocates GPU memory (90 % by default) so 24 GB lets
+      you run 13–34B models. Use --gpu-memory-utilization to tune. Flash-attention is supported
+      via ROCm's CK library.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "python -m venv venv && source venv/bin/activate"
+      - "pip install vllm --extra-index-url https://download.pytorch.org/whl/rocm6.2"
+      - "python -m vllm.entrypoints.openai.api_server --model meta-llama/Llama-3.1-8B-Instruct"
+      - "Verify with: curl http://localhost:8000/v1/models"
+
+  gfx1101:
+    status: tested
+    tested_on_rocm: "6.2"
+    notes: RX 7800 XT / RX 7700 XT — works on Linux. 16 GB VRAM limits to ≤13B models.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "Same install as gfx1100. Set --gpu-memory-utilization 0.85 to leave headroom."
+
+  gfx1030:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 6800/6900 — works but slower than RDNA3 cards. PagedAttention works.
+      Flash-attention backend may fall back to a slower kernel.
+    env_vars: {}
+    install_hints:
+      - "pip install vllm --extra-index-url https://download.pytorch.org/whl/rocm6.2"
+
+  gfx1102:
+    status: partial
+    tested_on_rocm: "6.2"
+    notes: >
+      RX 7600 (8 GB) — vLLM's default memory pre-allocation requires lowering
+      --gpu-memory-utilization to 0.80 or less. Stick to 7B Q4/Q8 models.
+    env_vars:
+      HSA_OVERRIDE_GFX_VERSION: "11.0.0"
+    install_hints:
+      - "pip install vllm --extra-index-url https://download.pytorch.org/whl/rocm6.2"
+      - "python -m vllm.entrypoints.openai.api_server --model <model> --gpu-memory-utilization 0.80"
+
+  gfx1201:
+    status: partial
+    tested_on_rocm: "7.x"
+    notes: >
+      RX 9070 series — requires ROCm 7.x builds of vLLM. Pre-built wheels may not be
+      available; expect to build from source. Flash-attention support still maturing.
+    env_vars: {}
+    install_hints:
+      - "Build from source: git clone https://github.com/vllm-project/vllm && pip install -e . --extra-index-url https://download.pytorch.org/whl/rocm7.x"

rocmate/cli.py

@@ -0,0 +1,142 @@
+"""rocmate command-line interface."""
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from rocmate import configs as configs_module
+from rocmate import doctor as doctor_module
+from rocmate import fixer as fixer_module
+from rocmate import install as install_module
+from rocmate.doctor import Status
+from rocmate.install import InstallError
+
+app = typer.Typer(
+    name="rocmate",
+    help="Curated AMD GPU compatibility index and CLI for AI workloads.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+_STATUS_ICON = {
+    "tested": "[green]✅ tested[/green]",
+    "partial": "[yellow]🟡 partial[/yellow]",
+    "broken": "[red]❌ broken[/red]",
+}
+
+
+@app.command()
+def doctor(
+    tool: Optional[str] = typer.Option(None, "--tool", help="Also show compatibility for a specific tool."),
+    fix: bool = typer.Option(False, "--fix", help="Interactively apply fixes for detected issues."),
+) -> None:
+    """Check whether the system is ready for AI workloads on an AMD GPU."""
+    result = doctor_module.run()
+    doctor_module.render(result, console)
+
+    if tool is not None:
+        try:
+            cfg = configs_module.load_tool(tool)
+        except FileNotFoundError:
+            console.print(f"[red]No config for tool '{tool}'.[/red]")
+            console.print(f"Available tools: {', '.join(configs_module.list_tools())}")
+            raise typer.Exit(code=1)
+
+        console.print(f"\n[bold]Tool compatibility: {cfg.name}[/bold]")
+        if not result.gpu_info:
+            console.print("[yellow]  No AMD GPU detected — cannot check tool compatibility.[/yellow]")
+        else:
+            for gpu_info in result.gpu_info:
+                chip = gpu_info.gfx_version
+                if chip in cfg.chips:
+                    support = cfg.chips[chip]
+                    icon = _STATUS_ICON.get(support.status, support.status)
+                    rocm = f" (ROCm {support.tested_on_rocm})" if support.tested_on_rocm else ""
+                    console.print(f"  {chip}: {icon}{rocm}")
+                else:
+                    console.print(f"  {chip}: [dim]no data[/dim]")
+
+    if fix:
+        fixable = [c for c in result.checks if c.fix and c.status != Status.OK]
+        if not fixable:
+            console.print("[green]Nothing to fix.[/green]")
+        else:
+            for check in fixable:
+                console.print(f"\n[bold]Fix available:[/bold] {check.name}")
+                console.print(f"  [dim]{check.fix}[/dim]")
+                if typer.confirm("Apply?", default=False):
+                    fix_result = fixer_module.apply_fix(check)
+                    if fix_result and fix_result.applied:
+                        console.print(f"  [green]✓ {fix_result.message}[/green]")
+                    elif fix_result:
+                        console.print(f"  [yellow]⚠ {fix_result.message}[/yellow]")
+
+    if result.has_blocking_issues():
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def show(tool: str = typer.Argument(..., help="Tool name, e.g. 'ollama'")) -> None:
+    """Show the tested configuration for a given tool."""
+    try:
+        config = configs_module.load_tool(tool)
+    except FileNotFoundError:
+        console.print(f"[red]No config available for tool '{tool}'.[/red]")
+        console.print(f"Available tools: {', '.join(configs_module.list_tools())}")
+        raise typer.Exit(code=1)
+    configs_module.render(config, console)
+
+
+@app.command(name="list")
+def list_tools() -> None:
+    """List all tools with tested configurations."""
+    tools = configs_module.list_tools()
+    console.print(f"[bold]Available tools ({len(tools)}):[/bold]")
+    for t in tools:
+        console.print(f"  • {t}")
+
+
+@app.command()
+def install(
+    tool: str = typer.Argument(..., help="Tool to install, e.g. 'ollama'"),
+    docker: bool = typer.Option(False, "--docker", help="Print a Docker Compose snippet instead."),
+) -> None:
+    """Install a tool with the correct ENV vars and pip indexes for your AMD GPU."""
+    from rocmate import gpu as gpu_module
+
+    gpus = gpu_module.detect_amd_gpus()
+    if not gpus:
+        console.print("[red]No AMD GPU detected — cannot determine install config.[/red]")
+        raise typer.Exit(code=1)
+
+    chip = gpus[0].gfx_version
+    try:
+        plan = install_module.build_plan(tool, chip)
+    except FileNotFoundError:
+        console.print(f"[red]No config for tool '{tool}'.[/red]")
+        console.print(f"Available tools: {', '.join(configs_module.list_tools())}")
+        raise typer.Exit(code=1)
+    except KeyError:
+        console.print(f"[yellow]No install config for {chip} + {tool}.[/yellow]")
+        raise typer.Exit(code=1)
+
+    if docker:
+        console.print(install_module.render_docker_compose(plan))
+        return
+
+    install_module.render_dry_run(plan, console)
+
+    if typer.confirm("Install now?", default=False):
+        try:
+            install_module.execute(plan)
+            console.print("[green]Done.[/green]")
+        except InstallError as e:
+            console.print(f"[red]Install failed:[/red] {e}")
+            raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

rocmate/configs.py

@@ -0,0 +1,98 @@
+"""Tool configuration loading and rendering."""
+from __future__ import annotations
+
+from importlib.resources import files
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel, Field
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class ChipSupport(BaseModel):
+    status: str  # "tested" | "partial" | "broken"
+    tested_on_rocm: Optional[str] = None  # e.g. "6.2", "6.3" — None = unknown
+    notes: Optional[str] = None
+    env_vars: dict[str, str] = Field(default_factory=dict)
+    install_hints: list[str] = Field(default_factory=list)
+
+
+class ToolConfig(BaseModel):
+    name: str
+    description: str
+    homepage: Optional[str] = None
+    chips: dict[str, ChipSupport] = Field(default_factory=dict)
+
+
+def _configs_dir() -> Path:
+    """Locate the bundled configs directory."""
+    # Dev mode: configs/ next to src/ (repo checkout)
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "configs" / "tools"
+        if candidate.is_dir():
+            return candidate
+    # Installed: configs live under rocmate/_configs (via hatch force-include)
+    try:
+        installed = Path(str(files("rocmate").joinpath("_configs/tools")))
+        if installed.is_dir():
+            return installed
+    except (ModuleNotFoundError, FileNotFoundError):
+        pass
+    raise FileNotFoundError("Could not locate rocmate configs directory")
+
+
+def list_tools() -> list[str]:
+    return sorted(p.stem for p in _configs_dir().glob("*.yaml"))
+
+
+def load_tool(tool: str) -> ToolConfig:
+    path = _configs_dir() / f"{tool}.yaml"
+    if not path.is_file():
+        raise FileNotFoundError(f"No config for tool '{tool}'")
+    data = yaml.safe_load(path.read_text())
+    return ToolConfig(**data)
+
+
+_STATUS_STYLE = {
+    "tested": "[green]✅ tested[/green]",
+    "partial": "[yellow]🟡 partial[/yellow]",
+    "broken": "[red]❌ broken[/red]",
+}
+
+
+def render(config: ToolConfig, console: Console) -> None:
+    header = f"[bold]{config.name}[/bold]\n{config.description}"
+    if config.homepage:
+        header += f"\n[dim]{config.homepage}[/dim]"
+    console.print(Panel(header, expand=False))
+
+    table = Table(title="Chip support", show_lines=False)
+    table.add_column("Chip")
+    table.add_column("Status")
+    table.add_column("ROCm")
+    table.add_column("Notes")
+    for chip, support in config.chips.items():
+        table.add_row(
+            chip,
+            _STATUS_STYLE.get(support.status, support.status),
+            support.tested_on_rocm or "[dim]?[/dim]",
+            support.notes or "",
+        )
+    console.print(table)
+
+    for chip, support in config.chips.items():
+        if not support.env_vars and not support.install_hints:
+            continue
+        console.print(f"\n[bold]{chip}[/bold]")
+        if support.env_vars:
+            console.print("  Environment:")
+            for k, v in support.env_vars.items():
+                console.print(f"    [cyan]export {k}={v}[/cyan]")
+        if support.install_hints:
+            console.print("  Install hints:")
+            for hint in support.install_hints:
+                console.print(f"    • {hint}")