GPU render: Blender 4.0.2 + Cycles + Gradio auto-start

Dockerfile

@@ -0,0 +1,39 @@
+FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04
+
+# System deps: Blender needs X11 libs even headless, ffmpeg for encoding
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    wget xz-utils \
+    libx11-6 libxi6 libxxf86vm1 libxfixes3 libxrender1 \
+    libgl1-mesa-glx libglib2.0-0 libsm6 libgomp1 libtbb12 \
+    ffmpeg python3-pip python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Blender 4.0.2 from official tarball
+RUN wget -q https://download.blender.org/release/Blender4.0/blender-4.0.2-linux-x64.tar.xz \
+    && tar -xf blender-4.0.2-linux-x64.tar.xz -C /opt \
+    && rm blender-4.0.2-linux-x64.tar.xz \
+    && ln -s /opt/blender-4.0.2/blender /usr/local/bin/blender
+
+# Verify Blender
+RUN blender --background --python-expr "import bpy; print(f'Blender {bpy.app.version_string} OK, CUDA: {bpy.app.build_options.cuda}')"
+
+# Python deps
+RUN pip3 install --no-cache-dir gradio huggingface_hub
+
+# App code
+COPY scripts/mol_giga_scene.py /app/scene.py
+COPY scripts/gradio_render.py /app/app.py
+
+WORKDIR /app
+ENV PYTHONUNBUFFERED=1
+ENV BLENDER_SYSTEM_SCRIPTS=/opt/blender-4.0.2/4.0/scripts
+
+# Pre-compile CUDA kernels on build (saves render startup time)
+RUN blender --background --python-expr "
+import bpy
+bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'
+bpy.context.preferences.addons['cycles'].preferences.get_devices()
+print('CUDA devices enumerated')
+" 2>&1 || true
+
+CMD ["python3", "app.py"]

