Deploy ROCmPort AI — CUDA-to-ROCm migration scanner

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.venv/Scripts/python.exe filter=lfs diff=lfs merge=lfs -text
+.venv/Scripts/pythonw.exe filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+.pytest_cache/
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.gradio/
+artifacts/
+tmp/
+.tmp/
+pytest-cache-files-*/

.venv/Scripts/python.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8afe555632efdbf8b01309532efc9389c5d4417fac976f6ee4389c7750772745
+size 269072

.venv/Scripts/pythonw.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:080e0247dd5a0240070bb2244b2bd64fc31217c764c8c9d7ce3bf844760ba88e
+size 256784

.venv/pyvenv.cfg

@@ -0,0 +1,5 @@
+home = C:\Users\nawan\anaconda3
+include-system-site-packages = false
+version = 3.12.4
+executable = C:\Users\nawan\anaconda3\python.exe
+command = C:\Users\nawan\anaconda3\python.exe -m venv C:\Users\nawan\Documents\Codex\2026-05-05\come-build-the-next-generation-of\.venv

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ROCmPort AI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,115 @@
 ---
 title: ROCmPort AI
-emoji: 👁
-colorFrom: purple
-colorTo: purple
-sdk: static
+emoji: ⚡
+colorFrom: red
+colorTo: yellow
+sdk: gradio
+app_file: app.py
 pinned: false
-short_description: 'CUDA to ROCm/HIP migration assistant using AI agents on AMD '
+license: mit
+short_description: CUDA-to-ROCm migration scanner for PyTorch, HF & vLLM repos
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ⚡ ROCmPort AI
+
+> **AMD Developer Hackathon — lablab.ai** | Track: AI Agents & Agentic Workflows
+
+ROCmPort AI is a **CUDA-to-ROCm migration scanner** powered by a three-agent CrewAI pipeline and Qwen3-Coder running on AMD Instinct GPUs. Drop in any CUDA-first PyTorch, Hugging Face, or vLLM repository and get a full AMD readiness report in seconds.
+
+## What it does
+
+```mermaid
+graph LR
+    User([User Repo]) --> Gradio[Gradio UI]
+    Gradio --> Pipeline{Pipeline}
+    
+    subgraph Agentic Workflow
+    Pipeline --> Auditor[CUDA Auditor]
+    Auditor --> Engineer[ROCm Engineer]
+    Engineer --> Reporter[Report Writer]
+    end
+    
+    Reporter --> LLM[(Qwen3-Coder on AMD Instinct)]
+    LLM --> Reporter
+    
+    Pipeline --> Scanner[Deterministic Scanner]
+    Scanner --> Patcher[Patcher]
+    Patcher --> Artifacts[Artifact Generator]
+    
+    Reporter --> Final([Migration Artifacts & Patch])
+    Artifacts --> Final
+```
+
+| Output | Description |
+|---|---|
+| **AMD Readiness Score** | Before/after scores across 5 categories |
+| **Findings table** | File + line references for every CUDA blocker |
+| **ROCm patch diff** | Auto-generated unified diff to apply deterministic fixes |
+| **Dockerfile.rocm** | ROCm-enabled container using vllm/vllm-openai-rocm |
+| **AMD Developer Cloud Runbook** | Exact validation commands for AMD Instinct GPUs |
+| **Migration report** | Narrative report (CrewAI + Qwen when configured) |
+| **Benchmark schema** | Structured result to fill after AMD Developer Cloud run |
+| **Artifact ZIP** | All outputs bundled for download |
+
+## Three-agent pipeline
+
+When `QWEN_BASE_URL` and `QWEN_API_KEY` are set (pointing to a Qwen3-Coder endpoint on AMD Instinct MI300X via vLLM), three CrewAI agents collaborate:
+
+1. **CUDA Migration Auditor** — scans every file for blockers using `scan_cuda_repository` tool
+2. **ROCm Migration Engineer** — generates the patch diff using `generate_rocm_patch` tool  
+3. **Migration Report Writer** — synthesises findings into an actionable Markdown report
+
+Without those env vars the app falls back to the fully deterministic scanner + patcher (which always runs).
+
+## Run locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+App listens on `http://127.0.0.1:7860`.
+
+## Enable the full CrewAI + Qwen pipeline
+
+```bash
+# Windows
+set QWEN_BASE_URL=https://your-amd-instinct-endpoint/v1
+set QWEN_API_KEY=your-token
+set QWEN_MODEL=Qwen/Qwen3-Coder-Next-FP8
+python app.py
+
+# Linux / macOS
+QWEN_BASE_URL=https://your-amd-instinct-endpoint/v1 \
+QWEN_API_KEY=your-token \
+QWEN_MODEL=Qwen/Qwen3-Coder-Next-FP8 \
+python app.py
+```
+
+## Tests
+
+```bash
+python -m pytest tests/ -v
+```
+
+7 tests cover the scanner, pipeline, and CrewAI agent layer.
+
+## AMD Benchmark
+
+The `data/benchmark_result.json` is a transparent **pending benchmark schema** — not a fabricated result. Run the generated AMD Developer Cloud runbook (shown in the app's Runbook tab) on an AMD Instinct MI300X instance to capture real throughput, latency, and VRAM figures, then replace the file.
+
+## Deploy to Hugging Face Spaces
+
+```bash
+python scripts/deploy_to_hf.py --token hf_... --username YourHFUsername
+```
+
+## Tech stack
+
+- **AMD Developer Cloud** + **AMD Instinct MI300X** for GPU compute
+- **ROCm** — open-source GPU computing platform
+- **CrewAI** — multi-agent orchestration
+- **Qwen3-Coder-Next-FP8** — code-specialist LLM on AMD hardware
+- **vLLM (ROCm build)** — high-throughput serving
+- **Hugging Face** — model hub + Space hosting
+- **Gradio 5** — web UI

app.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+
+from rocmport.agents import CREWAI_AVAILABLE
+from rocmport.ingest import PreparedRepo, prepare_github_repo, prepare_uploaded_zip, sample_repo_path
+from rocmport.models import CATEGORY_LABELS, MigrationBundle
+from rocmport.pipeline import analyze_repository
+
+
+def _pipeline_mode_html() -> str:
+    """Return an HTML badge indicating whether the agentic CrewAI pipeline is active."""
+    if (
+        CREWAI_AVAILABLE
+        and os.getenv("QWEN_BASE_URL", "").strip()
+        and os.getenv("QWEN_API_KEY", "").strip()
+    ):
+        return (
+            "<div class='mode-badge agentic'>"
+            "🤖 <strong>CrewAI Agentic Mode</strong> &mdash; "
+            "CUDA Auditor &rarr; ROCm Engineer &rarr; Report Writer agents active "
+            "(powered by Qwen3-Coder on AMD Instinct)"
+            "</div>"
+        )
+    return (
+        "<div class='mode-badge deterministic'>"
+        "⚙️ <strong>Deterministic Mode</strong> &mdash; "
+        "Set <code>QWEN_BASE_URL</code> &amp; <code>QWEN_API_KEY</code> "
+        "to enable the full CrewAI multi-agent pipeline."
+        "</div>"
+    )
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+RUNTIME_DIR = PROJECT_ROOT / "artifacts" / "runtime"
+RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+os.environ.setdefault("ROCMPORT_TMP_DIR", str(RUNTIME_DIR))
+
+
+def run_analysis(source_mode: str, uploaded_zip: str | None, github_url: str, branch: str) -> tuple[Any, ...]:
+    try:
+        prepared = _prepare_repo(source_mode, uploaded_zip, github_url, branch)
+        output_dir = RUNTIME_DIR / f"rocmport-ui-artifacts-{uuid.uuid4().hex}"
+        output_dir.mkdir(parents=True, exist_ok=False)
+        bundle = analyze_repository(prepared.path, output_dir=output_dir, repo_name=prepared.name)
+        return _format_outputs(bundle)
+    except Exception as exc:
+        error = f"Analysis failed: {exc}"
+        empty_scores = "<div class='score-card'><h2>Analysis failed</h2><p>{}</p></div>".format(error)
+        return (
+            empty_scores,
+            [],
+            error,
+            "",
+            "",
+            "",
+            error,
+            "{}",
+            error,
+            None,
+        )
+
+
+def _prepare_repo(source_mode: str, uploaded_zip: str | None, github_url: str, branch: str) -> PreparedRepo:
+    if source_mode == "Built-in sample":
+        sample = sample_repo_path(PROJECT_ROOT)
+        return PreparedRepo(path=sample, name="cuda_first_repo")
+    if source_mode == "Uploaded ZIP":
+        if not uploaded_zip:
+            raise ValueError("Upload a ZIP file or switch to the built-in sample.")
+        return prepare_uploaded_zip(uploaded_zip)
+    if source_mode == "Public GitHub URL":
+        if not github_url.strip():
+            raise ValueError("Enter a public GitHub repository URL.")
+        return prepare_github_repo(github_url, branch.strip() or "main")
+    raise ValueError("Unknown source mode.")
+
+
+def _format_outputs(bundle: MigrationBundle) -> tuple[Any, ...]:
+    benchmark_json = json.dumps(bundle.benchmark, indent=2)
+    return (
+        _score_html(bundle),
+        bundle.findings_table(),
+        _migration_plan_markdown(bundle),
+        bundle.patch_diff,
+        bundle.dockerfile,
+        bundle.runbook,
+        _benchmark_markdown(bundle.benchmark),
+        benchmark_json,
+        bundle.report,
+        bundle.artifact_paths.get("rocmport_artifacts.zip"),
+    )
+
+
+def _score_html(bundle: MigrationBundle) -> str:
+    rows = []
+    for category, label in CATEGORY_LABELS.items():
+        before = bundle.before_score.categories[category]
+        after = bundle.after_score.categories[category]
+        rows.append(
+            f"""
+            <tr>
+              <td>{label}</td>
+              <td><div class="meter"><span style="width:{before}%"></span></div><strong>{before}</strong></td>
+              <td><div class="meter after"><span style="width:{after}%"></span></div><strong>{after}</strong></td>
+            </tr>
+            """
+        )
+    return f"""
+    <div class="score-wrap">
+      <div class="score-card">
+        <div class="score-label">Before</div>
+        <div class="score-number">{bundle.before_score.total}</div>
+      </div>
+      <div class="score-card">
+        <div class="score-label">Migration package</div>
+        <div class="score-number after-text">{bundle.after_score.total}</div>
+      </div>
+      <div class="score-card">
+        <div class="score-label">Findings</div>
+        <div class="score-number">{len(bundle.findings)}</div>
+      </div>
+    </div>
+    <table class="score-table">
+      <thead><tr><th>Category</th><th>Before</th><th>Migration package</th></tr></thead>
+      <tbody>{''.join(rows)}</tbody>
+    </table>
+    """
+
+
+def _migration_plan_markdown(bundle: MigrationBundle) -> str:
+    if not bundle.findings:
+        return "### Migration Plan\n\nNo blockers were found. Run the generated AMD Developer Cloud smoke test before submission."
+    grouped: dict[str, list[str]] = {}
+    for finding in bundle.findings:
+        grouped.setdefault(finding.category, []).append(
+            f"- `{finding.path}:{finding.line}`: {finding.suggested_fix}"
+        )
+    sections = ["### Migration Plan"]
+    for category, label in CATEGORY_LABELS.items():
+        if category not in grouped:
+            continue
+        sections.append(f"\n#### {label}\n" + "\n".join(grouped[category][:8]))
+    return "\n".join(sections)
+
+
+def _benchmark_markdown(benchmark: dict[str, Any]) -> str:
+    verified = benchmark.get("verified", False)
+    status = "Verified AMD Developer Cloud run" if verified else "Pending AMD Developer Cloud run"
+    lines = [
+        f"### {status}",
+        "",
+        f"- Hardware: `{benchmark.get('hardware', 'not captured')}`",
+        f"- ROCm: `{benchmark.get('rocm_version', 'not captured')}`",
+        f"- vLLM: `{benchmark.get('vllm_version', 'not captured')}`",
+        f"- Model: `{benchmark.get('model', 'not captured')}`",
+        f"- Throughput tokens/sec: `{benchmark.get('throughput_tokens_per_second', 'not captured')}`",
+        f"- P50 latency ms: `{benchmark.get('p50_latency_ms', 'not captured')}`",
+        f"- Peak VRAM GB: `{benchmark.get('peak_vram_gb', 'not captured')}`",
+        "",
+        benchmark.get("notes", "Run the generated AMD Developer Cloud runbook to replace this record with measured values."),
+    ]
+    return "\n".join(lines)
+
+
+CSS = """
+.gradio-container { max-width: 1280px !important; }
+.mode-badge {
+  padding: 10px 16px;
+  border-radius: 8px;
+  font-size: 14px;
+  margin-bottom: 16px;
+  border: 1px solid;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.05);
+}
+.mode-badge.agentic {
+  background: rgba(8, 127, 91, 0.1);
+  border-color: #087f5b;
+  color: var(--body-text-color);
+}
+.mode-badge.deterministic {
+  background: rgba(54, 79, 199, 0.1);
+  border-color: #748ffc;
+  color: var(--body-text-color);
+}
+.score-wrap {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 16px;
+  margin: 12px 0 24px;
+}
+.score-card {
+  border: 1px solid var(--border-color-primary);
+  border-radius: 12px;
+  padding: 20px;
+  background: var(--background-fill-secondary);
+  box-shadow: 0 4px 20px rgba(0,0,0,0.08);
+  transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+.score-card:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 8px 24px rgba(237, 28, 36, 0.15);
+}
+.score-label {
+  color: var(--body-text-color-subdued);
+  font-size: 14px;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  margin-bottom: 8px;
+  font-weight: 600;
+}
+.score-number {
+  color: var(--body-text-color);
+  font-size: 42px;
+  line-height: 1;
+  font-weight: 800;
+}
+.after-text { color: #ed1c24; } /* AMD Red */
+.score-table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 12px;
+}
+.score-table th {
+  text-transform: uppercase;
+  font-size: 12px;
+  color: var(--body-text-color-subdued);
+}
+.score-table th,
+.score-table td {
+  border-bottom: 1px solid var(--border-color-primary);
+  padding: 12px 8px;
+  text-align: left;
+}
+.meter {
+  width: calc(100% - 48px);
+  height: 10px;
+  background: var(--background-fill-primary);
+  border-radius: 5px;
+  display: inline-block;
+  vertical-align: middle;
+  margin-right: 8px;
+  overflow: hidden;
+}
+.meter span {
+  display: block;
+  height: 100%;
+  background: var(--body-text-color-subdued);
+  border-radius: 5px;
+  transition: width 1s cubic-bezier(0.4, 0, 0.2, 1);
+}
+.meter.after span { background: linear-gradient(90deg, #b80000 0%, #ed1c24 100%); }
+#findings-table table {
+  table-layout: fixed;
+}
+#findings-table th {
+  white-space: nowrap;
+}
+"""
+
+THEME = gr.themes.Soft(
+    primary_hue="red",
+    neutral_hue="zinc",
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"]
+).set(
+    button_primary_background_fill="linear-gradient(90deg, #ed1c24 0%, #b80000 100%)",
+    button_primary_background_fill_hover="linear-gradient(90deg, #ff333a 0%, #cc0000 100%)",
+    button_primary_text_color="white",
+    block_title_text_weight="600",
+    block_shadow="*shadow_drop_lg",
+    block_border_width="0px",
+    block_radius="*radius_lg"
+)
+
+
+with gr.Blocks(title="ROCmPort AI ⚡") as demo:
+    gr.Markdown("# ROCmPort AI ⚡")
+    gr.Markdown("CUDA-to-ROCm migration scanner for PyTorch, Hugging Face, and vLLM repositories.")
+    gr.HTML(_pipeline_mode_html())
+    gr.Markdown(
+        "> **How it works:** Three CrewAI agents collaborate to migrate the repository. All scoring is deterministic.\n\n"
+        "```text\n"
+        "                    [ 📁 User Repository ]\n"
+        "                              │\n"
+        "                              ▼\n"
+        "                      [ 🖥️ Gradio UI ]\n"
+        "                              │\n"
+        "                              ▼\n"
+        "                       [ ⚙️ Pipeline ]\n"
+        "                              │\n"
+        "            ┌─────────────────┴─────────────────┐\n"
+        "     (Agentic Workflow)                (Deterministic Fallback)\n"
+        "            │                                   │\n"
+        "   [ 🕵️ CUDA Auditor ]                  [ 🔍 Scanner ]\n"
+        "            │                                   │\n"
+        "   [ 🛠️ ROCm Engineer ]                 [ 🩹 Patcher ]\n"
+        "            │                                   │\n"
+        "   [ 📝 Report Writer ]                 [ 📦 Artifacts ]\n"
+        "            │                                   │\n"
+        "  (🧠 Qwen3 on MI300X)                          │\n"
+        "            │                                   │\n"
+        "            └─────────────────┬─────────────────┘\n"
+        "                              ▼\n"
+        "               [ 🎯 Final Migration Package ]\n"
+        "```"
+    )
+
+    with gr.Row():
+        source_mode = gr.Radio(
+            choices=["Built-in sample", "Uploaded ZIP", "Public GitHub URL"],
+            value="Built-in sample",
+            label="Repository source",
+        )
+        uploaded_zip = gr.File(label="Repository ZIP", type="filepath", file_types=[".zip"])
+    with gr.Row():
+        github_url = gr.Textbox(label="GitHub URL", placeholder="https://github.com/owner/repo")
+        branch = gr.Textbox(label="Branch", value="main")
+
+    analyze_button = gr.Button("Analyze repository", variant="primary")
+
+    with gr.Tabs():
+        with gr.Tab("Scan"):
+            score_html = gr.HTML(label="AMD Readiness Score")
+            findings_table = gr.Dataframe(
+                headers=["Severity", "Category", "Path", "Line", "Finding", "Suggested fix"],
+                label="Findings",
+                wrap=True,
+                column_widths=[92, 210, 260, 72, 500, 620],
+                elem_id="findings-table",
+            )
+            migration_plan = gr.Markdown(label="Migration Plan")
+        with gr.Tab("Patch"):
+            patch_diff = gr.Code(label="rocm_patch.diff", language=None, lines=20)
+            dockerfile = gr.Code(label="Dockerfile.rocm", language="dockerfile", lines=18)
+            runbook = gr.Markdown(label="AMD Developer Cloud Runbook")
+        with gr.Tab("Benchmark"):
+            benchmark_md = gr.Markdown(label="Benchmark Summary")
+            benchmark_json = gr.Code(label="benchmark_result.json", language="json", lines=18)
+        with gr.Tab("Report"):
+            report_md = gr.Markdown(label="Migration Report")
+            artifact_zip = gr.File(label="Download migration artifact bundle")
+
+    analyze_button.click(
+        fn=run_analysis,
+        inputs=[source_mode, uploaded_zip, github_url, branch],
+        outputs=[
+            score_html,
+            findings_table,
+            migration_plan,
+            patch_diff,
+            dockerfile,
+            runbook,
+            benchmark_md,
+            benchmark_json,
+            report_md,
+            artifact_zip,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    server_name = os.getenv("GRADIO_SERVER_NAME") or ("0.0.0.0" if os.getenv("SPACE_ID") else "127.0.0.1")
+    server_port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+    demo.launch(server_name=server_name, server_port=server_port, theme=THEME, css=CSS, quiet=True)

artifacts/check-scoring/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]

artifacts/check-scoring/ROCM_FEEDBACK.md

@@ -0,0 +1,17 @@
+# ROCm / AMD Developer Cloud Feedback
+
+## What worked well
+
+- The ROCm-enabled vLLM container gives developers a clear serving path for AMD Instinct GPUs.
+- AMD Developer Cloud is well aligned with hackathon demos because developers can avoid local GPU setup.
+- Qwen3-Coder-Next on AMD Instinct is a strong story for repo-level coding agents.
+
+## Friction points to document during the live run
+
+- Exact VM image, ROCm version, and Docker image should be easy to capture in benchmark logs.
+- Users need obvious examples for replacing NVIDIA container flags and monitoring commands.
+- More migration examples for common CUDA-first PyTorch repos would reduce onboarding time.
+
+## Suggested product improvement
+
+Publish a small official CUDA-to-ROCm migration checklist for PyTorch, vLLM, and Hugging Face inference projects, with copyable Docker commands for AMD Developer Cloud.

artifacts/check-scoring/ROCM_MIGRATION_COOKBOOK.md

@@ -0,0 +1,40 @@
+# ROCm Migration Cookbook
+
+## PyTorch device handling
+
+Use a runtime device abstraction instead of hardcoding `.cuda()` or `torch.device("cuda")` everywhere.
+
+```python
+import torch
+
+# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+inputs = inputs.to(device)
+```
+
+## GPU inspection
+
+Replace NVIDIA-only commands with ROCm equivalents:
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+```
+
+## Containers
+
+For vLLM serving on AMD GPUs, use the ROCm-enabled vLLM image:
+
+```bash
+docker pull vllm/vllm-openai-rocm:latest
+```
+
+Run with AMD GPU device access:
+
+```bash
+docker run --rm -it --device /dev/kfd --device /dev/dri --group-add video --ipc=host --network=host --security-opt seccomp=unconfined vllm/vllm-openai-rocm:latest
+```
+
+## Manual review cases
+
+Manual migration is still required for CUDA C++ kernels, CUDA-only binary wheels, custom Triton kernels, and libraries that ship only CUDA builds.

artifacts/check-scoring/amd_developer_cloud_runbook.md

@@ -0,0 +1,50 @@
+# AMD Developer Cloud Runbook
+
+This runbook validates `cuda_first_repo` on AMD Developer Cloud without executing untrusted code inside the ROCmPort AI Space.
+
+## 1. Create an AMD GPU VM
+
+Use an AMD Developer Cloud VM with an AMD Instinct GPU and ROCm-ready Docker support.
+
+## 2. Build the ROCm container
+
+```bash
+docker build -f Dockerfile.rocm -t rocmport-cuda_first_repo .
+```
+
+## 3. Run a smoke check
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  rocmport-cuda_first_repo
+```
+
+## 4. Run vLLM on ROCm
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  -v "$PWD:/workspace/cuda_first_repo" \
+  vllm/vllm-openai-rocm:latest \
+  vllm serve Qwen/Qwen3-Coder-Next-FP8 --tensor-parallel-size 1
+```
+
+## 5. Capture benchmark metadata
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+python scripts/collect_benchmark_result.py --output benchmark_result.json
+```
+
+Replace `data/benchmark_result.json` with the captured result before final submission.

artifacts/check-scoring/benchmark_result.json

@@ -0,0 +1,20 @@
+{
+  "verified": false,
+  "status": "pending_external_amd_developer_cloud_run",
+  "hardware": "AMD Instinct MI300X or compatible AMD Developer Cloud instance",
+  "rocm_version": "capture with rocminfo or container metadata",
+  "vllm_version": "capture with python -m vllm --version",
+  "model": "Qwen/Qwen3-Coder-Next-FP8",
+  "prompt_config": {
+    "input_tokens": 512,
+    "output_tokens": 256,
+    "concurrency": 8,
+    "requests": 64
+  },
+  "throughput_tokens_per_second": null,
+  "p50_latency_ms": null,
+  "p95_latency_ms": null,
+  "peak_vram_gb": null,
+  "log_excerpt": "Replace this record after running the generated AMD Developer Cloud runbook.",
+  "notes": "This file is a transparent benchmark schema, not a fabricated result. The Space displays it as pending until measured values are captured on AMD Developer Cloud."
+}

artifacts/check-scoring/migration_report.md

@@ -0,0 +1,47 @@
+# ROCmPort AI Migration Report: cuda_first_repo
+
+## AMD Readiness Score
+
+- Before deterministic fixes: 51/100
+- Migration package generated: 90/100
+- This score means ROCm migration artifacts were generated and are ready for AMD Developer Cloud validation; it is not a production certification.
+
+| Category | Before | Migration package |
+| --- | ---: | ---: |
+| Code portability | 0 | 86 |
+| Environment readiness | 0 | 86 |
+| Serving readiness | 90 | 98 |
+| Benchmark readiness | 65 | 85 |
+| Deployment readiness | 100 | 95 |
+
+## Findings
+
+| Severity | Category | Location | Finding | Suggested fix |
+| --- | --- | --- | --- | --- |
+| high | Benchmark readiness | `benchmarks/benchmark.py:6` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Environment readiness | `Dockerfile:1` | Dockerfile uses an NVIDIA CUDA base image. | Use vllm/vllm-openai-rocm:latest for vLLM serving or rocm/pytorch:latest for PyTorch workloads. |
+| medium | Environment readiness | `Dockerfile:8` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Code portability | `infer.py:6` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `infer.py:11` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `infer.py:12` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| low | Code portability | `infer.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| medium | Environment readiness | `scripts/serve_vllm.sh:4` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Environment readiness | `scripts/serve_vllm.sh:5` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `scripts/serve_vllm.sh:6` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+
+## Generated Artifacts
+
+- `rocm_patch.diff` contains deterministic MVP fixes.
+- `Dockerfile.rocm` uses the ROCm-enabled vLLM container.
+- `amd_developer_cloud_runbook.md` documents the validation path.
+- `benchmark_result.json` records the AMD benchmark schema and status.
+
+## Qwen Agent Notes
+
+Qwen endpoint was not configured. The report uses deterministic scanner output only.
+
+## Remaining Risks
+
+- CUDA C++ kernels, custom Triton kernels, and CUDA-only binary dependencies require manual review.
+- Uploaded repositories are not executed inside the Space; live validation belongs on AMD Developer Cloud.
+- ROCm performance depends on model, batch shape, vLLM version, ROCm version, and GPU instance configuration.

artifacts/check-scoring/rocm_patch.diff

@@ -0,0 +1,50 @@
+--- a/Dockerfile
++++ b/Dockerfile
+@@ -1,10 +1,10 @@
+-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
++FROM vllm/vllm-openai-rocm:latest
+ 
+ WORKDIR /app
+ COPY requirements.txt .
+ RUN pip install --no-cache-dir -r requirements.txt
+ COPY . .
+ 
+-ENV NVIDIA_VISIBLE_DEVICES=all
++ENV HIP_VISIBLE_DEVICES=all
+ 
+ CMD ["python", "infer.py"]
+--- a/infer.py
++++ b/infer.py
+@@ -1,15 +1,18 @@
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+-device = torch.device("cuda")
++device = _rocmport_device
+ 
+ 
+ def main():
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()
+-    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to("cuda")
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)
++    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to(_rocmport_device)
+     with torch.no_grad():
+         outputs = model.generate(**inputs, max_new_tokens=64)
+     print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+--- a/scripts/serve_vllm.sh
++++ b/scripts/serve_vllm.sh
+@@ -1,6 +1,6 @@
+ #!/usr/bin/env bash
+ set -euo pipefail
+ 
+-export CUDA_VISIBLE_DEVICES=0
+-nvidia-smi
++export HIP_VISIBLE_DEVICES=0
++rocm-smi
+ vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 1

artifacts/check-scoring/rocmport_artifacts.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f46889d5d26e62603bf801b51a98a18d203ef648bf52009a0be2777c57dc359a
+size 5349

artifacts/check/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]

artifacts/check/ROCM_FEEDBACK.md

@@ -0,0 +1,17 @@
+# ROCm / AMD Developer Cloud Feedback
+
+## What worked well
+
+- The ROCm-enabled vLLM container gives developers a clear serving path for AMD Instinct GPUs.
+- AMD Developer Cloud is well aligned with hackathon demos because developers can avoid local GPU setup.
+- Qwen3-Coder-Next on AMD Instinct is a strong story for repo-level coding agents.
+
+## Friction points to document during the live run
+
+- Exact VM image, ROCm version, and Docker image should be easy to capture in benchmark logs.
+- Users need obvious examples for replacing NVIDIA container flags and monitoring commands.
+- More migration examples for common CUDA-first PyTorch repos would reduce onboarding time.
+
+## Suggested product improvement
+
+Publish a small official CUDA-to-ROCm migration checklist for PyTorch, vLLM, and Hugging Face inference projects, with copyable Docker commands for AMD Developer Cloud.

artifacts/check/ROCM_MIGRATION_COOKBOOK.md

@@ -0,0 +1,40 @@
+# ROCm Migration Cookbook
+
+## PyTorch device handling
+
+Use a runtime device abstraction instead of hardcoding `.cuda()` or `torch.device("cuda")` everywhere.
+
+```python
+import torch
+
+# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+inputs = inputs.to(device)
+```
+
+## GPU inspection
+
+Replace NVIDIA-only commands with ROCm equivalents:
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+```
+
+## Containers
+
+For vLLM serving on AMD GPUs, use the ROCm-enabled vLLM image:
+
+```bash
+docker pull vllm/vllm-openai-rocm:latest
+```
+
+Run with AMD GPU device access:
+
+```bash
+docker run --rm -it --device /dev/kfd --device /dev/dri --group-add video --ipc=host --network=host --security-opt seccomp=unconfined vllm/vllm-openai-rocm:latest
+```
+
+## Manual review cases
+
+Manual migration is still required for CUDA C++ kernels, CUDA-only binary wheels, custom Triton kernels, and libraries that ship only CUDA builds.

artifacts/check/amd_developer_cloud_runbook.md

@@ -0,0 +1,50 @@
+# AMD Developer Cloud Runbook
+
+This runbook validates `cuda_first_repo` on AMD Developer Cloud without executing untrusted code inside the ROCmPort AI Space.
+
+## 1. Create an AMD GPU VM
+
+Use an AMD Developer Cloud VM with an AMD Instinct GPU and ROCm-ready Docker support.
+
+## 2. Build the ROCm container
+
+```bash
+docker build -f Dockerfile.rocm -t rocmport-cuda_first_repo .
+```
+
+## 3. Run a smoke check
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  rocmport-cuda_first_repo
+```
+
+## 4. Run vLLM on ROCm
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  -v "$PWD:/workspace/cuda_first_repo" \
+  vllm/vllm-openai-rocm:latest \
+  vllm serve Qwen/Qwen3-Coder-Next-FP8 --tensor-parallel-size 1
+```
+
+## 5. Capture benchmark metadata
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+python scripts/collect_benchmark_result.py --output benchmark_result.json
+```
+
+Replace `data/benchmark_result.json` with the captured result before final submission.

artifacts/check/benchmark_result.json

@@ -0,0 +1,20 @@
+{
+  "verified": false,
+  "status": "pending_external_amd_developer_cloud_run",
+  "hardware": "AMD Instinct MI300X or compatible AMD Developer Cloud instance",
+  "rocm_version": "capture with rocminfo or container metadata",
+  "vllm_version": "capture with python -m vllm --version",
+  "model": "Qwen/Qwen3-Coder-Next-FP8",
+  "prompt_config": {
+    "input_tokens": 512,
+    "output_tokens": 256,
+    "concurrency": 8,
+    "requests": 64
+  },
+  "throughput_tokens_per_second": null,
+  "p50_latency_ms": null,
+  "p95_latency_ms": null,
+  "peak_vram_gb": null,
+  "log_excerpt": "Replace this record after running the generated AMD Developer Cloud runbook.",
+  "notes": "This file is a transparent benchmark schema, not a fabricated result. The Space displays it as pending until measured values are captured on AMD Developer Cloud."
+}

artifacts/check/migration_report.md

@@ -0,0 +1,45 @@
+# ROCmPort AI Migration Report: cuda_first_repo
+
+## AMD Readiness Score
+
+- Before deterministic fixes: 53/100
+- After deterministic fixes: 100/100
+
+| Category | Before | After |
+| --- | ---: | ---: |
+| Code portability | 0 | 100 |
+| Environment readiness | 8 | 100 |
+| Serving readiness | 90 | 100 |
+| Benchmark readiness | 65 | 100 |
+| Deployment readiness | 100 | 100 |
+
+## Findings
+
+| Severity | Category | Location | Finding | Suggested fix |
+| --- | --- | --- | --- | --- |
+| high | Benchmark readiness | `benchmarks/benchmark.py:6` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Environment readiness | `Dockerfile:1` | Dockerfile uses an NVIDIA CUDA base image. | Use vllm/vllm-openai-rocm:latest for vLLM serving or rocm/pytorch:latest for PyTorch workloads. |
+| medium | Environment readiness | `Dockerfile:8` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Code portability | `infer.py:6` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `infer.py:11` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `infer.py:12` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| low | Code portability | `infer.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| high | Environment readiness | `scripts/serve_vllm.sh:5` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `scripts/serve_vllm.sh:6` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+
+## Generated Artifacts
+
+- `rocm_patch.diff` contains deterministic MVP fixes.
+- `Dockerfile.rocm` uses the ROCm-enabled vLLM container.
+- `amd_developer_cloud_runbook.md` documents the validation path.
+- `benchmark_result.json` records the AMD benchmark schema and status.
+
+## Qwen Agent Notes
+
+Qwen endpoint was not configured. The report uses deterministic scanner output only.
+
+## Remaining Risks
+
+- CUDA C++ kernels, custom Triton kernels, and CUDA-only binary dependencies require manual review.
+- Uploaded repositories are not executed inside the Space; live validation belongs on AMD Developer Cloud.
+- ROCm performance depends on model, batch shape, vLLM version, ROCm version, and GPU instance configuration.

artifacts/check/rocm_patch.diff

@@ -0,0 +1,48 @@
+--- a/Dockerfile
++++ b/Dockerfile
+@@ -1,10 +1,10 @@
+-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
++FROM vllm/vllm-openai-rocm:latest
+ 
+ WORKDIR /app
+ COPY requirements.txt .
+ RUN pip install --no-cache-dir -r requirements.txt
+ COPY . .
+ 
+-ENV NVIDIA_VISIBLE_DEVICES=all
++ENV HIP_VISIBLE_DEVICES=all
+ 
+ CMD ["python", "infer.py"]
+--- a/infer.py
++++ b/infer.py
+@@ -1,15 +1,18 @@
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+-device = torch.device("cuda")
++device = _rocmport_device
+ 
+ 
+ def main():
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()
+-    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to("cuda")
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)
++    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to(_rocmport_device)
+     with torch.no_grad():
+         outputs = model.generate(**inputs, max_new_tokens=64)
+     print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+--- a/scripts/serve_vllm.sh
++++ b/scripts/serve_vllm.sh
+@@ -2,5 +2,5 @@
+ set -euo pipefail
+ 
+ export CUDA_VISIBLE_DEVICES=0
+-nvidia-smi
++rocm-smi
+ vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 1

artifacts/check/rocmport_artifacts.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a416cb1bb90125df6f5b63bc41032aa6543b74b8b5b2a431761cde14b5a52d5b
+size 5229

artifacts/check2/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]