app.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Gradio wrapper for Molecular Gigafactory GPU rendering on HF Space.
+Auto-starts render on boot; persists progress via checkpoint file.
+Uploads final MP4 to HF Dataset repo so it survives Space restarts.
+"""
+
+import gradio as gr
+import subprocess
+import threading
+import json
+import os
+import sys
+import time
+import shutil
+from pathlib import Path
+from huggingface_hub import HfApi, upload_file, create_repo
+
+OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/app/output")
+PROGRESS_FILE = os.path.join(OUTPUT_DIR, "progress.json")
+STATUS_FILE = os.path.join(OUTPUT_DIR, "status.json")
+HF_DATASET = "MolecularReality/mol-giga-output"
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+PHASES = ["A", "B", "C", "D", "E"]
+RENDER_RES = "720"
+RENDER_SAMPLES = "64"
+
+# ---------------------------------------------------------------------------
+# Render engine
+# ---------------------------------------------------------------------------
+def run_blender_phase(phase):
+    """Run Blender for a single phase. Returns True on success."""
+    phase_dir = os.path.join(OUTPUT_DIR, f"phase_{phase}")
+    os.makedirs(phase_dir, exist_ok=True)
+
+    cmd = [
+        "blender", "--background",
+        "--python", "/app/scene.py", "--",
+        "--render-all", f"--phase={phase}",
+        f"--output={OUTPUT_DIR}",
+        f"--res={RENDER_RES}",
+        f"--samples={RENDER_SAMPLES}",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=7200)
+    if result.returncode != 0:
+        print(f"Phase {phase} FAILED:\n{result.stderr[-2000:]}")
+        return False
+
+    # Encode phase frames to MP4
+    phase_mp4 = os.path.join(OUTPUT_DIR, f"phase_{phase}.mp4")
+    frames_pattern = os.path.join(phase_dir, "frame_%04d.png")
+    if os.path.exists(os.path.join(phase_dir, "frame_0001.png")):
+        enc = subprocess.run([
+            "ffmpeg", "-y", "-framerate", "24",
+            "-i", frames_pattern,
+            "-c:v", "libx264", "-preset", "fast", "-crf", "18",
+            "-pix_fmt", "yuv420p",
+            phase_mp4,
+        ], capture_output=True, text=True, timeout=600)
+        if enc.returncode != 0:
+            print(f"ffmpeg phase {phase} FAILED:\n{enc.stderr[-1000:]}")
+            return False
+
+    return os.path.exists(phase_mp4)
+
+
+def encode_final():
+    """Concat phase MP4s into final movie."""
+    concat_list = os.path.join(OUTPUT_DIR, "concat.txt")
+    mp4_paths = []
+    for phase in PHASES:
+        mp4 = os.path.join(OUTPUT_DIR, f"phase_{phase}.mp4")
+        if os.path.exists(mp4):
+            mp4_paths.append(mp4)
+
+    if not mp4_paths:
+        return None
+
+    with open(concat_list, "w") as f:
+        for mp4 in mp4_paths:
+            f.write(f"file '{mp4}'\n")
+
+    final_mp4 = os.path.join(OUTPUT_DIR, "Molecular-Gigafactory.mp4")
+    subprocess.run([
+        "ffmpeg", "-y", "-f", "concat", "-safe", "0",
+        "-i", concat_list, "-c", "copy", final_mp4,
+    ], capture_output=True, text=True, timeout=300)
+
+    return final_mp4 if os.path.exists(final_mp4) else None
+
+
+def upload_result(mp4_path):
+    """Upload final MP4 to HF Dataset."""
+    if not HF_TOKEN:
+        print("WARNING: HF_TOKEN not set, cannot upload")
+        return False
+    try:
+        api = HfApi(token=HF_TOKEN)
+        create_repo(HF_DATASET, repo_type="dataset", exist_ok=True, token=HF_TOKEN)
+        upload_file(
+            path_or_fileobj=mp4_path,
+            path_in_repo="Molecular-Gigafactory.mp4",
+            repo_id=HF_DATASET,
+            repo_type="dataset",
+            token=HF_TOKEN,
+        )
+        # Also upload poster frame
+        poster = os.path.join(OUTPUT_DIR, "poster.jpg")
+        subprocess.run([
+            "ffmpeg", "-y", "-i", mp4_path, "-ss", "30", "-vframes", "1",
+            "-q:v", "2", poster,
+        ], capture_output=True, timeout=60)
+        if os.path.exists(poster):
+            upload_file(
+                path_or_fileobj=poster,
+                path_in_repo="Molecular-Gigafactory-poster.jpg",
+                repo_id=HF_DATASET,
+                repo_type="dataset",
+                token=HF_TOKEN,
+            )
+        return True
+    except Exception as e:
+        print(f"Upload failed: {e}")
+        return False
+
+
+def save_status(data):
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    with open(STATUS_FILE, "w") as f:
+        json.dump(data, f)
+
+
+def load_status():
+    try:
+        with open(STATUS_FILE) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {"phase": "idle", "progress": 0, "message": "Ready"}
+
+
+# ---------------------------------------------------------------------------
+# Background render thread
+# ---------------------------------------------------------------------------
+def render_all_phases():
+    """Render all phases, encode, upload. Runs in background thread."""
+    save_status({"phase": "starting", "progress": 0, "message": "Initializing..."})
+
+    completed_phases = []
+    for phase in PHASES:
+        # Check if phase already done (from checkpoint)
+        progress = {}
+        try:
+            with open(PROGRESS_FILE) as f:
+                progress = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            pass
+
+        phase_key = f"phase_{phase}"
+        if progress.get(phase_key, {}).get("complete"):
+            msg = f"Phase {phase} already complete, skipping"
+            print(msg)
+            save_status({"phase": phase, "progress": int((len(completed_phases) + 1) / len(PHASES) * 100),
+                         "message": msg})
+            completed_phases.append(phase)
+            continue
+
+        msg = f"Rendering phase {phase}..."
+        print(msg)
+        save_status({"phase": phase, "progress": int(len(completed_phases) / len(PHASES) * 100),
+                     "message": msg})
+
+        ok = run_blender_phase(phase)
+        if ok:
+            completed_phases.append(phase)
+            save_status({"phase": phase, "progress": int(len(completed_phases) / len(PHASES) * 100),
+                         "message": f"Phase {phase} done"})
+        else:
+            save_status({"phase": phase, "progress": int(len(completed_phases) / len(PHASES) * 100),
+                         "message": f"Phase {phase} FAILED — will retry on restart"})
+            return  # Stop here; next boot will resume from checkpoint
+
+    # All phases done — encode final
+    save_status({"phase": "encoding", "progress": 85, "message": "Encoding final MP4..."})
+    final_mp4 = encode_final()
+    if not final_mp4:
+        save_status({"phase": "error", "progress": 85, "message": "Final encode failed"})
+        return
+
+    # Upload
+    save_status({"phase": "uploading", "progress": 90, "message": "Uploading to HF Dataset..."})
+    ok = upload_result(final_mp4)
+    if ok:
+        save_status({"phase": "done", "progress": 100,
+                     "message": f"Complete! MP4 uploaded to {HF_DATASET}"})
+    else:
+        save_status({"phase": "done", "progress": 100,
+                     "message": f"Render complete but upload failed. MP4 at {final_mp4}"})
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+def get_status():
+    s = load_status()
+    return json.dumps(s, indent=2)
+
+
+def start_render():
+    s = load_status()
+    if s.get("phase") in ("running", "starting", "encoding", "uploading"):
+        return "Render already in progress!"
+    threading.Thread(target=render_all_phases, daemon=True).start()
+    return "Render started! Check status below."
+
+
+with gr.Blocks(title="Molecular Gigafactory Render", theme="soft") as demo:
+    gr.Markdown("""
+    # Molecular Gigafactory — GPU Render Service
+    Auto-starts rendering on Space boot. Results uploaded to HF Dataset.
+    """)
+
+    with gr.Row():
+        start_btn = gr.Button("Start Render", variant="primary")
+        refresh_btn = gr.Button("Refresh Status")
+
+    status_display = gr.Textbox(
+        value=get_status(), label="Status", lines=6, every=10
+    )
+
+    start_btn.click(start_render, outputs=[status_display])
+    refresh_btn.click(get_status, outputs=[status_display])
+
+    # Auto-refresh status every 10 seconds
+    demo.load(get_status, outputs=[status_display], every=10)
+
+
+# ---------------------------------------------------------------------------
+# Auto-start on boot
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Check if we need to auto-start
+    status = load_status()
+    if status.get("phase") in ("idle", "error", None) or status.get("progress", 0) < 100:
+        print(f"Auto-starting render (current status: {status.get('phase')})")
+        threading.Thread(target=render_all_phases, daemon=True).start()
+    else:
+        print(f"Render already complete (status: {status.get('phase')})")
+
+    demo.queue(default_concurrency_limit=1)
+    demo.launch(server_name="0.0.0.0", server_port=7860)

scene.py

@@ -0,0 +1,809 @@
+#!/usr/bin/env python3
+"""Molecular Gigafactory — Procedural Blender Scene Generator.
+
+Usage:
+  # Test render single frame at 480p
+  blender --background --python mol_giga_scene.py -- --test --frame 500
+
+  # Render all phases at production resolution
+  blender --background --python mol_giga_scene.py -- --render-all --phase all
+
+  # Render specific phase
+  blender --background --python mol_giga_scene.py -- --render-all --phase A
+
+  # Render with custom resolution
+  blender --background --python mol_giga_scene.py -- --render-all --res 720 --phase all
+"""
+
+import bpy
+import math
+import mathutils
+import os
+import sys
+import json
+import time
+import argparse
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# CONFIGURATION
+# ---------------------------------------------------------------------------
+CONFIG = {
+    "output_dir": "/var/www/epicquest.bio/app/static/videos/frames",
+    "progress_file": "/var/www/epicquest.bio/app/static/videos/frames/progress.json",
+    "resolution_x": 1280,   # 720p default for v0.01
+    "resolution_y": 720,
+    "fps": 24,
+    "samples": 64,
+    "rack_count": 5,         # v0.01: 5 racks
+    "rack_rows": 13,
+    "rack_cols": 11,
+    "rack_height": 2.2,
+    "rack_width": 1.0,
+    "rack_depth": 0.8,
+    "room_width": 12.0,
+    "room_depth": 10.0,
+    "room_height": 3.5,
+}
+
+# Animation phase definitions (frames for each phase, 24fps, 45s total = 1080 frames)
+PHASES = {
+    "A": {"name": "Exterior fly-in",        "start": 1,    "end": 240,  "desc": "0-10s approach"},
+    "B": {"name": "Roof cutaway",           "start": 241,  "end": 480,  "desc": "10-20s descend"},
+    "C": {"name": "Rack reveal",            "start": 481,  "end": 960,  "desc": "20-40s interior"},
+    "D": {"name": "Detail annotations",     "start": 961,  "end": 1320, "desc": "40-55s close-up"},
+    "E": {"name": "Final hold",             "start": 1321, "end": 1440, "desc": "55-60s settle"},
+}
+
+# ---------------------------------------------------------------------------
+# CLI ARGUMENTS
+# ---------------------------------------------------------------------------
+def parse_args():
+    """Parse command-line arguments after '--'."""
+    argv = sys.argv
+    if "--" in argv:
+        argv = argv[argv.index("--") + 1:]
+    else:
+        argv = []
+
+    parser = argparse.ArgumentParser(description="Molecular Gigafactory Scene Generator")
+    parser.add_argument("--test", action="store_true", help="Test render single frame")
+    parser.add_argument("--frame", type=int, default=500, help="Frame to test-render")
+    parser.add_argument("--render-all", action="store_true", help="Render full animation")
+    parser.add_argument("--phase", type=str, default="all", help="Phase to render (A/B/C/D/E/all)")
+    parser.add_argument("--res", type=int, default=None, help="Resolution (720 or 1080)")
+    parser.add_argument("--samples", type=int, default=None, help="Override sample count")
+    parser.add_argument("--output", type=str, default=None, help="Override output directory")
+    return parser.parse_args(argv)
+
+
+# ---------------------------------------------------------------------------
+# UTILITIES
+# ---------------------------------------------------------------------------
+def make_material(name, color_hex, metallic=0.0, roughness=0.5, emit_strength=0.0, emit_hex=None, alpha=1.0):
+    """Create a PBR material from hex colors matching the apex theme palette."""
+    def hex_to_rgb(h):
+        h = h.lstrip("#")
+        return (int(h[0:2], 16) / 255, int(h[2:4], 16) / 255, int(h[4:6], 16) / 255)
+
+    mat = bpy.data.materials.new(name)
+    mat.use_nodes = True
+    nodes = mat.node_tree.nodes
+    nodes.clear()
+    bsdf = nodes.new("ShaderNodeBsdfPrincipled")
+    bsdf.inputs["Base Color"].default_value = (*hex_to_rgb(color_hex), 1.0)
+    bsdf.inputs["Metallic"].default_value = metallic
+    bsdf.inputs["Roughness"].default_value = roughness
+    bsdf.inputs["Emission Strength"].default_value = emit_strength
+    if emit_hex:
+        bsdf.inputs["Emission Color"].default_value = (*hex_to_rgb(emit_hex), 1.0)
+    if alpha < 1.0:
+        mat.blend_method = 'BLEND'
+        bsdf.inputs["Alpha"].default_value = alpha
+    out = nodes.new("ShaderNodeOutputMaterial")
+    mat.node_tree.links.new(bsdf.outputs["BSDF"], out.inputs["Surface"])
+    return mat
+
+
+def _detach_from_collections(obj):
+    """Unlink from all collections so caller can link where needed."""
+    for coll in list(obj.users_collection):
+        coll.objects.unlink(obj)
+
+
+def add_box(name, half_extents, location=(0, 0, 0)):
+    """Add a box primitive and return it (not linked to any collection)."""
+    bpy.ops.mesh.primitive_cube_add(size=1)
+    obj = bpy.context.object
+    obj.name = name
+    obj.scale = half_extents
+    obj.location = location
+    _detach_from_collections(obj)
+    return obj
+
+
+def add_cylinder(name, radius, depth, location=(0, 0, 0), rotation=(0, 0, 0)):
+    """Add a cylinder primitive (not linked to any collection)."""
+    bpy.ops.mesh.primitive_cylinder_add(radius=radius, depth=depth, location=location)
+    obj = bpy.context.object
+    obj.name = name
+    obj.rotation_euler = rotation
+    _detach_from_collections(obj)
+    return obj
+
+
+def add_sphere(name, radius, location=(0, 0, 0)):
+    """Add a UV sphere (not linked to any collection)."""
+    bpy.ops.mesh.primitive_uv_sphere_add(radius=radius, location=location)
+    obj = bpy.context.object
+    obj.name = name
+    _detach_from_collections(obj)
+    return obj
+
+
+def save_progress(data):
+    """Write progress JSON for crash recovery."""
+    os.makedirs(os.path.dirname(CONFIG["progress_file"]), exist_ok=True)
+    with open(CONFIG["progress_file"], "w") as f:
+        json.dump(data, f)
+
+
+def load_progress():
+    """Read progress JSON, return None if not found."""
+    try:
+        with open(CONFIG["progress_file"]) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# 1. CLEAR SCENE
+# ---------------------------------------------------------------------------
+def clear_scene():
+    """Remove all objects from the default scene."""
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    # Set render settings
+    scene = bpy.context.scene
+    scene.render.resolution_x = CONFIG["resolution_x"]
+    scene.render.resolution_y = CONFIG["resolution_y"]
+    scene.render.resolution_percentage = 100
+    scene.render.fps = CONFIG["fps"]
+    scene.render.image_settings.file_format = 'PNG'
+    scene.render.image_settings.color_mode = 'RGBA'
+    scene.frame_start = 1
+    scene.frame_end = 1440
+
+
+# ---------------------------------------------------------------------------
+# 2. MATERIALS
+# ---------------------------------------------------------------------------
+def create_all_materials():
+    """Create all shared materials, return a dict for easy lookup."""
+    mats = {}
+    mats["pcb"]      = make_material("PCB",      "#1a5c1a", roughness=0.6)
+    mats["case"]     = make_material("Case",     "#2a2a2a", metallic=0.2, roughness=0.7)
+    mats["chip"]     = make_material("Chip",     "#222222", metallic=0.5, roughness=0.3)
+    mats["silver"]   = make_material("Silver",   "#c0c0c0", metallic=0.9, roughness=0.15)
+    mats["copper"]   = make_material("Copper",   "#b87333", metallic=0.8, roughness=0.2)
+    mats["battery"]  = make_material("Battery",  "#335599", metallic=0.3, roughness=0.4)
+    mats["led"]      = make_material("LED",      "#22c55e", emit_strength=5.0, emit_hex="#22c55e")
+    mats["flow"]     = make_material("FlowCell", "#ccddff", metallic=0.0, roughness=0.1, alpha=0.7)
+    mats["rack"]     = make_material("Rack",     "#333333", metallic=0.7, roughness=0.4)
+    mats["floor"]    = make_material("Floor",    "#0d0d0d", roughness=0.8)
+    mats["wall"]     = make_material("Wall",     "#1a1a1a", roughness=0.9)
+    mats["ceiling"]  = make_material("Ceiling",  "#222222", roughness=0.8)
+    mats["cable"]    = make_material("Cable",    "#111111", roughness=0.6)
+    mats["trace"]    = make_material("Trace",    "#4ade80", emit_strength=2.0, emit_hex="#4ade80")
+    mats["wireframe"]= make_material("Wireframe","#4ade80", emit_strength=1.5, emit_hex="#4ade80")
+    mats["text_anno"]= make_material("Annotation","#4ade80", emit_strength=3.0, emit_hex="#4ade80")
+    return mats
+
+
+# ---------------------------------------------------------------------------
+# 3. MR1 DEVICE MODELS (3 LODs)
+# ---------------------------------------------------------------------------
+def build_mr1_lod0():
+    """High-detail MR1 device (~8k tris). Returns a Collection."""
+    col = bpy.data.collections.new("MR1_LOD0")
+    bpy.context.scene.collection.children.link(col)
+    mats = create_all_materials()
+
+    # PCB base
+    pcb = add_box("PCB", (0.070, 0.035, 0.0008), (0, 0, 0.0008))
+    pcb.data.materials.append(mats["pcb"])
+    col.objects.link(pcb)
+
+    # ESP32-S3
+    esp = add_box("ESP32", (0.009, 0.009, 0.0015), (0.050, 0.015, 0.0023))
+    esp.data.materials.append(mats["chip"])
+    col.objects.link(esp)
+
+    # LMP7721 preamp
+    lmp = add_box("LMP7721", (0.0025, 0.0025, 0.00075), (-0.010, 0.000, 0.0018))
+    lmp.data.materials.append(mats["silver"])
+    col.objects.link(lmp)
+
+    # ADC
+    adc = add_box("MAX11169", (0.003, 0.003, 0.00075), (0.010, -0.010, 0.0018))
+    adc.data.materials.append(mats["chip"])
+    col.objects.link(adc)
+
+    # DAC
+    dac = add_box("MCP4822", (0.003, 0.003, 0.00075), (0.020, -0.010, 0.0018))
+    dac.data.materials.append(mats["chip"])
+    col.objects.link(dac)
+
+    # 6 batteries
+    for i in range(6):
+        b = add_cylinder(f"Batt{i+1}", 0.009, 0.065,
+                        (-0.045 + i * 0.018, -0.025, 0.034),
+                        (0, math.radians(90), 0))
+        b.data.materials.append(mats["battery"])
+        col.objects.link(b)
+
+    # Flow cell
+    flow = add_box("FlowCell", (0.010, 0.005, 0.0025), (-0.060, 0.0, 0.003))
+    flow.data.materials.append(mats["flow"])
+    col.objects.link(flow)
+
+    # Copper shield can (wireframe box over preamp)
+    shield = add_box("ShieldCan", (0.012, 0.010, 0.005), (-0.010, 0.0, 0.005))
+    shield.data.materials.append(mats["copper"])
+    mod = shield.modifiers.new("Wireframe", 'WIREFRAME')
+    mod.thickness = 0.0003
+    col.objects.link(shield)
+
+    # LED indicator
+    led = add_sphere("LED", 0.0015, (0.060, 0.025, 0.003))
+    led.data.materials.append(mats["led"])
+    col.objects.link(led)
+
+    # Ag/AgCl electrodes
+    for j, xo in enumerate([-0.002, 0.002]):
+        e = add_cylinder(f"Elec{j+1}", 0.00025, 0.006, (-0.060 + xo, 0.0, 0.006))
+        e.data.materials.append(mats["silver"])
+        col.objects.link(e)
+
+    # Case shell (wireframe display for now, solid in render)
+    case = add_box("CaseShell", (0.075, 0.039, 0.009), (0, 0, 0.001))
+    case.data.materials.append(mats["case"])
+    mod = case.modifiers.new("Solidify", 'SOLIDIFY')
+    mod.thickness = 0.001
+    mod.offset = 1
+    col.objects.link(case)
+
+    return col
+
+
+def build_mr1_lod1():
+    """Medium-detail MR1 (~1.2k tris). Simplified: case + PCB block + batteries."""
+    col = bpy.data.collections.new("MR1_LOD1")
+    bpy.context.scene.collection.children.link(col)
+    mats = create_all_materials()
+
+    # Main body block (PCB + case combined)
+    body = add_box("Body", (0.075, 0.039, 0.009), (0, 0, 0.001))
+    body.data.materials.append(mats["case"])
+    col.objects.link(body)
+
+    # Simplified PCB surface on top
+    pcb_top = add_box("PCB_Top", (0.070, 0.035, 0.0003), (0, 0, 0.010))
+    pcb_top.data.materials.append(mats["pcb"])
+    col.objects.link(pcb_top)
+
+    # Battery cylinders (6)
+    for i in range(6):
+        b = add_cylinder(f"B{i}", 0.009, 0.065,
+                        (-0.045 + i * 0.018, -0.025, 0.034),
+                        (0, math.radians(90), 0))
+        b.data.materials.append(mats["battery"])
+        col.objects.link(b)
+
+    # LED
+    led = add_sphere("LED", 0.002, (0.060, 0.025, 0.003))
+    led.data.materials.append(mats["led"])
+    col.objects.link(led)
+
+    return col
+
+
+def build_mr1_lod2():
+    """Low-detail MR1 (~200 tris). Single box with emissive LED point."""
+    col = bpy.data.collections.new("MR1_LOD2")
+    bpy.context.scene.collection.children.link(col)
+    mats = create_all_materials()
+
+    body = add_box("Body", (0.075, 0.039, 0.009))
+    body.data.materials.append(mats["case"])
+    col.objects.link(body)
+
+    led = add_sphere("LED", 0.003, (0.060, 0.025, 0.003))
+    led.data.materials.append(mats["led"])
+    col.objects.link(led)
+
+    return col
+
+
+# ---------------------------------------------------------------------------
+# 4. RACK
+# ---------------------------------------------------------------------------
+def build_rack(x, z, lod0_col, lod1_col, lod2_col):
+    """Build a double-sided rack at position (x, 0, z) with LOD instances."""
+    mats = create_all_materials()
+    rack = bpy.data.collections.new(f"Rack_{int(x)}_{int(z)}")
+    bpy.context.scene.collection.children.link(rack)
+
+    # Frame
+    hw = CONFIG["rack_width"] / 2
+    hd = CONFIG["rack_depth"] / 2
+    hh = CONFIG["rack_height"] / 2
+    th = 0.02  # extrusion thickness
+
+    # Vertical posts (4 corners)
+    for dx in [-hw + th, hw - th]:
+        for dz in [-hd + th, hd - th]:
+            post = add_box("Post", (th/2, th/2, hh),
+                          (x + dx, hh, z + dz))
+            post.data.materials.append(mats["rack"])
+            rack.objects.link(post)
+
+    # Horizontal rails (front and back, at each row position)
+    row_spacing = CONFIG["rack_height"] / CONFIG["rack_rows"]
+    for r in range(CONFIG["rack_rows"] + 1):
+        ry = r * row_spacing
+        for face_z in [-hd, hd]:
+            rail = add_box("Rail", (hw/2, 0.005, 0.005),
+                          (x + hw/2, ry, z + face_z))
+            rail.data.materials.append(mats["rack"])
+            rack.objects.link(rail)
+
+    # Device instances — front and back face
+    col_spacing_w = (CONFIG["rack_width"] - 0.1) / CONFIG["rack_cols"]
+    col_spacing_h = (CONFIG["rack_height"] - 0.15) / CONFIG["rack_rows"]
+    start_w = -CONFIG["rack_width"]/2 + 0.05 + col_spacing_w/2
+    start_h = 0.08 + col_spacing_h/2
+
+    for face_z in [-hd + 0.09, hd - 0.09]:  # offset for rack depth
+        for r in range(CONFIG["rack_rows"]):
+            for c in range(CONFIG["rack_cols"]):
+                dx = start_w + c * col_spacing_w
+                dy = start_h + r * col_spacing_h
+                dz = face_z
+
+                # Device lies flat: thickness (Z) points up (rack Y),
+                # long axis (X) goes into rack depth (rack Z)
+                empty = bpy.data.objects.new(f"Dev_{r}_{c}", None)
+                empty.empty_display_type = 'PLAIN_AXES'
+                empty.location = (x + dx, dy, z + dz)
+                empty.rotation_euler = (math.radians(90), 0, 0)
+                empty.instance_type = 'COLLECTION'
+                empty.instance_collection = lod0_col
+                rack.objects.link(empty)
+
+    return rack
+
+
+# ---------------------------------------------------------------------------
+# 5. FACILITY
+# ---------------------------------------------------------------------------
+def build_facility(mr1_lod0, mr1_lod1, mr1_lod2):
+    """Build room, floor, walls, ceiling, lighting, racks."""
+    mats = create_all_materials()
+    scene_col = bpy.context.scene.collection
+
+    rw = CONFIG["room_width"]
+    rd = CONFIG["room_depth"]
+    rh = CONFIG["room_height"]
+
+    # Floor — large dark platform
+    floor = add_box("Floor", (rw/2 + 2, rd/2 + 2, 0.01), (rw/2, 0, rd/2))
+    floor.data.materials.append(mats["floor"])
+    scene_col.objects.link(floor)
+
+    # Walls — skip for v0.01; facility is an open platform
+    # Ceiling — skip; we want to see inside from above in exterior shots
+
+    # Racks — arrange in a grid
+    rack_count = CONFIG["rack_count"]
+    racks_per_row = 3  # for 5 racks: 2 rows of 2+3
+    rack_spacing_x = 2.5
+    rack_spacing_z = 2.5
+    start_x = rw/2 - (racks_per_row - 1) * rack_spacing_x / 2
+    start_z = 2.0
+
+    for i in range(rack_count):
+        rx = start_x + (i % racks_per_row) * rack_spacing_x
+        rz = start_z + (i // racks_per_row) * rack_spacing_z
+        build_rack(rx, rz, mr1_lod0, mr1_lod1, mr1_lod2)
+
+    # Overhead cable trays
+    for i in range(rack_count + 1):
+        cx = start_x + (i % racks_per_row) * rack_spacing_x - rack_spacing_x/2
+        tray = add_box("CableTray", (0.15, 0.03, rd/2), (cx, rh - 0.5, rd/2))
+        tray.data.materials.append(mats["cable"])
+        scene_col.objects.link(tray)
+
+    # Lighting — overhead area lamps + key sun
+    for lx in [rw * 0.25, rw * 0.5, rw * 0.75]:
+        for lz in [rd * 0.25, rd * 0.5, rd * 0.75]:
+            bpy.ops.object.light_add(type='AREA', location=(lx, rh - 0.1, lz))
+            light = bpy.context.object
+            light.data.energy = 150.0
+            light.data.size = 0.8
+            light.data.color = (0.9, 0.95, 1.0)
+
+    # Key sun for ambient fill (needed for EEVEE visibility)
+    bpy.ops.object.light_add(type='SUN', location=(rw * 0.3, rh + 5, rd * 0.3))
+    sun = bpy.context.object
+    sun.data.energy = 3.0
+    sun.data.angle = math.radians(15)
+
+
+# ---------------------------------------------------------------------------
+# 6. CAMERA ANIMATION (NURBS PATH)
+# ---------------------------------------------------------------------------
+def setup_camera_animation():
+    """Create NURBS path + Follow Path constraint on camera."""
+    rw = CONFIG["room_width"]
+    rd = CONFIG["room_depth"]
+    rh = CONFIG["room_height"]
+
+    # Compute rack positions (matching build_facility layout)
+    racks_per_row = 3
+    rack_spacing_x = 2.5
+    rack_spacing_z = 2.5
+    start_x = rw/2 - (racks_per_row - 1) * rack_spacing_x / 2
+    start_z = 2.0
+
+    # Target rack for close-up phases D-E: second rack in first row
+    target_rack_x = start_x + rack_spacing_x
+    target_rack_z = start_z
+
+    # Waypoints for the 5-phase animation (x, y, z, weight)
+    waypoints = [
+        # Phase A: exterior approach (high above, looking down)
+        (rw/2, 50.0, rd/2 - 10, 1.0),
+        (rw/2, 30.0, rd/2 - 5, 1.0),
+        (rw/2, 15.0, rd/2 - 2, 1.0),
+        (rw/2, rh + 2, rd/2, 1.0),        # just above roof, frame 240
+
+        # Phase B: roof cutaway (descend through roof)
+        (rw/2, rh - 0.5, rd/2, 1.0),       # just below roof
+        (rw/2, rh - 1.5, rd/2, 1.0),       # entering room
+
+        # Phase C: rack reveal (pan across room at ceiling height)
+        (rw * 0.8, rh - 2, rd * 0.7, 1.0),
+        (rw * 0.5, rh - 2.5, rd * 0.5, 1.0),
+        (rw * 0.3, 1.7, rd * 0.4, 1.0),    # eye level, looking at racks
+
+        # Phase D: detail close-up (dolly toward target rack)
+        (target_rack_x, 1.5, target_rack_z, 1.0),
+        (target_rack_x + 0.3, 1.3, target_rack_z + 0.3, 1.0),
+
+        # Phase E: final hold
+        (target_rack_x + 0.5, 1.2, target_rack_z + 0.5, 1.0),
+    ]
+
+    total_frames = 1440
+
+    # Camera — placed at first waypoint
+    first_wp = waypoints[0][:3]
+    bpy.ops.object.camera_add(location=first_wp)
+    cam = bpy.context.object
+    cam.name = "MainCamera"
+    cam.data.lens = 28
+    bpy.context.scene.camera = cam
+
+    # LookAt target — starts at room center
+    bpy.ops.object.empty_add(type='PLAIN_AXES', location=(rw/2, 1.0, rd/2))
+    target = bpy.context.object
+    target.name = "LookAtTarget"
+
+    # Animate target position
+    target.location = (rw/2, 1.0, rd/2)
+    target.keyframe_insert('location', frame=1)
+    target.location = (rw/2, rh - 3, rd/2)
+    target.keyframe_insert('location', frame=60)
+    target.location = (rw * 0.7, rh - 1.5, rd * 0.7)
+    target.keyframe_insert('location', frame=240)
+    target.location = (rw * 0.5, 1.0, rd * 0.5)
+    target.keyframe_insert('location', frame=480)
+    target.location = (target_rack_x, 1.0, target_rack_z)
+    target.keyframe_insert('location', frame=960)
+    target.location = (target_rack_x + 0.5, 1.2, target_rack_z + 0.5)
+    target.keyframe_insert('location', frame=1440)
+
+    # Direct keyframe camera position at phase boundaries (no constraint conflicts)
+    camera_keys = {
+        1:    (rw/2, 50.0, rd/2 - 10),     # Phase A start: high above, south
+        120:  (rw/2, 30.0, rd/2 - 3),
+        240:  (rw/2, rh + 2, rd/2),         # Phase A→B: just above roof
+        360:  (rw/2, rh - 1, rd/2),         # Phase B: inside room, ceiling height
+        480:  (rw * 0.7, rh - 2, rd * 0.7),# Phase B→C: panning across
+        720:  (rw * 0.5, rh - 2.5, rd * 0.5),
+        960:  (target_rack_x - 0.5, 1.5, target_rack_z),  # Phase C→D: approach target rack
+        1200: (target_rack_x, 1.3, target_rack_z + 0.2),  # Phase D: close-up
+        1440: (target_rack_x + 0.5, 1.2, target_rack_z + 0.5),  # Phase E: final hold
+    }
+
+    for frame, pos in camera_keys.items():
+        cam.location = pos
+        cam.keyframe_insert('location', frame=frame)
+
+    # Set Track To constraint LAST so it isn't overridden
+    track = cam.constraints.new('TRACK_TO')
+    track.target = target
+    track.track_axis = 'TRACK_NEGATIVE_Z'
+    track.up_axis = 'UP_Y'
+
+    # Smooth interpolation for all fcurves
+    if cam.animation_data and cam.animation_data.action:
+        for fcu in cam.animation_data.action.fcurves:
+            for kf in fcu.keyframe_points:
+                kf.interpolation = 'BEZIER'
+    if target.animation_data and target.animation_data.action:
+        for fcu in target.animation_data.action.fcurves:
+            for kf in fcu.keyframe_points:
+                kf.interpolation = 'BEZIER'
+
+    return cam, target, None
+
+
+# ---------------------------------------------------------------------------
+# 7. ANNOTATIONS
+# ---------------------------------------------------------------------------
+def create_annotations():
+    """Create 3D text annotation objects with keyframed visibility."""
+    mats = create_all_materials()
+    annot_col = bpy.data.collections.new("Annotations")
+    bpy.context.scene.collection.children.link(annot_col)
+
+    # Find a good position near the central rack
+    rack_x = CONFIG["room_width"] / 2
+    rack_z = 2.0
+
+    annotations = [
+        ("MR1 Molecular Streamer", (rack_x - 0.5, 1.8, rack_z + 0.5), 961),
+        ("10,000 devices / 35 racks", (rack_x - 0.5, 1.5, rack_z + 0.5), 1000),
+        ("ESP32-S3 · LMP7721 · MAX11169", (rack_x - 0.5, 1.2, rack_z + 0.5), 1040),
+        ("Flow Cell: Silicon Micropore", (rack_x - 0.5, 0.9, rack_z + 0.5), 1080),
+        ("286 devices per rack", (rack_x - 0.5, 0.6, rack_z + 0.5), 1120),
+    ]
+
+    for text, loc, appear_frame in annotations:
+        bpy.ops.object.text_add(location=loc)
+        txt_obj = bpy.context.object
+        txt_obj.name = f"Anno_{text[:20]}"
+        txt_obj.data.body = text
+        txt_obj.data.size = 0.08
+        txt_obj.data.extrude = 0.005
+        txt_obj.data.align_x = 'LEFT'
+        txt_obj.data.font = bpy.data.fonts.load(
+            "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
+        ) if os.path.exists("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf") else None
+
+        txt_obj.data.materials.append(mats["text_anno"])
+
+        # Visibility keyframes
+        txt_obj.hide_viewport = True
+        txt_obj.hide_render = True
+        txt_obj.keyframe_insert('hide_render', frame=appear_frame - 1)
+        txt_obj.keyframe_insert('hide_viewport', frame=appear_frame - 1)
+        txt_obj.hide_render = False
+        txt_obj.hide_viewport = False
+        txt_obj.keyframe_insert('hide_render', frame=appear_frame)
+        txt_obj.keyframe_insert('hide_viewport', frame=appear_frame)
+
+        annot_col.objects.link(txt_obj)
+
+
+# ---------------------------------------------------------------------------
+# 8. RENDER SETTINGS
+# ---------------------------------------------------------------------------
+def configure_render(engine='CYCLES'):
+    """Set render engine and quality settings."""
+    scene = bpy.context.scene
+
+    if engine == 'CYCLES':
+        scene.render.engine = 'CYCLES'
+        prefs = bpy.context.preferences.addons['cycles'].preferences
+
+        # Try OptiX first (faster), fall back to CUDA
+        for device_type in ['OPTIX', 'CUDA']:
+            try:
+                prefs.compute_device_type = device_type
+                prefs.get_devices()
+                gpu_found = any(d.type == device_type for d in prefs.devices)
+                if gpu_found:
+                    print(f"Cycles: using {device_type}")
+                    break
+            except Exception:
+                continue
+
+        # Enable all GPU devices
+        for device in prefs.devices:
+            device.use = device.type in ('OPTIX', 'CUDA')
+            print(f"  Device: {device.name} ({device.type}) — {'enabled' if device.use else 'skipped'}")
+
+        scene.cycles.device = 'GPU'
+        scene.cycles.samples = CONFIG["samples"]
+        scene.cycles.use_denoising = True
+        scene.cycles.denoiser = 'OPTIX'  # OptiX denoiser on GPU
+        scene.cycles.use_adaptive_sampling = True
+        scene.cycles.adaptive_threshold = 0.01
+        scene.cycles.max_bounces = 8
+        scene.cycles.diffuse_bounces = 4
+        scene.cycles.glossy_bounces = 4
+        scene.cycles.transmission_bounces = 8
+        scene.cycles.volume_bounces = 0
+        scene.cycles.texture_limit = 1024
+        scene.cycles.use_compact_bvh = True
+        scene.cycles.bvh_type = 'STATIC'
+        scene.cycles.use_square_samples = True
+    else:
+        scene.render.engine = 'BLENDER_EEVEE'
+        scene.eevee.taa_render_samples = 32
+        scene.eevee.use_bloom = True
+        scene.eevee.bloom_intensity = 0.3
+        scene.eevee.use_gtao = True
+
+    # Simplify for performance
+    scene.render.use_simplify = True
+    scene.render.simplify_subdivision = 0
+    scene.render.simplify_child_particles = 0.0
+
+    # Color management
+    scene.view_settings.view_transform = 'Standard'
+    scene.view_settings.look = 'None'
+
+
+# ---------------------------------------------------------------------------
+# 9. WORLD / ENVIRONMENT
+# ---------------------------------------------------------------------------
+def setup_world():
+    """Dark world matching apex theme — dim ambient fill."""
+    world = bpy.data.worlds.new("ApexDark")
+    bpy.context.scene.world = world
+    world.use_nodes = True
+    bg = world.node_tree.nodes["Background"]
+    bg.inputs["Color"].default_value = (0.01, 0.02, 0.01, 1.0)
+    bg.inputs["Strength"].default_value = 1.0
+
+
+# ---------------------------------------------------------------------------
+# 10. RENDER LOOP WITH CHECKPOINTING
+# ---------------------------------------------------------------------------
+def render_phase(phase_key, engine='CYCLES'):
+    """Render all frames for a given phase, with checkpoint/resume."""
+    phase = PHASES[phase_key]
+    scene = bpy.context.scene
+
+    out_dir = os.path.join(CONFIG["output_dir"], f"phase_{phase_key}")
+    os.makedirs(out_dir, exist_ok=True)
+
+    scene.frame_start = phase["start"]
+    scene.frame_end = phase["end"]
+    scene.render.filepath = os.path.join(out_dir, "frame_####.png")
+
+    # Check progress
+    progress = load_progress() or {}
+    phase_progress = progress.get(f"phase_{phase_key}", {})
+    last_frame = phase_progress.get("last_frame", phase["start"] - 1)
+
+    if last_frame >= phase["end"]:
+        print(f"Phase {phase_key} already complete, skipping.")
+        return
+
+    start_from = last_frame + 1
+    print(f"Rendering phase {phase_key} ({phase['name']}): frames {start_from}-{phase['end']}")
+
+    for frame in range(start_from, phase["end"] + 1):
+        scene.frame_set(frame)
+        scene.render.filepath = os.path.join(out_dir, f"frame_{frame:04d}.png")
+        bpy.ops.render.render(write_still=True)
+
+        if frame % 30 == 0:
+            progress[f"phase_{phase_key}"] = {"last_frame": frame, "timestamp": time.time()}
+            save_progress(progress)
+            print(f"  Progress: {frame}/{phase['end']} ({100*frame/phase['end']:.0f}%)")
+
+    # Mark phase complete
+    progress[f"phase_{phase_key}"] = {"last_frame": phase["end"], "timestamp": time.time(), "complete": True}
+    save_progress(progress)
+    print(f"Phase {phase_key} complete.")
+
+
+def render_test_frame(frame_num, engine='EEVEE'):
+    """Render a single test frame at low resolution."""
+    scene = bpy.context.scene
+    scene.render.resolution_x = 640
+    scene.render.resolution_y = 360
+
+    test_path = os.path.join(CONFIG["output_dir"], f"test_frame_{frame_num:04d}.png")
+    scene.render.filepath = test_path
+    scene.frame_set(frame_num)
+
+    # Debug: camera position
+    cam = bpy.data.objects.get('MainCamera')
+    if cam:
+        loc = cam.matrix_world.translation
+        direction = cam.matrix_world.to_quaternion() @ mathutils.Vector((0, 0, -1))
+        print(f"  Camera pos: {loc}, looking: {direction}")
+
+    if engine == 'EEVEE':
+        scene.render.engine = 'BLENDER_EEVEE'
+        scene.eevee.taa_render_samples = 32
+    else:
+        scene.render.engine = 'CYCLES'
+        scene.cycles.samples = 8
+        scene.cycles.use_denoising = False
+
+    bpy.ops.render.render(write_still=True)
+    print(f"Test frame rendered to {test_path}")
+
+
+# ---------------------------------------------------------------------------
+# MAIN
+# ---------------------------------------------------------------------------
+def main():
+    args = parse_args()
+
+    # Apply overrides
+    if args.res:
+        CONFIG["resolution_x"] = 1920 if args.res == 1080 else 1280
+        CONFIG["resolution_y"] = 1080 if args.res == 1080 else 720
+    if args.samples:
+        CONFIG["samples"] = args.samples
+    if args.output:
+        CONFIG["output_dir"] = args.output
+
+    print(f"=== Molecular Gigafactory Scene Generator ===")
+    print(f"Resolution: {CONFIG['resolution_x']}x{CONFIG['resolution_y']}")
+    print(f"Samples: {CONFIG['samples']}")
+    print(f"Output: {CONFIG['output_dir']}")
+
+    # Build scene
+    print("Clearing scene...")
+    clear_scene()
+
+    print("Setting up world...")
+    setup_world()
+
+    print("Building MR1 device models...")
+    mr1_lod0 = build_mr1_lod0()
+    mr1_lod1 = build_mr1_lod1()
+    mr1_lod2 = build_mr1_lod2()
+
+    print("Building facility...")
+    build_facility(mr1_lod0, mr1_lod1, mr1_lod2)
+
+    print("Setting up camera animation...")
+    setup_camera_animation()
+
+    print("Creating annotations...")
+    create_annotations()
+
+    if args.test:
+        print(f"Test render at frame {args.frame}...")
+        render_test_frame(args.frame, 'EEVEE')
+    elif args.render_all:
+        engine = 'CYCLES'
+        print(f"Configuring {engine} render engine...")
+        configure_render(engine)
+
+        if args.phase == "all":
+            for phase_key in ["A", "B", "C", "D", "E"]:
+                print(f"\n--- Phase {phase_key}: {PHASES[phase_key]['name']} ---")
+                render_phase(phase_key, engine)
+        else:
+            render_phase(args.phase, engine)
+
+        print("\n=== All rendering complete ===")
+    else:
+        print("No action specified. Use --test or --render-all.")
+        print("Scene built successfully — ready for rendering.")
+
+
+if __name__ == "__main__":
+    main()