artifacts/check2/ROCM_FEEDBACK.md

@@ -0,0 +1,17 @@
+# ROCm / AMD Developer Cloud Feedback
+
+## What worked well
+
+- The ROCm-enabled vLLM container gives developers a clear serving path for AMD Instinct GPUs.
+- AMD Developer Cloud is well aligned with hackathon demos because developers can avoid local GPU setup.
+- Qwen3-Coder-Next on AMD Instinct is a strong story for repo-level coding agents.
+
+## Friction points to document during the live run
+
+- Exact VM image, ROCm version, and Docker image should be easy to capture in benchmark logs.
+- Users need obvious examples for replacing NVIDIA container flags and monitoring commands.
+- More migration examples for common CUDA-first PyTorch repos would reduce onboarding time.
+
+## Suggested product improvement
+
+Publish a small official CUDA-to-ROCm migration checklist for PyTorch, vLLM, and Hugging Face inference projects, with copyable Docker commands for AMD Developer Cloud.

artifacts/check2/ROCM_MIGRATION_COOKBOOK.md

@@ -0,0 +1,40 @@
+# ROCm Migration Cookbook
+
+## PyTorch device handling
+
+Use a runtime device abstraction instead of hardcoding `.cuda()` or `torch.device("cuda")` everywhere.
+
+```python
+import torch
+
+# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+inputs = inputs.to(device)
+```
+
+## GPU inspection
+
+Replace NVIDIA-only commands with ROCm equivalents:
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+```
+
+## Containers
+
+For vLLM serving on AMD GPUs, use the ROCm-enabled vLLM image:
+
+```bash
+docker pull vllm/vllm-openai-rocm:latest
+```
+
+Run with AMD GPU device access:
+
+```bash
+docker run --rm -it --device /dev/kfd --device /dev/dri --group-add video --ipc=host --network=host --security-opt seccomp=unconfined vllm/vllm-openai-rocm:latest
+```
+
+## Manual review cases
+
+Manual migration is still required for CUDA C++ kernels, CUDA-only binary wheels, custom Triton kernels, and libraries that ship only CUDA builds.

artifacts/check2/amd_developer_cloud_runbook.md

@@ -0,0 +1,50 @@
+# AMD Developer Cloud Runbook
+
+This runbook validates `cuda_first_repo` on AMD Developer Cloud without executing untrusted code inside the ROCmPort AI Space.
+
+## 1. Create an AMD GPU VM
+
+Use an AMD Developer Cloud VM with an AMD Instinct GPU and ROCm-ready Docker support.
+
+## 2. Build the ROCm container
+
+```bash
+docker build -f Dockerfile.rocm -t rocmport-cuda_first_repo .
+```
+
+## 3. Run a smoke check
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  rocmport-cuda_first_repo
+```
+
+## 4. Run vLLM on ROCm
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  -v "$PWD:/workspace/cuda_first_repo" \
+  vllm/vllm-openai-rocm:latest \
+  vllm serve Qwen/Qwen3-Coder-Next-FP8 --tensor-parallel-size 1
+```
+
+## 5. Capture benchmark metadata
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+python scripts/collect_benchmark_result.py --output benchmark_result.json
+```
+
+Replace `data/benchmark_result.json` with the captured result before final submission.

artifacts/check2/benchmark_result.json

@@ -0,0 +1,20 @@
+{
+  "verified": false,
+  "status": "pending_external_amd_developer_cloud_run",
+  "hardware": "AMD Instinct MI300X or compatible AMD Developer Cloud instance",
+  "rocm_version": "capture with rocminfo or container metadata",
+  "vllm_version": "capture with python -m vllm --version",
+  "model": "Qwen/Qwen3-Coder-Next-FP8",
+  "prompt_config": {
+    "input_tokens": 512,
+    "output_tokens": 256,
+    "concurrency": 8,
+    "requests": 64
+  },
+  "throughput_tokens_per_second": null,
+  "p50_latency_ms": null,
+  "p95_latency_ms": null,
+  "peak_vram_gb": null,
+  "log_excerpt": "Replace this record after running the generated AMD Developer Cloud runbook.",
+  "notes": "This file is a transparent benchmark schema, not a fabricated result. The Space displays it as pending until measured values are captured on AMD Developer Cloud."
+}

artifacts/check2/migration_report.md

@@ -0,0 +1,46 @@
+# ROCmPort AI Migration Report: cuda_first_repo
+
+## AMD Readiness Score
+
+- Before deterministic fixes: 51/100
+- After deterministic fixes: 100/100
+
+| Category | Before | After |
+| --- | ---: | ---: |
+| Code portability | 0 | 100 |
+| Environment readiness | 0 | 100 |
+| Serving readiness | 90 | 100 |
+| Benchmark readiness | 65 | 100 |
+| Deployment readiness | 100 | 100 |
+
+## Findings
+
+| Severity | Category | Location | Finding | Suggested fix |
+| --- | --- | --- | --- | --- |
+| high | Benchmark readiness | `benchmarks/benchmark.py:6` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Environment readiness | `Dockerfile:1` | Dockerfile uses an NVIDIA CUDA base image. | Use vllm/vllm-openai-rocm:latest for vLLM serving or rocm/pytorch:latest for PyTorch workloads. |
+| medium | Environment readiness | `Dockerfile:8` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Code portability | `infer.py:6` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `infer.py:11` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `infer.py:12` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| low | Code portability | `infer.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| medium | Environment readiness | `scripts/serve_vllm.sh:4` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Environment readiness | `scripts/serve_vllm.sh:5` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `scripts/serve_vllm.sh:6` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+
+## Generated Artifacts
+
+- `rocm_patch.diff` contains deterministic MVP fixes.
+- `Dockerfile.rocm` uses the ROCm-enabled vLLM container.
+- `amd_developer_cloud_runbook.md` documents the validation path.
+- `benchmark_result.json` records the AMD benchmark schema and status.
+
+## Qwen Agent Notes
+
+Qwen endpoint was not configured. The report uses deterministic scanner output only.
+
+## Remaining Risks
+
+- CUDA C++ kernels, custom Triton kernels, and CUDA-only binary dependencies require manual review.
+- Uploaded repositories are not executed inside the Space; live validation belongs on AMD Developer Cloud.
+- ROCm performance depends on model, batch shape, vLLM version, ROCm version, and GPU instance configuration.

artifacts/check2/rocm_patch.diff

@@ -0,0 +1,50 @@
+--- a/Dockerfile
++++ b/Dockerfile
+@@ -1,10 +1,10 @@
+-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
++FROM vllm/vllm-openai-rocm:latest
+ 
+ WORKDIR /app
+ COPY requirements.txt .
+ RUN pip install --no-cache-dir -r requirements.txt
+ COPY . .
+ 
+-ENV NVIDIA_VISIBLE_DEVICES=all
++ENV HIP_VISIBLE_DEVICES=all
+ 
+ CMD ["python", "infer.py"]
+--- a/infer.py
++++ b/infer.py
+@@ -1,15 +1,18 @@
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+-device = torch.device("cuda")
++device = _rocmport_device
+ 
+ 
+ def main():
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()
+-    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to("cuda")
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)
++    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to(_rocmport_device)
+     with torch.no_grad():
+         outputs = model.generate(**inputs, max_new_tokens=64)
+     print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+--- a/scripts/serve_vllm.sh
++++ b/scripts/serve_vllm.sh
+@@ -1,6 +1,6 @@
+ #!/usr/bin/env bash
+ set -euo pipefail
+ 
+-export CUDA_VISIBLE_DEVICES=0
+-nvidia-smi
++export HIP_VISIBLE_DEVICES=0
++rocm-smi
+ vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 1

artifacts/check2/rocmport_artifacts.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b346f1ca8119e31fb879012c85fb6a20663459f9266944b277e346d3d8c89fa
+size 5275

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/ROCM_FEEDBACK.md

@@ -0,0 +1,17 @@
+# ROCm / AMD Developer Cloud Feedback
+
+## What worked well
+
+- The ROCm-enabled vLLM container gives developers a clear serving path for AMD Instinct GPUs.
+- AMD Developer Cloud is well aligned with hackathon demos because developers can avoid local GPU setup.
+- Qwen3-Coder-Next on AMD Instinct is a strong story for repo-level coding agents.
+
+## Friction points to document during the live run
+
+- Exact VM image, ROCm version, and Docker image should be easy to capture in benchmark logs.
+- Users need obvious examples for replacing NVIDIA container flags and monitoring commands.
+- More migration examples for common CUDA-first PyTorch repos would reduce onboarding time.
+
+## Suggested product improvement
+
+Publish a small official CUDA-to-ROCm migration checklist for PyTorch, vLLM, and Hugging Face inference projects, with copyable Docker commands for AMD Developer Cloud.

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/ROCM_MIGRATION_COOKBOOK.md

@@ -0,0 +1,40 @@
+# ROCm Migration Cookbook
+
+## PyTorch device handling
+
+Use a runtime device abstraction instead of hardcoding `.cuda()` or `torch.device("cuda")` everywhere.
+
+```python
+import torch
+
+# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+inputs = inputs.to(device)
+```
+
+## GPU inspection
+
+Replace NVIDIA-only commands with ROCm equivalents:
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+```
+
+## Containers
+
+For vLLM serving on AMD GPUs, use the ROCm-enabled vLLM image:
+
+```bash
+docker pull vllm/vllm-openai-rocm:latest
+```
+
+Run with AMD GPU device access:
+
+```bash
+docker run --rm -it --device /dev/kfd --device /dev/dri --group-add video --ipc=host --network=host --security-opt seccomp=unconfined vllm/vllm-openai-rocm:latest
+```
+
+## Manual review cases
+
+Manual migration is still required for CUDA C++ kernels, CUDA-only binary wheels, custom Triton kernels, and libraries that ship only CUDA builds.

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/amd_developer_cloud_runbook.md

@@ -0,0 +1,50 @@
+# AMD Developer Cloud Runbook
+
+This runbook validates `cuda_first_repo` on AMD Developer Cloud without executing untrusted code inside the ROCmPort AI Space.
+
+## 1. Create an AMD GPU VM
+
+Use an AMD Developer Cloud VM with an AMD Instinct GPU and ROCm-ready Docker support.
+
+## 2. Build the ROCm container
+
+```bash
+docker build -f Dockerfile.rocm -t rocmport-cuda_first_repo .
+```
+
+## 3. Run a smoke check
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  rocmport-cuda_first_repo
+```
+
+## 4. Run vLLM on ROCm
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  -v "$PWD:/workspace/cuda_first_repo" \
+  vllm/vllm-openai-rocm:latest \
+  vllm serve Qwen/Qwen3-Coder-Next-FP8 --tensor-parallel-size 1
+```
+
+## 5. Capture benchmark metadata
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+python scripts/collect_benchmark_result.py --output benchmark_result.json
+```
+
+Replace `data/benchmark_result.json` with the captured result before final submission.

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/benchmark_result.json

@@ -0,0 +1,20 @@
+{
+  "verified": false,
+  "status": "pending_external_amd_developer_cloud_run",
+  "hardware": "AMD Instinct MI300X or compatible AMD Developer Cloud instance",
+  "rocm_version": "capture with rocminfo or container metadata",
+  "vllm_version": "capture with python -m vllm --version",
+  "model": "Qwen/Qwen3-Coder-Next-FP8",
+  "prompt_config": {
+    "input_tokens": 512,
+    "output_tokens": 256,
+    "concurrency": 8,
+    "requests": 64
+  },
+  "throughput_tokens_per_second": null,
+  "p50_latency_ms": null,
+  "p95_latency_ms": null,
+  "peak_vram_gb": null,
+  "log_excerpt": "Replace this record after running the generated AMD Developer Cloud runbook.",
+  "notes": "This file is a transparent benchmark schema, not a fabricated result. The Space displays it as pending until measured values are captured on AMD Developer Cloud."
+}

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/migration_report.md

@@ -0,0 +1,71 @@
+# ROCmPort AI Migration Report: cuda_first_repo
+
+## AMD Readiness Score
+
+- Before deterministic fixes: 42/100
+- Migration package generated: 67/100
+- This score means ROCm migration artifacts were generated and are ready for AMD Developer Cloud validation; it is not a production certification.
+
+| Category | Before | Migration package |
+| --- | ---: | ---: |
+| Code portability | 0 | 46 |
+| Environment readiness | 0 | 0 |
+| Serving readiness | 80 | 96 |
+| Benchmark readiness | 30 | 92 |
+| Deployment readiness | 100 | 100 |
+
+## Findings
+
+| Severity | Category | Location | Finding | Suggested fix |
+| --- | --- | --- | --- | --- |
+| medium | Environment readiness | `benchmarks/benchmark.py:13` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Benchmark readiness | `benchmarks/benchmark.py:22` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Benchmark readiness | `benchmarks/benchmark.py:24` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Code portability | `benchmarks/benchmark.py:36` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `benchmarks/benchmark.py:38` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `benchmarks/benchmark.py:41` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| medium | Environment readiness | `docker-compose.yml:6` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| medium | Environment readiness | `docker-compose.yml:7` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| medium | Environment readiness | `docker-compose.yml:8` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| medium | Environment readiness | `docker-compose.yml:24` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| medium | Environment readiness | `docker-compose.yml:25` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Environment readiness | `docker-compose.yml:29` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `docker-compose.yml:30` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+| high | Environment readiness | `Dockerfile:1` | Dockerfile uses an NVIDIA CUDA base image. | Use vllm/vllm-openai-rocm:latest for vLLM serving or rocm/pytorch:latest for PyTorch workloads. |
+| medium | Environment readiness | `Dockerfile:8` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Code portability | `infer.py:6` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `infer.py:11` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `infer.py:12` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| low | Code portability | `infer.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| medium | Environment readiness | `requirements.txt:4` | Dependency references a CUDA-specific package. | Replace CUDA-specific wheels with ROCm-compatible PyTorch or library builds. |
+| medium | Environment readiness | `requirements.txt:5` | Dependency references a CUDA-specific package. | Replace CUDA-specific wheels with ROCm-compatible PyTorch or library builds. |
+| medium | Environment readiness | `scripts/serve_vllm.sh:4` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Environment readiness | `scripts/serve_vllm.sh:5` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `scripts/serve_vllm.sh:6` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+| medium | Environment readiness | `scripts/train.py:13` | CUDA_VISIBLE_DEVICES is used for GPU selection. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| medium | Environment readiness | `scripts/train.py:14` | CUDA toolkit path environment variable found. | Remove CUDA toolkit path assumptions or replace with ROCm installation paths when required. |
+| high | Code portability | `scripts/train.py:18` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| low | Code portability | `scripts/train.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| high | Code portability | `scripts/train.py:30` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `scripts/train.py:35` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| high | Code portability | `scripts/train.py:36` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| high | Code portability | `scripts/train.py:44` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `scripts/train.py:45` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| low | Code portability | `scripts/train.py:59` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+
+## Generated Artifacts
+
+- `rocm_patch.diff` contains deterministic MVP fixes.
+- `Dockerfile.rocm` uses the ROCm-enabled vLLM container.
+- `amd_developer_cloud_runbook.md` documents the validation path.
+- `benchmark_result.json` records the AMD benchmark schema and status.
+
+## Qwen Agent Notes
+
+Qwen endpoint was not configured. The report uses deterministic scanner output only.
+
+## Remaining Risks
+
+- CUDA C++ kernels, custom Triton kernels, and CUDA-only binary dependencies require manual review.
+- Uploaded repositories are not executed inside the Space; live validation belongs on AMD Developer Cloud.
+- ROCm performance depends on model, batch shape, vLLM version, ROCm version, and GPU instance configuration.

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/rocm_patch.diff

@@ -0,0 +1,155 @@
+--- a/benchmarks/benchmark.py
++++ b/benchmarks/benchmark.py
+@@ -9,6 +9,9 @@
+ import json
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
++
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ 
+ os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"  # should → HIP_VISIBLE_DEVICES
+ 
+@@ -33,12 +36,12 @@
+     hw = gpu_info()
+     print("GPU info:", hw)
+ 
+-    device = torch.device("cuda")          # hardcoded CUDA device
++    device = _rocmport_device          # hardcoded CUDA device
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()   # .cuda()
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)   # .to(_rocmport_device)
+     model.eval()
+ 
+-    inputs = tokenizer(PROMPT, return_tensors="pt").to("cuda")       # .to("cuda")
++    inputs = tokenizer(PROMPT, return_tensors="pt").to(_rocmport_device)       # .to(_rocmport_device)
+ 
+     # Warm-up
+     with torch.no_grad():
+--- a/docker-compose.yml
++++ b/docker-compose.yml
+@@ -3,9 +3,9 @@
+   inference:
+     image: nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
+     environment:
+-      - NVIDIA_VISIBLE_DEVICES=all
+-      - NVIDIA_DRIVER_CAPABILITIES=compute,utility
+-      - CUDA_VISIBLE_DEVICES=0
++      - HIP_VISIBLE_DEVICES=all
++      - ROCM_VISIBLE_DEVICES=compute,utility
++      - HIP_VISIBLE_DEVICES=0
+     deploy:
+       resources:
+         reservations:
+@@ -21,10 +21,10 @@
+   vllm_server:
+     image: nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
+     environment:
+-      - NVIDIA_VISIBLE_DEVICES=0,1
+-      - CUDA_VISIBLE_DEVICES=0,1
++      - HIP_VISIBLE_DEVICES=0,1
++      - HIP_VISIBLE_DEVICES=0,1
+     ports:
+       - "8000:8000"
+     command: >
+-      bash -c "nvidia-smi && pip install vllm &&
++      bash -c "rocm-smi && pip install vllm &&
+                vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 2"
+--- a/Dockerfile
++++ b/Dockerfile
+@@ -1,10 +1,10 @@
+-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
++FROM vllm/vllm-openai-rocm:latest
+ 
+ WORKDIR /app
+ COPY requirements.txt .
+ RUN pip install --no-cache-dir -r requirements.txt
+ COPY . .
+ 
+-ENV NVIDIA_VISIBLE_DEVICES=all
++ENV HIP_VISIBLE_DEVICES=all
+ 
+ CMD ["python", "infer.py"]
+--- a/infer.py
++++ b/infer.py
+@@ -1,15 +1,18 @@
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+-device = torch.device("cuda")
++device = _rocmport_device
+ 
+ 
+ def main():
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()
+-    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to("cuda")
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)
++    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to(_rocmport_device)
+     with torch.no_grad():
+         outputs = model.generate(**inputs, max_new_tokens=64)
+     print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+--- a/scripts/serve_vllm.sh
++++ b/scripts/serve_vllm.sh
+@@ -1,6 +1,6 @@
+ #!/usr/bin/env bash
+ set -euo pipefail
+ 
+-export CUDA_VISIBLE_DEVICES=0
+-nvidia-smi
++export HIP_VISIBLE_DEVICES=0
++rocm-smi
+ vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 1
+--- a/scripts/train.py
++++ b/scripts/train.py
+@@ -9,13 +9,16 @@
+ from torch.utils.data import DataLoader, TensorDataset
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ # ── CUDA-specific patterns that ROCmPort will flag ─────────────────────────
+ os.environ["CUDA_VISIBLE_DEVICES"] = "0"          # should → HIP_VISIBLE_DEVICES
+ os.environ["CUDA_HOME"] = "/usr/local/cuda"        # should be removed / replaced
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+ 
+-device = torch.device("cuda")                      # hardcoded CUDA device
++device = _rocmport_device                      # hardcoded CUDA device
+ print("CUDA available:", torch.cuda.is_available())
+ 
+ 
+@@ -27,13 +30,13 @@
+ 
+ def train(epochs: int = 3, lr: float = 2e-5):
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()   # .cuda() call
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)   # .to(_rocmport_device) call
+ 
+     optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+ 
+     ids, labels = get_dummy_batch()
+-    ids = ids.to("cuda")        # hardcoded "cuda" string
+-    labels = labels.to("cuda")  # hardcoded "cuda" string
++    ids = ids.to(_rocmport_device)        # hardcoded "cuda" string
++    labels = labels.to(_rocmport_device)  # hardcoded "cuda" string
+ 
+     dataset = TensorDataset(ids, labels)
+     loader = DataLoader(dataset, batch_size=2)
+@@ -41,8 +44,8 @@
+     model.train()
+     for epoch in range(epochs):
+         for batch_ids, batch_labels in loader:
+-            batch_ids = batch_ids.cuda()    # another .cuda() call
+-            batch_labels = batch_labels.cuda()
++            batch_ids = batch_ids.to(_rocmport_device)    # another .to(_rocmport_device) call
++            batch_labels = batch_labels.to(_rocmport_device)
+             outputs = model(input_ids=batch_ids, labels=batch_labels)
+             loss = outputs.loss
+             loss.backward()

artifacts/runtime/rocmport-ui-artifacts-2394ce307a044fcfa1edda12f4f304cb/rocmport_artifacts.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:232d4aa956fe47770fd6f443c73af4ba5f3bfbc5cc73c997f9fc77538bf7c918
+size 6603

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/ROCM_FEEDBACK.md

@@ -0,0 +1,17 @@
+# ROCm / AMD Developer Cloud Feedback
+
+## What worked well
+
+- The ROCm-enabled vLLM container gives developers a clear serving path for AMD Instinct GPUs.
+- AMD Developer Cloud is well aligned with hackathon demos because developers can avoid local GPU setup.
+- Qwen3-Coder-Next on AMD Instinct is a strong story for repo-level coding agents.
+
+## Friction points to document during the live run
+
+- Exact VM image, ROCm version, and Docker image should be easy to capture in benchmark logs.
+- Users need obvious examples for replacing NVIDIA container flags and monitoring commands.
+- More migration examples for common CUDA-first PyTorch repos would reduce onboarding time.
+
+## Suggested product improvement
+
+Publish a small official CUDA-to-ROCm migration checklist for PyTorch, vLLM, and Hugging Face inference projects, with copyable Docker commands for AMD Developer Cloud.

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/ROCM_MIGRATION_COOKBOOK.md

@@ -0,0 +1,40 @@
+# ROCm Migration Cookbook
+
+## PyTorch device handling
+
+Use a runtime device abstraction instead of hardcoding `.cuda()` or `torch.device("cuda")` everywhere.
+
+```python
+import torch
+
+# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+inputs = inputs.to(device)
+```
+
+## GPU inspection
+
+Replace NVIDIA-only commands with ROCm equivalents:
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+```
+
+## Containers
+
+For vLLM serving on AMD GPUs, use the ROCm-enabled vLLM image:
+
+```bash
+docker pull vllm/vllm-openai-rocm:latest
+```
+
+Run with AMD GPU device access:
+
+```bash
+docker run --rm -it --device /dev/kfd --device /dev/dri --group-add video --ipc=host --network=host --security-opt seccomp=unconfined vllm/vllm-openai-rocm:latest
+```
+
+## Manual review cases
+
+Manual migration is still required for CUDA C++ kernels, CUDA-only binary wheels, custom Triton kernels, and libraries that ship only CUDA builds.

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/amd_developer_cloud_runbook.md

@@ -0,0 +1,50 @@
+# AMD Developer Cloud Runbook
+
+This runbook validates `cuda_first_repo` on AMD Developer Cloud without executing untrusted code inside the ROCmPort AI Space.
+
+## 1. Create an AMD GPU VM
+
+Use an AMD Developer Cloud VM with an AMD Instinct GPU and ROCm-ready Docker support.
+
+## 2. Build the ROCm container
+
+```bash
+docker build -f Dockerfile.rocm -t rocmport-cuda_first_repo .
+```
+
+## 3. Run a smoke check
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  rocmport-cuda_first_repo
+```
+
+## 4. Run vLLM on ROCm
+
+```bash
+docker run --rm -it \
+  --device /dev/kfd \
+  --device /dev/dri \
+  --group-add video \
+  --ipc=host \
+  --network=host \
+  --security-opt seccomp=unconfined \
+  -v "$PWD:/workspace/cuda_first_repo" \
+  vllm/vllm-openai-rocm:latest \
+  vllm serve Qwen/Qwen3-Coder-Next-FP8 --tensor-parallel-size 1
+```
+
+## 5. Capture benchmark metadata
+
+```bash
+rocm-smi --showproductname --showmeminfo vram --showuse
+python scripts/collect_benchmark_result.py --output benchmark_result.json
+```
+
+Replace `data/benchmark_result.json` with the captured result before final submission.

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/benchmark_result.json

@@ -0,0 +1,20 @@
+{
+  "verified": false,
+  "status": "pending_external_amd_developer_cloud_run",
+  "hardware": "AMD Instinct MI300X or compatible AMD Developer Cloud instance",
+  "rocm_version": "capture with rocminfo or container metadata",
+  "vllm_version": "capture with python -m vllm --version",
+  "model": "Qwen/Qwen3-Coder-Next-FP8",
+  "prompt_config": {
+    "input_tokens": 512,
+    "output_tokens": 256,
+    "concurrency": 8,
+    "requests": 64
+  },
+  "throughput_tokens_per_second": null,
+  "p50_latency_ms": null,
+  "p95_latency_ms": null,
+  "peak_vram_gb": null,
+  "log_excerpt": "Replace this record after running the generated AMD Developer Cloud runbook.",
+  "notes": "This file is a transparent benchmark schema, not a fabricated result. The Space displays it as pending until measured values are captured on AMD Developer Cloud."
+}

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/migration_report.md

@@ -0,0 +1,45 @@
+# ROCmPort AI Migration Report: cuda_first_repo
+
+## AMD Readiness Score
+
+- Before deterministic fixes: 53/100
+- After deterministic fixes: 100/100
+
+| Category | Before | After |
+| --- | ---: | ---: |
+| Code portability | 0 | 100 |
+| Environment readiness | 8 | 100 |
+| Serving readiness | 90 | 100 |
+| Benchmark readiness | 65 | 100 |
+| Deployment readiness | 100 | 100 |
+
+## Findings
+
+| Severity | Category | Location | Finding | Suggested fix |
+| --- | --- | --- | --- | --- |
+| high | Benchmark readiness | `benchmarks/benchmark.py:6` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| high | Environment readiness | `Dockerfile:1` | Dockerfile uses an NVIDIA CUDA base image. | Use vllm/vllm-openai-rocm:latest for vLLM serving or rocm/pytorch:latest for PyTorch workloads. |
+| medium | Environment readiness | `Dockerfile:8` | NVIDIA container environment variable found. | Use HIP_VISIBLE_DEVICES or ROCR_VISIBLE_DEVICES for AMD GPU targeting. |
+| high | Code portability | `infer.py:6` | torch.device is hardcoded to CUDA. | Use torch.device("cuda" if torch.cuda.is_available() else "cpu"); ROCm PyTorch reports AMD GPUs through torch.cuda. |
+| high | Code portability | `infer.py:11` | PyTorch tensor or module is moved with a hardcoded .cuda() call. | Replace .cuda() with .to(_rocmport_device) and define a runtime device abstraction. |
+| high | Code portability | `infer.py:12` | Tensor or module transfer hardcodes the CUDA device string. | Replace .to("cuda") with .to(_rocmport_device). |
+| low | Code portability | `infer.py:19` | CUDA availability check may confuse ROCm users because PyTorch ROCm still uses the torch.cuda namespace. | Keep the API call but document that it covers AMD GPUs under ROCm PyTorch. |
+| high | Environment readiness | `scripts/serve_vllm.sh:5` | NVIDIA-specific GPU inspection command found. | Use rocm-smi for AMD GPU monitoring and benchmark metadata collection. |
+| low | Serving readiness | `scripts/serve_vllm.sh:6` | vLLM serving command found without explicit ROCm container guidance. | Run vLLM inside vllm/vllm-openai-rocm with /dev/kfd, /dev/dri, host IPC, and video group access. |
+
+## Generated Artifacts
+
+- `rocm_patch.diff` contains deterministic MVP fixes.
+- `Dockerfile.rocm` uses the ROCm-enabled vLLM container.
+- `amd_developer_cloud_runbook.md` documents the validation path.
+- `benchmark_result.json` records the AMD benchmark schema and status.
+
+## Qwen Agent Notes
+
+Qwen endpoint was not configured. The report uses deterministic scanner output only.
+
+## Remaining Risks
+
+- CUDA C++ kernels, custom Triton kernels, and CUDA-only binary dependencies require manual review.
+- Uploaded repositories are not executed inside the Space; live validation belongs on AMD Developer Cloud.
+- ROCm performance depends on model, batch shape, vLLM version, ROCm version, and GPU instance configuration.

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/rocm_patch.diff

@@ -0,0 +1,48 @@
+--- a/Dockerfile
++++ b/Dockerfile
+@@ -1,10 +1,10 @@
+-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
++FROM vllm/vllm-openai-rocm:latest
+ 
+ WORKDIR /app
+ COPY requirements.txt .
+ RUN pip install --no-cache-dir -r requirements.txt
+ COPY . .
+ 
+-ENV NVIDIA_VISIBLE_DEVICES=all
++ENV HIP_VISIBLE_DEVICES=all
+ 
+ CMD ["python", "infer.py"]
+--- a/infer.py
++++ b/infer.py
+@@ -1,15 +1,18 @@
+ import torch
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ 
++# ROCm PyTorch exposes AMD GPUs through the torch.cuda namespace.
++_rocmport_device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
++
+ 
+ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+-device = torch.device("cuda")
++device = _rocmport_device
+ 
+ 
+ def main():
+     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).cuda()
+-    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to("cuda")
++    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).to(_rocmport_device)
++    inputs = tokenizer("Explain ROCm in one sentence.", return_tensors="pt").to(_rocmport_device)
+     with torch.no_grad():
+         outputs = model.generate(**inputs, max_new_tokens=64)
+     print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+--- a/scripts/serve_vllm.sh
++++ b/scripts/serve_vllm.sh
+@@ -2,5 +2,5 @@
+ set -euo pipefail
+ 
+ export CUDA_VISIBLE_DEVICES=0
+-nvidia-smi
++rocm-smi
+ vllm serve Qwen/Qwen2.5-0.5B-Instruct --tensor-parallel-size 1

artifacts/runtime/rocmport-ui-artifacts-3b0405c215eb4a3cb5cf402e4ee6453d/rocmport_artifacts.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd2494bdf724b6ec9d98675fea27408938c2ee0f7ee6b2bd219e10a857a1c105
+size 5229

artifacts/runtime/rocmport-ui-artifacts-6f4540ff23e142ad9d6ab18154ea44e6/Dockerfile.rocm

@@ -0,0 +1,11 @@
+FROM vllm/vllm-openai-rocm:latest
+
+WORKDIR /workspace/cuda_first_repo
+COPY . /workspace/cuda_first_repo
+
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+ENV HIP_VISIBLE_DEVICES=0
+ENV PYTORCH_HIP_ALLOC_CONF=expandable_segments:True
+
+CMD ["python", "-c", "import torch; print('torch', torch.__version__); print('rocm_gpu_available', torch.cuda.is_available())"]