Merge branch 'master' into remove_define_var

2026-08-14 12:38:27 +00:00 · 2026-06-17 17:50:53 -07:00 · 2026-06-17 16:40:59 -07:00 · 2026-06-17 15:58:57 -07:00 · 2026-06-17 11:29:59 -07:00 · 2026-06-17 11:03:30 -07:00
209 changed files with 740 additions and 13908 deletions
@@ -80,7 +80,7 @@ runs:
    - name: Cache Python packages (PR)
      if: github.event_name == 'pull_request'
      id: restore-venv-pr
-      uses: actions/cache/restore@v5
+      uses: actions/cache/restore@v4
      with:
        path: /tmp/.uv-cache
        key: uv-${{ runner.os }}-${{ runner.arch }}-python-${{ inputs.python-version }}-${{ inputs.deps }}-${{ inputs.pydeps }}-${{ env.CACHE_VERSION }}
@@ -96,7 +96,7 @@ runs:

    - name: Cache downloads (PR)
      if: inputs.key != '' && github.event_name == 'pull_request'
-      uses: actions/cache/restore@v5
+      uses: actions/cache/restore@v4
      with:
        path: ${{ runner.os == 'Linux' && '~/.cache/tinygrad/downloads/' || '~/Library/Caches/tinygrad/downloads/' }}
        key: downloads-${{ github.job }}-${{ inputs.key }}-${{ env.CACHE_VERSION }}
@@ -203,7 +203,7 @@ runs:

    - name: Cache apt (PR)
      if: runner.os == 'Linux' && (inputs.opencl == 'true' || inputs.amd == 'true' || inputs.webgpu == 'true' || inputs.llvm == 'true' || inputs.qemu == 'true') && github.event_name == 'pull_request'
-      uses: actions/cache/restore@v5
+      uses: actions/cache/restore@v4
      with:
        path: /var/cache/apt/archives/
        key: ${{ runner.os }}-${{ runner.arch }}-apt-${{ steps.apt-pkgs.outputs.hash }}-${{ env.CACHE_VERSION }}
@@ -99,6 +99,7 @@ jobs:
        ln -s ~/tinygrad/extra/disassemblers/applegpu extra/disassemblers/applegpu
        ln -s ~/tinygrad/weights/sd-v1-4.ckpt weights/sd-v1-4.ckpt
        ln -s ~/tinygrad/weights/bpe_simple_vocab_16e6.txt.gz weights/bpe_simple_vocab_16e6.txt.gz
+        ln -s ~/tinygrad/weights/LLaMA weights/LLaMA
        ln -s ~/tinygrad/extra/datasets/cifar-10-python.tar.gz extra/datasets/cifar-10-python.tar.gz
    - name: setup staging db
      if: github.ref == 'refs/heads/update_benchmark_staging'
@@ -133,10 +134,32 @@ jobs:
      run: DEBUG=2 SHOULD_USE_TC=1 BFLOAT16=1 python3.11 extra/gemm/simple_matmul.py
    - name: Fuzz Padded Tensor Core GEMM
      run: DEV=METAL M_START=6 M_STOP=10 M_STEP=1 N_START=6 N_STOP=10 N_STEP=1 K_START=6 K_STOP=24 K_STEP=1 TC_OPT=2 DEBUG=2 python3.11 ./extra/gemm/fuzz_matmul.py
-    - name: Run llama3.2
-      run: BENCHMARK_LOG=llama32_3b-f16 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3.11 -m tinygrad.llm -m llama3.2:3b-f16 --benchmark --warmup
-    - name: Run olmoe
-      run: BENCHMARK_LOG=olmoe JITBEAM=2 IGNORE_BEAM_CACHE=1 python3.11 -m tinygrad.llm -m olmoe --benchmark --warmup
+    - name: Run LLaMA
+      run: |
+        BENCHMARK_LOG=llama_nojit JIT=0 python3.11 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=llama JIT=1 python3.11 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run LLaMA with BEAM
+      run: BENCHMARK_LOG=llama_beam JITBEAM=2 IGNORE_BEAM_CACHE=1 python3.11 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run quantized LLaMA
+      run: |
+        BENCHMARK_LOG=llama_int8 python3.11 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing --quantize int8
+        BENCHMARK_LOG=llama_nf4 python3.11 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing --quantize nf4
+    - name: Run quantized LLaMA3
+      run: |
+        BENCHMARK_LOG=llama3_int8 python3.11 examples/llama3.py --size 8B --temperature 0 --benchmark --quantize int8
+        BENCHMARK_LOG=llama3_nf4 python3.11 examples/llama3.py --size 8B --temperature 0 --benchmark --quantize nf4
+    #- name: Run LLaMA 7B on 4 (virtual) GPUs
+    #  run: python3.11 examples/llama.py --gen 1 --size 7B --shard 4 --prompt "Hello." --count 10 --temperature 0  --timing
+    - name: Run GPT2
+      run: |
+        BENCHMARK_LOG=gpt2_nojit JIT=0 python3.11 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=gpt2 JIT=1 ASSERT_MIN_STEP_TIME=13 python3.11 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF
+      run: BENCHMARK_LOG=gpt2_half HALF=1 python3.11 examples/gpt2.py --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF/BEAM
+      run: BENCHMARK_LOG=gpt2_half_beam HALF=1 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3.11 examples/gpt2.py --count 10 --temperature 0 --timing
+    - name: Run OLMoE
+      run: BENCHMARK_LOG=olmoe python3.11 examples/olmoe.py
    - name: Train MNIST
      run: time PYTHONPATH=. TARGET_EVAL_ACC_PCT=96.0 python3.11 examples/beautiful_mnist.py

@@ -212,6 +235,9 @@ jobs:
    - name: Symlink models and datasets
      run: |
        mkdir -p weights
+        ln -s ~/tinygrad/weights/LLaMA weights/LLaMA
+        ln -s /raid/weights/mixtral-8x7b-32kseqlen weights/mixtral-8x7b-32kseqlen
+        ln -s /raid/weights/LLaMA-2 weights/LLaMA-2
        ln -s /raid/weights/LLaMA-3 weights/LLaMA-3
        mkdir -p extra/datasets
        ln -s /raid/datasets/imagenet extra/datasets/imagenet
@@ -253,16 +279,36 @@ jobs:
    # TODO: too slow
    # - name: Run SDXL
    #   run: BENCHMARK_LOG=stable_diffusion_xl ASSERT_MIN_STEP_TIME=2000 CAPTURE_PROCESS_REPLAY=0 DEV=NV CAPTURE_PROCESS_REPLAY=0 python3 examples/sdxl.py --seed 0 --noshow --timing
-    - name: Run llama3.2
-      run: DEV=NV BENCHMARK_LOG=llama32_3b-f16 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 -m tinygrad.llm -m llama3.2:3b-f16 --benchmark --warmup
-    - name: Run qwen3.5
-      run: DEV=NV BENCHMARK_LOG=qwen35_35b-a3b JITBEAM=2 IGNORE_BEAM_CACHE=1 CAPTURE_PROCESS_REPLAY=0 python3 -m tinygrad.llm -m qwen3.5:35b-a3b --benchmark --warmup
+    - name: Run LLaMA
+      run: |
+        BENCHMARK_LOG=llama_nojit DEV=NV JIT=0 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=llama DEV=NV JIT=1 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run LLaMA with BEAM
+      run: BENCHMARK_LOG=llama_beam DEV=NV JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    # - name: Run LLaMA 7B on 4 GPUs
+    #   run: DEV=NV CAPTURE_PROCESS_REPLAY=0 python3 examples/llama.py --gen 1 --size 7B --shard 4 --prompt "Hello." --count 10 --temperature 0  --timing
+    # - name: Run LLaMA 7B on 6 GPUs
+    #   run: DEV=NV CAPTURE_PROCESS_REPLAY=0 python3 examples/llama.py --gen 1 --size 7B --shard 6 --prompt "Hello." --count 10 --temperature 0  --timing
+    - name: Run LLaMA-3 8B BEAM
+      run: BENCHMARK_LOG=llama3_beam DEV=NV JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/llama3.py --size 8B --model weights/LLaMA-3/8B-SF-DPO/ --benchmark --temperature 0
    - name: Run LLaMA-3 8B on 4 GPUs with BEAM
      run: BENCHMARK_LOG=llama3_beam_4gpu DEV=NV JITBEAM=2 IGNORE_BEAM_CACHE=1 CAPTURE_PROCESS_REPLAY=0 python3 examples/llama3.py --size 8B --shard 4 --model weights/LLaMA-3/8B-SF-DPO/ --benchmark --temperature 0
+    - name: Run quantized LLaMA3
+      run: BENCHMARK_LOG=llama3_fp8 python3 examples/llama3.py --size 8B --model weights/LLaMA-3/8B-SF-DPO/ --temperature 0 --benchmark --quantize fp8
    # - name: Run LLaMA-3 8B on 6 GPUs
    #   run: DEV=NV CAPTURE_PROCESS_REPLAY=0 python3 examples/llama3.py --size 8B --shard 6 --model weights/LLaMA-3/8B-SF-DPO/ --benchmark --temperature 0
    # - name: Run LLaMA-2 70B
    #   run: DEV=NV CAPTURE_PROCESS_REPLAY=0 MAX_CONTEXT=256 python3 examples/llama.py --gen 2 --size 70B --shard 6 --prompt "Hello." --count 10 --temperature 0  --timing
+    - name: Run Mixtral 8x7B
+      run: time BENCHMARK_LOG=mixtral DEV=NV CAPTURE_PROCESS_REPLAY=0 python3 examples/mixtral.py --temperature 0 --count 10 --timing
+    - name: Run GPT2
+      run: |
+        BENCHMARK_LOG=gpt2_nojit DEV=NV JIT=0 python3 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=gpt2 DEV=NV JIT=1 ASSERT_MIN_STEP_TIME=4 python3 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF
+      run: BENCHMARK_LOG=gpt2_half DEV=NV HALF=1 ASSERT_MIN_STEP_TIME=6 python3 examples/gpt2.py --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF/BEAM
+      run: BENCHMARK_LOG=gpt2_half_beam DEV=NV HALF=1 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/gpt2.py --count 10 --temperature 0 --timing
    - uses: actions/upload-artifact@v7
      with:
        name: Speed (NVIDIA)
@@ -356,7 +402,10 @@ jobs:
      run: |
        mkdir -p weights
        ln -s ~/tinygrad/weights/bpe_simple_vocab_16e6.txt.gz weights/bpe_simple_vocab_16e6.txt.gz
+        ln -s ~/tinygrad/weights/LLaMA weights/LLaMA
        ln -s ~/tinygrad/extra/datasets/cifar-10-python.tar.gz extra/datasets/cifar-10-python.tar.gz
+        ln -s /raid/weights/mixtral-8x7b-32kseqlen weights/mixtral-8x7b-32kseqlen
+        ln -s /raid/weights/LLaMA-2 weights/LLaMA-2
        ln -s /raid/weights/LLaMA-3 weights/LLaMA-3
        mkdir -p extra/datasets
        ln -s /raid/datasets/imagenet extra/datasets/imagenet
@@ -409,10 +458,18 @@ jobs:
      run: BENCHMARK_LOG=stable_diffusion ASSERT_MIN_STEP_TIME=550 DEV=AMD python3 examples/stable_diffusion.py --fp16 --seed 0 --noshow --timing
    - name: Run SDXL
      run: BENCHMARK_LOG=stable_diffusion_xl ASSERT_MIN_STEP_TIME=3200 CAPTURE_PROCESS_REPLAY=0 DEV=AMD python3 examples/sdxl.py --seed 0 --noshow --timing
-    - name: Run llama3.2
-      run: DEV=AMD BENCHMARK_LOG=llama32_3b-f16 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 -m tinygrad.llm -m llama3.2:3b-f16 --benchmark --warmup
-    - name: Run qwen3.5
-      run: DEV=AMD BENCHMARK_LOG=qwen35_35b-a3b JITBEAM=2 IGNORE_BEAM_CACHE=1 CAPTURE_PROCESS_REPLAY=0 python3 -m tinygrad.llm -m qwen3.5:35b-a3b --benchmark --warmup
+    - name: Run LLaMA 7B
+      run: |
+        BENCHMARK_LOG=llama_nojit DEV=AMD JIT=0 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=llama DEV=AMD JIT=1 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run LLaMA 7B with BEAM
+      run: BENCHMARK_LOG=llama_beam DEV=AMD JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/llama.py --gen 1 --prompt "Hello." --count 10 --temperature 0 --timing
+    # - name: Run LLaMA 7B on 4 GPUs
+    #   run: DEV=AMD CAPTURE_PROCESS_REPLAY=0 python3 examples/llama.py --gen 1 --size 7B --shard 4 --prompt "Hello." --count 10 --temperature 0  --timing
+    # - name: Run LLaMA 7B on 6 GPUs
+    #   run: DEV=AMD CAPTURE_PROCESS_REPLAY=0 python3 examples/llama.py --gen 1 --size 7B --shard 6 --prompt "Hello." --count 10 --temperature 0  --timing
+    - name: Run LLaMA-3 8B BEAM
+      run: BENCHMARK_LOG=llama3_beam DEV=AMD JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/llama3.py --size 8B --model weights/LLaMA-3/8B-SF-DPO/ --benchmark --temperature 0
    - name: Run LLaMA-3 8B on 4 GPUs with BEAM
      run: BENCHMARK_LOG=llama3_beam_4gpu DEV=AMD JITBEAM=2 IGNORE_BEAM_CACHE=1 CAPTURE_PROCESS_REPLAY=0 python3 examples/llama3.py --size 8B --shard 4 --model weights/LLaMA-3/8B-SF-DPO/ --benchmark --temperature 0
    # - name: Run LLaMA-3 8B on 6 GPUs
@@ -421,6 +478,16 @@ jobs:
    #  run: sudo modprobe amdgpu
    # - name: Run LLaMA-2 70B
    #   run: DEV=AMD CAPTURE_PROCESS_REPLAY=0 python3 examples/llama.py --gen 2 --size 70B --shard 6 --prompt "Hello." --count 10 --temperature 0  --timing
+    - name: Run Mixtral 8x7B
+      run: time BENCHMARK_LOG=mixtral DEV=AMD python3 examples/mixtral.py --temperature 0 --count 10 --timing
+    - name: Run GPT2
+      run: |
+        BENCHMARK_LOG=gpt2_nojit DEV=AMD JIT=0 python3 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+        BENCHMARK_LOG=gpt2 DEV=AMD JIT=1 ASSERT_MIN_STEP_TIME=5 python3 examples/gpt2.py --prompt "Hello." --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF
+      run: BENCHMARK_LOG=gpt2_half DEV=AMD HALF=1 ASSERT_MIN_STEP_TIME=5 python3 examples/gpt2.py --count 10 --temperature 0 --timing
+    - name: Run GPT2 w HALF/BEAM
+      run: BENCHMARK_LOG=gpt2_half_beam DEV=AMD HALF=1 JITBEAM=2 IGNORE_BEAM_CACHE=1 python3 examples/gpt2.py --count 10 --temperature 0 --timing
    - name: Run process replay tests
      uses: ./.github/actions/process-replay

@@ -218,15 +218,14 @@ jobs:
      uses: ./.github/actions/setup-tinygrad
      with:
        key: unittest-13
+        pydeps: "pillow ftfy regex pre-commit"
        deps: testing_unit
        llvm: 'true'
        amd: 'true'
    - name: Run NULL backend tests
      run: DEV=NULL python -m pytest -n=auto test/null/ --durations=20
    - name: Run targeted tests on NULL backend
-      run: |
-        DEV=NULL python3 -m unittest test.backend.test_multitensor.TestMultiTensor.test_data_parallel_resnet_train_step
-        DEV=NULL VIZ=1 python3 -m pytest -n=auto test/null/test_viz.py
+      run: DEV=NULL python3 -m unittest test.backend.test_multitensor.TestMultiTensor.test_data_parallel_resnet_train_step
    # TODO: too slow
    # - name: Run SDXL on NULL backend
    #   run: DEV=NULL DEBUG=1 python3 examples/sdxl.py --seed 0 --noshow --timing --fakeweights
@@ -250,7 +249,7 @@ jobs:
      uses: ./.github/actions/setup-tinygrad
      with:
        key: unittest-13
-        pydeps: "pre-commit"
+        pydeps: "pillow ftfy regex pre-commit"
        deps: testing_unit
        llvm: 'true'
    - name: Run pre-commit test hooks
@@ -469,7 +468,7 @@ jobs:
 # ****** Models Tests ******

  testmodels:
-    name: Models
+    name: Models (llvm+cpu+gpu)
    runs-on: *linux
    timeout-minutes: 15
    steps:
@@ -480,12 +479,34 @@ jobs:
        with:
          key: models
          deps: testing
+          opencl: 'true'
          llvm: 'true'
+      - name: Test models (llvm)
+        run: DEV=CPU:LLVM python -m pytest -n=auto test/models --durations=20
+      - name: Test models (opencl)
+        run: DEV=CL python -m pytest -n=auto test/models --durations=20
      - name: Test models (cpu)
        run: DEV=CPU python -m pytest -n=auto test/models --durations=20
      - name: Run process replay tests
        uses: ./.github/actions/process-replay

+  testmetalmodels:
+    name: Models (metal)
+    runs-on: &macos macos-26
+    timeout-minutes: 20
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v6
+    - name: Setup Environment
+      uses: ./.github/actions/setup-tinygrad
+      with:
+        key: metal
+        deps: testing
+    - name: Test models (Metal)
+      run: DEV=METAL python -m pytest -n=auto test/models --durations=20
+    - name: Test LLaMA compile speed
+      run: DEV=METAL python test/external/external_test_speed_llama.py
+
 # ****** Feature Tests ******

  testdsp:
@@ -694,7 +715,7 @@ jobs:

  unittestmacos:
    name: MacOS (unit)
-    runs-on: &macos macos-26
+    runs-on: *macos
    timeout-minutes: 20
    steps:
    - name: Checkout Code
@@ -1,5 +1,5 @@
 from typing import Tuple, Dict, List, Optional
-from tinygrad.dtype import DType, dtypes, AddrSpace
+from tinygrad.dtype import DType, dtypes
 from tinygrad.tensor import Tensor
 from tinygrad.device import Device, Buffer
 from tinygrad.engine.jit import TinyJit
@@ -39,7 +39,7 @@ def compile_net(linear:UOp, output_bufs:List[Buffer]) -> Tuple[Dict[str,str], Li
    prg = to_program(call.src[0], Device[arg_uops[0].device].renderer)
    info = prg.arg
    functions[info.function_name] = prg.src[3].arg
-    cargs = [name_of(bu, i == 0) for i, bu in enumerate(arg_uops)] + list(info.vars)
+    cargs = [name_of(bu, i == 0) for i, bu in enumerate(arg_uops)] + [v for v in info.vars if v.op is Ops.DEFINE_VAR]
    statements.append((info.function_name, cargs, info.global_size, info.local_size))

  return functions, statements, {name:(size, dtype, key) for name, size, dtype, key in bufs.values()}, bufs_to_save
@@ -253,18 +253,17 @@ def export_model(model, target:str, *inputs, model_name: Optional[str] = "model"
  symbolic_vars = OrderedDict()
  for i, (_, args, global_size, _) in enumerate(statements):
    for j, var in enumerate(args):
-      if getattr(var, "op", None) is Ops.PARAM and var.addrspace is AddrSpace.ALU and var.arg.name is not None:
+      if getattr(var, "op", None) is Ops.DEFINE_VAR and isinstance(getattr(var, "arg", None), tuple) and isinstance(var.arg[0], str):
        if var not in symbolic_vars:
-          symbolic_vars[var] = var.expr
+          symbolic_vars[var] = var.arg[0]
          bufs[symbolic_vars[var]] = (var.dtype.itemsize, var.dtype, symbolic_vars[var])
        statements[i][1][j] = symbolic_vars[var]

    if global_size:
      for j, dim in enumerate(global_size):
-        if getattr(dim, "op", None) is Ops.ADD and len(dim.src) == 2 and \
-           any(s.op is Ops.PARAM and s.addrspace is AddrSpace.ALU for s in dim.src) and any(s.op is Ops.CONST for s in dim.src):
+        if getattr(dim, "op", None) is Ops.ADD and len(dim.src) == 2 and {dim.src[0].op, dim.src[1].op} == {Ops.DEFINE_VAR, Ops.CONST}:
          name, val = dim.src if dim.src[1].op is Ops.CONST else reversed(dim.src)
-          global_size[j] = f"_{name.expr}[0] + {val.arg}"
+          global_size[j] = f"_{name.arg[0]}[0] + {val.arg}"

  prg = ""
  if target == "clang":
@@ -458,8 +458,7 @@ def test_matmul():
  def asm_kernel(A:UOp, B:UOp, C:UOp) -> UOp:
    gidxs = [UOp.special(n, f"gidx{i}") for i,n in enumerate(grid)]
    lidxs = [UOp.special(n, f"lidx{i}") for i,n in enumerate(local)]
-    lds_size = max(LDS_SIZE, 65536//getenv("LIMIT_OCC", 65536))
-    lds = UOp.placeholder((lds_size,), dtypes.uint8, 0, AddrSpace.LOCAL)
+    lds = UOp(Ops.DEFINE_LOCAL, dtypes.uint8.ptr(size=max(LDS_SIZE, 65536//getenv("LIMIT_OCC", 65536)), addrspace=AddrSpace.LOCAL), (), 'lds')
    sink = UOp.sink(A.base, B.base, C.base, lds, *gidxs, *lidxs, arg=KernelInfo(name=colored("kernel", "cyan"),
                                                                                  estimates=Estimates(ops=N*N*N*2, mem=N*N*4*3)))
    return UOp(Ops.PROGRAM, src=(sink, UOp(Ops.DEVICE, arg=dname), UOp(Ops.LINEAR, src=tuple([UOp(Ops.INS, arg=x) for x in insts]))))
@@ -126,7 +126,7 @@ def amd_flash_attention(o:UOp, q:UOp, k:UOp, v:UOp) -> UOp:
  P_lds = QP_lds[:, :BLOCK_N]
  P_write = P_lds.reshape(WAVES_M, TM // WMMA_ACC, WMMA_ACC, LANES_PER_WAVE_M, WAVES_N, TN, LANES_PER_WAVE_N)
  P_write = P_write.permute((0, 4, 3, 6, 1, 2, 5)).reshape(THREADS_PER_BLOCK, TM, TN)
-  # TODO: P_write[tid].store(S_reg.cast(dtypes.half)) -- shaped store fails due to RESHAPE(local BUFFER) surviving linearization
+  # TODO: P_write[tid].store(S_reg.cast(dtypes.half)) — shaped store fails due to RESHAPE(DEFINE_LOCAL) surviving linearization
  rw1 = UOp.range(TM, 296, AxisType.LOOP)
  rw2 = UOp.range(TN, 297, AxisType.LOOP)
  P_store = P_write[tid, rw1, rw2].store(S_reg[rw1, rw2].cast(dtypes.half)).end(rw1, rw2)
@@ -2619,7 +2619,7 @@ def custom_asm_gemm(C:UOp, A:UOp, B:UOp, dname:str) -> UOp:
  lidx = UOp.special(WORKGROUP_SIZE, "lidx0")
  gidx = UOp.special(NUM_WG, "gidx0")
  insts = build_kernel(batch, M, N, K, A.dtype.base)
-  lds = UOp.placeholder((133_120,), dtypes.uint8, 0, AddrSpace.LOCAL)
+  lds = UOp(Ops.DEFINE_LOCAL, dtypes.uint8.ptr(size=133_120, addrspace=AddrSpace.LOCAL), (), 'lds')
  sink = UOp.sink(C.base, A.base, B.base, lds, lidx, gidx,
                  arg=KernelInfo(name=f"gemm_{batch}_{M}_{N}_{K}", estimates=Estimates(ops=2*batch*M*N*K, mem=(batch*M*K + K*N + batch*M*N)*2)))
  return UOp(Ops.PROGRAM, src=(sink, UOp(Ops.DEVICE, arg=dname),
@@ -219,8 +219,7 @@ def test_matmul():
  def asm_kernel(A, B, C):
    gidxs = [UOp.special(n, f"gidx{i}") for i,n in enumerate(grid)]
    lidxs = [UOp.special(THREADS, "lidx0")]
-    lds_size = max(LDS_SIZE, 65536//getenv("LIMIT_OCC",2))
-    lds = UOp.placeholder((lds_size,), dtypes.uint8, 0, AddrSpace.LOCAL)
+    lds = UOp(Ops.DEFINE_LOCAL, dtypes.uint8.ptr(size=max(LDS_SIZE, 65536//getenv("LIMIT_OCC",2)), addrspace=AddrSpace.LOCAL), (), 'lds')
    sink = UOp.sink(A.base, B.base, C.base, lds, *gidxs, *lidxs,
                    arg=KernelInfo(name=colored("kernel","cyan"), estimates=Estimates(ops=N*N*N*2, mem=N*N*2*3)))
    return UOp(Ops.PROGRAM, src=(sink, UOp(Ops.DEVICE, arg=dname), UOp(Ops.LINEAR, src=tuple([UOp(Ops.INS, arg=x) for x in insts]))))
@@ -7,7 +7,7 @@ from tinygrad.helpers import to_tuple, round_up
 from tinygrad.device import Device, Buffer, BufferSpec, Compiled, LRUAllocator, MultiBuffer
 from tinygrad.uop.ops import Ops, sint, UOp, UPat, PatternMatcher, KernelInfo, graph_rewrite, track_rewrites, GroupOp
 from tinygrad.uop.symbolic import symbolic_simple, symbolic
-from tinygrad.dtype import dtypes, AddrSpace
+from tinygrad.dtype import dtypes
 from tinygrad.runtime.support.hcq import MMIOInterface
 from tinygrad.renderer import Renderer, Estimates
 from tinygrad.engine.realize import to_program, get_call_arg_uops, get_call_name, get_call_outs_ins, estimate_uop, pm_flatten_linear
@@ -288,25 +288,18 @@ def schedule_inner_sync(ctx:DepsCtx, linear:UOp) -> UOp:
      new_src.append(call)
      continue

-    new_q = ctx.last_per_queue[q.arg] = (q:=get_submit(call.src[0]).src[0]).rtag(next(ctx.opid))
-    qdevs, refs = to_tuple(new_q.arg[0]), get_call_arg_uops(call)
+    q = get_submit(call.src[0]).src[0]
+    new_q = ctx.last_per_queue[q.arg] = q.rtag(next(ctx.opid))

-    # per-lane deps, tracked per (device, queue). skip self
-    dep_lanes:list[tuple[UOp, int]] = []
-    for lane, d in enumerate(qdevs):
-      for dep in ctx.deps.access_resources([get_dep_buf(ctx, b, lane) for b in refs], call.arg.aux.outs, new_q.replace(arg=(d, new_q.arg[1]))):
-        if dep.tag != new_q.tag: dep_lanes.append((dep, lane))
+    refs = get_call_arg_uops(call)
+    deps = dedup(flatten(ctx.deps.access_resources([get_dep_buf(ctx, b, l) for b in refs], call.arg.aux.outs, new_q) for l in range(len(q.arg[0]))))

-    # drop self-queue waits, queue self-orders
-    if qdevs[0].split(":")[0] in {"AMD", "QCOM"} or new_q.arg[1].startswith("COPY"):
-      dep_lanes = [(dep, lane) for dep, lane in dep_lanes if dep.arg != (qdevs[lane], new_q.arg[1])]
+    # optims: keep only the max wait per queue, and drop self-queue waits when the queue self-orders
+    deps = {dep.arg:dep for dep in sorted(deps, key=lambda x: x.tag)}
+    if to_tuple(new_q.arg[0])[0].split(":")[0] in {"AMD", "QCOM"} or new_q.arg[1].startswith("COPY"):
+      deps.pop(new_q.arg, None)

-    # keep latest dep per lane, group lanes
-    latest = {(dep.arg, lane): dep for dep, lane in sorted(dep_lanes, key=lambda x: x[0].tag)}
-    deps:dict[UOp, tuple[int, ...]] = collections.defaultdict(tuple)
-    for (_, lane), dep in latest.items(): deps[dep] += (lane,)
-
-    if deps: new_q = new_q.after(*deps, arg=tuple(deps.values())).rtag("deps")
+    new_q = new_q.after(*deps.values()).rtag("deps") if deps else new_q
    new_src.append(call.replace(src=(call.src[0].substitute({q:new_q}), *call.src[1:])))
  return linear.replace(src=tuple(new_src))
 pm_schedule_inner_sync = PatternMatcher([(UPat(Ops.LINEAR, name="linear"), schedule_inner_sync)])
@@ -321,10 +314,7 @@ def make_finalizer(queues:list[UOp], nbump:int) -> UOp:

  # queue is inc with deps
  submit = make_submit(make_signal(devs).store(tl.index(zero)), devs=devs, queue="COMPUTE:0")
-
-  # split each (multi-device) queue into per-device deps so each finalizer lane waits on the matching device's signal
-  lane_queues = [(q.replace(arg=(d, q.arg[1])), (devs.index(d),)) for q in queues for d in to_tuple(q.arg[0])]
-  submit = submit.replace(src=(submit.src[0].after(*(q for q, _ in lane_queues), arg=tuple(l for _, l in lane_queues)).rtag("deps"),))
+  submit = submit.replace(src=(submit.src[0].after(*queues).rtag("deps"),))

  upd = [(tl, 1)] + [(make_signal_value(devs, queue=qn), nbump) for qn in dedup([q.arg[1] for q in queues])]
  patches = [s.after(submit).index(zero, dtype=s.dtype.ptr()).store(s.index(zero) + inc) for s, inc in upd]
@@ -345,14 +335,12 @@ def add_loads(ctx:set[int], deps:UOp) -> UOp:
  cur_devs = to_tuple((cur:=deps.src[0]).arg[0])

  waits = []
-  for lanes, dep in zip(deps.arg, deps.src[1:]):
-    dep_dev, queue = dep.arg # dep_dev is a single device (deps are recorded per-device)
+  for dep in deps.src[1:]:
+    devs, queue = dep.arg
    ctx.add(dep.tag) # mark op to update signal.

-    # for lanes that need this dep, wait on the dep device's signal/value; other lanes get a passing sentinel
-    lanes = set(lanes)
-    sig = make_mstack([make_signal(dep_dev if j in lanes else d, queue=queue, sentinel=j not in lanes) for j, d in enumerate(cur_devs)])
-    val = make_mstack([make_signal_value(dep_dev if j in lanes else d, queue=queue) for j, d in enumerate(cur_devs)]).index(UOp.const(dtypes.int, 0))
+    sig = make_mstack([make_signal(d, queue=queue, sentinel=d not in devs) for d in cur_devs])
+    val = make_signal_value(cur_devs, queue=queue).index(UOp.const(dtypes.int, 0))
    waits.append(sig.wait(val + dep.tag))
  return cur.replace(src=tuple(waits) + cur.src)
 pm_add_inner_loads = PatternMatcher([(UPat(Ops.AFTER, tag="deps", name="deps"), add_loads)])
@@ -383,8 +371,7 @@ def merge_queues(linear:UOp) -> UOp:
  opened_qs:dict[tuple[tuple[str, ...], str], tuple[list[UOp], HCQInfo]] = {} # (devs, queue) -> (sinks, aux), kept in submit order

  for call in linear.src:
-    # finalizer cannot be merged, since it bumps inner signal (this introduces race when multidevs).
-    if call.tag != "hcq" or (call.tag == "hcq" and call.arg.aux.name == "hcq finalizer"):
+    if call.tag != "hcq":
      new_src += [merge_sink((sa:=opened_qs.pop(k))[0]).call(aux=sa[1]).rtag("hcq") for k in list(opened_qs)] + [call]
      continue

@@ -423,7 +410,7 @@ pm_annotate_devs = PatternMatcher([(UPat(Ops.CALL, tag="hcq", name="call"),
 # 4.4. replace params with per-submit input address loads

 def replace_params(call:UOp) -> UOp|None:
-  if not (params:={u:u.arg.slot for u in call.src[0].toposort() if u.op is Ops.PARAM and u.addrspace is AddrSpace.GLOBAL}): return None
+  if not (params:={u:u.arg.slot for u in call.src[0].toposort() if u.op is Ops.PARAM and u.addrspace is not None}): return None

  # fill new info
  hcqinfo = replace(call.arg.aux, params=tuple(sorted(set(params.values()))), inputs=len(get_call_arg_uops(call)))
@@ -517,11 +504,8 @@ def fold_const_store(buf:UOp, off:UOp, val:UOp) -> UOp:

 def resolve_getaddr(buf:UOp, g:UOp) -> UOp:
  if buf.op not in (Ops.BUFFER, Ops.MSTACK, Ops.MSELECT): return buf
-  devs, b = to_tuple(g.src[1].arg), buf.buffer
-  bufs = tuple(cast(Buffer, x.buffer) for x in buf.src) if buf.op is Ops.MSTACK else tuple(b.bufs if isinstance(b, MultiBuffer) else (b,)*len(devs))
-  assert len(bufs) == len(devs), f"can't resolve {len(bufs)} buffers on {len(devs)} devices"
-  addrs = tuple(UOp.const(dtypes.uint64, x.get_buf(d).va_addr) for x, d in zip(bufs, devs))
-  return addrs[0] if len(addrs) == 1 else UOp(Ops.STACK, dtypes.uint64.vec(len(addrs)), addrs)
+  if isinstance(b:=buf.buffer, Buffer): return UOp.const(dtypes.uint64, b.get_buf(g.src[1].arg).va_addr)
+  return UOp(Ops.STACK, dtypes.uint64.vec(len(b.bufs)), tuple(UOp.const(dtypes.uint64, x.ensure_allocated()._buf.va_addr) for x in b.bufs))

 def resolve_getaddr_slice(bv:UOp, dev:UOp) -> UOp:
  itemsize = bv.src[0].dtype.itemsize if unwrap_after(bv.src[0]).op in (Ops.BUFFER, Ops.SLICE, Ops.MSTACK, Ops.MSELECT) else bv.dtype.itemsize
@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import cast, Any, Callable
+from typing import cast
 import os, ctypes, struct, hashlib, functools, importlib, mmap, errno, array, contextlib, sys, weakref, itertools, collections, atexit
 assert sys.platform != 'win32'
 from dataclasses import dataclass
@@ -89,25 +89,25 @@ def memory_barrier(ctx):
                 reg_done=getattr(ctx.nbio, f'regBIF_BX_PF{pf}_GPU_HDP_FLUSH_DONE').addr[0], value=0xffffffff),
    acquire_mem(ctx)))

-def pm4_wait(ctx, dst, val): return wait_reg_mem(ctx, val, mem=make_getaddr(dst, ctx.devs))
+def pm4_wait(ctx, dst, val): return wait_reg_mem(ctx, val, mem=make_getaddr(dst, ctx.device))

 def pm4_barrier(ctx): return memory_barrier(ctx)

 def pm4_store(ctx, dst, val):
  if val.op is Ops.BINARY: return None
-  return release_mem(ctx, make_getaddr(dst, ctx.devs), val, ctx.pm4.data_sel__mec_release_mem__send_32_bit_low,
+  return release_mem(ctx, make_getaddr(dst, ctx.device), val, ctx.pm4.data_sel__mec_release_mem__send_32_bit_low,
                     ctx.pm4.int_sel__mec_release_mem__send_interrupt_after_write_confirm, cache_flush=True)

 def pm4_timestamp(ctx, dst):
-  return release_mem(ctx, make_getaddr(dst, ctx.devs), 0, ctx.pm4.data_sel__mec_release_mem__send_gpu_clock_counter,
+  return release_mem(ctx, make_getaddr(dst, ctx.device), 0, ctx.pm4.data_sel__mec_release_mem__send_gpu_clock_counter,
                     ctx.pm4.int_sel__mec_release_mem__none)

 def pm4_program(ctx, prg):
  data, info = prg.arg
  lib_gpu, args = prg.src
-  prog_addr = make_getaddr(lib_gpu, ctx.devs) + data.entry_point_offset
-  scratch_addr = make_getaddr(UOp.new_buffer(lib_gpu.device, data.private_segment_size, dtypes.uint8).rtag("scratch"), ctx.devs)
-  args_addr = make_getaddr(args, ctx.devs)
+  prog_addr = make_getaddr(lib_gpu, ctx.device) + data.entry_point_offset
+  scratch_addr = make_getaddr(UOp.new_buffer(lib_gpu.device, data.private_segment_size, dtypes.uint8).rtag("scratch"), ctx.device)
+  args_addr = make_getaddr(args, ctx.device)

  user_regs = []
  if data.enable_private_segment_sgpr:
@@ -174,7 +174,7 @@ pm_pm4_submit = PatternMatcher([(UPat(Ops.LINEAR, name="lin"),
 class SDMAOps(FastEnum): COPY = auto(); POLL_REGMEM = auto(); FENCE = auto(); TRAP = auto(); TIMESTAMP = auto()  # noqa: E702

 def sdma_copy(ctx, dst, src, copy):
-  src_addr, dst_addr = make_getaddr(src, ctx.devs), make_getaddr(dst, ctx.devs)
+  src_addr, dst_addr = make_getaddr(src, ctx.device), make_getaddr(dst, ctx.device)
  return UOp(Ops.LINEAR, dtypes.void, tuple([make_ins(SDMAOps.COPY,
     ctx.sdma.SDMA_OP_COPY | ctx.sdma.SDMA_PKT_COPY_LINEAR_HEADER_SUB_OP(ctx.sdma.SDMA_SUBOP_COPY_LINEAR),
     ctx.sdma.SDMA_PKT_COPY_LINEAR_COUNT_COUNT(min(copy.arg - off, ctx.max_copy_size) - 1), 0,
@@ -183,17 +183,17 @@ def sdma_copy(ctx, dst, src, copy):
 def sdma_wait(ctx, dst, val):
  op = ctx.sdma.SDMA_OP_POLL_REGMEM | ctx.sdma.SDMA_PKT_POLL_REGMEM_HEADER_FUNC(WAIT_REG_MEM_FUNCTION_GEQ) \
     | ctx.sdma.SDMA_PKT_POLL_REGMEM_HEADER_MEM_POLL(1)
-  return make_ins(SDMAOps.POLL_REGMEM, op, *data64_le(make_getaddr(dst, ctx.devs)), val, 0xffffffff,
+  return make_ins(SDMAOps.POLL_REGMEM, op, *data64_le(make_getaddr(dst, ctx.device)), val, 0xffffffff,
    ctx.sdma.SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(0x04) | ctx.sdma.SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff))

 def sdma_store(ctx, dst, val):
  op = ctx.sdma.SDMA_OP_FENCE | (ctx.sdma.SDMA_PKT_FENCE_HEADER_MTYPE(3) if ctx.target[0] != 9 else 0)
  return UOp(Ops.LINEAR, dtypes.void, (
-    make_ins(SDMAOps.FENCE, op, *data64_le(make_getaddr(dst, ctx.devs)), val), make_ins(SDMAOps.TRAP, ctx.sdma.SDMA_OP_TRAP, 0)))
+    make_ins(SDMAOps.FENCE, op, *data64_le(make_getaddr(dst, ctx.device)), val), make_ins(SDMAOps.TRAP, ctx.sdma.SDMA_OP_TRAP, 0)))

 def sdma_timestamp(ctx, dst):
  op = ctx.sdma.SDMA_OP_TIMESTAMP | ctx.sdma.SDMA_PKT_TIMESTAMP_GET_HEADER_SUB_OP(ctx.sdma.SDMA_SUBOP_TIMESTAMP_GET_GLOBAL)
-  return make_ins(SDMAOps.TIMESTAMP, op, *data64_le(make_getaddr(dst, ctx.devs)))
+  return make_ins(SDMAOps.TIMESTAMP, op, *data64_le(make_getaddr(dst, ctx.device)))

 pm_sdma_opsel = PatternMatcher([
  (UPat(Ops.BARRIER), lambda: UOp(Ops.NOOP, dtypes.void, ())),
@@ -516,17 +516,11 @@ class PCIIface(PCIIfaceBase):

 def _mock(iface, name=None): return type(name or f"MOCK{iface.__name__}", (iface,), {})

-@dataclass(frozen=True)
-class AMDEncodeCtx:  # encode-time constants for one queue: devs (every cmdbuf address resolves into these) + gfx version + packet/ip modules
-  devs: tuple[str, ...]; target: tuple[int, ...]; pm4: Any; sdma: Any; soc: Any  # noqa: E702
-  gc: AMDIP; nbio: AMDIP; xccs: int; max_copy_size: int; tmpring_size: Callable  # noqa: E702
-
 def encode_queue(q:UOp) -> UOp|None:
  if not (isinstance(q.arg, tuple) and len(q.arg) == 2 and isinstance(q.arg[1], str) and q.arg[1].startswith(("COMPUTE", "COPY"))): return None
-  d = Device[(devs:=to_tuple(q.arg[0]))[0]]
-  ctx = AMDEncodeCtx(devs, d.target, d.pm4, d.sdma, d.soc, d.gc, d.nbio, d.xccs, d.max_copy_size, d.tmpring_size)
+  devs = to_tuple(q.arg[0])
  opsel, submit = (pm_pm4_opsel, pm_pm4_submit) if q.arg[1].startswith("COMPUTE") else (pm_sdma_opsel, pm_sdma_submit)
-  return submit.rewrite(graph_rewrite(q, opsel + pm_flatten_linear, walk=True, ctx=ctx, name=f"{q.arg[1]} opsel"))
+  return submit.rewrite(graph_rewrite(q, opsel + pm_flatten_linear, walk=True, ctx=Device[devs[0]], name=f"{q.arg[1]} opsel"))

 pm_lower = PatternMatcher([
  (UPat(Ops.CUSTOM_FUNCTION, arg="submit", src=(UPat(Ops.LINEAR, name="q"),)), encode_queue),
@@ -1,71 +0,0 @@
-import functools
-from tinygrad import Tensor, dtypes
-from tinygrad.helpers import prod
-from tinygrad.uop.ops import UOp, Ops, KernelInfo, AxisType
-from extra.llama_kernels import FP8_MAX, THREADS_PER_WG, alloc_like
-
-BLK = 32
-PACK = 4
-
-@functools.cache
-def _custom_quantize_mxfp8(fp8_out:UOp, e8_out:UOp, si_out:UOp, x:UOp) -> UOp:
-  rows, K = x.shape
-  scale_K = K // BLK
-  n_elems = rows * K
-  n_super = n_elems // (BLK * PACK)
-  sk4 = scale_K // PACK
-  assert n_super % THREADS_PER_WG == 0, f"{n_super=} must divide over {THREADS_PER_WG=}"
-  nwg = n_super // THREADS_PER_WG
-
-  x = x.reshape(n_elems)
-  fp8_out = fp8_out.reshape(n_elems)
-  e8_out = e8_out.reshape(rows * scale_K)
-  si_out = si_out.reshape(sk4 * rows)
-
-  wg = UOp.range(nwg, 0, AxisType.GLOBAL)
-  tid = UOp.range(THREADS_PER_WG, 1, AxisType.LOCAL)
-  sb = UOp.range(PACK, 2, AxisType.UNROLL)
-  lane = UOp.range(BLK, 3, AxisType.UNROLL)
-
-  super_idx = wg * THREADS_PER_WG + tid
-  idx = super_idx * (BLK * PACK) + sb * BLK + lane
-
-  x_f = x[idx].cast(dtypes.float)
-  abs_x = (x_f < 0.0).where(-x_f, x_f)
-  blk_max = abs_x.reduce(lane, arg=Ops.MAX)
-  e8f = (blk_max.maximum(1e-38).log2().floor() + 127.0).maximum(0.0).minimum(254.0)
-  qscale = (127.0 - e8f).exp2()
-  scaled = (x_f * qscale).maximum(-FP8_MAX).minimum(FP8_MAX)
-  e8u8 = e8f.cast(dtypes.uint8)
-
-  fp8_store = fp8_out[idx].store(scaled.cast(fp8_out.dtype.base)).end(lane)
-  e8_store = e8_out.after(fp8_store)[super_idx * PACK + sb].store(e8u8)
-
-  # pack the 4 e8 of this super-block into one uint32 (little-endian: byte sb), write transposed (sk4, row)
-  packed = (e8u8.cast(dtypes.uint32) << (sb.cast(dtypes.uint32) * 8)).reduce(sb, arg=Ops.ADD)
-  row, col4 = super_idx // sk4, super_idx % sk4
-  si_store = si_out.after(e8_store.end(sb))[col4 * rows + row].store(packed)
-  return si_store.end(tid, wg).sink(arg=KernelInfo(f"quantize_mxfp8_{n_elems}", opts_to_apply=()))
-
-def _quantize_mxfp8_fused_bwd(gradient:UOp, kernel:UOp):
-  _, e8_out, _, x = kernel.src[1:]
-  device = x.device
-  rows, K = x.shape
-  scale_K = K // BLK
-  e8 = Tensor(e8_out, device=device).reshape(rows, scale_K)
-  qscale = (127.0 - e8.cast(dtypes.float32)).exp2().reshape(rows, scale_K, 1).expand(rows, scale_K, BLK).reshape(rows, K)
-  grad_x = (Tensor(gradient, device=device).float() * qscale).cast(dtypes.bfloat16)
-  return (None, None, None, grad_x.uop)
-
-def quantize_mxfp8_fused(x:Tensor) -> tuple[Tensor, Tensor, Tensor]:
-  assert x.dtype == dtypes.bfloat16, f"expected bf16, got {x.dtype}"
-  assert x.ndim == 2, f"expected 2d (rows, K), got {x.shape}"
-  from extra.gemm.cdna_asm_gemm import FP8_DTYPE
-  rows, K = x.shape
-  scale_K = K // BLK
-  axis = x.uop.axis if isinstance(x.device, tuple) else None
-  fp8_out = alloc_like((rows, K), FP8_DTYPE, x.device, axis)
-  e8_out = alloc_like((rows, scale_K), dtypes.uint8, x.device, axis)
-  si_out = alloc_like((scale_K // PACK, rows), dtypes.uint32, x.device, None if axis is None else (1 if axis == 0 else 0))
-  fp8_out, e8_out, si_out, *_ = Tensor.custom_kernel(fp8_out, e8_out, si_out, x, fxn=_custom_quantize_mxfp8, grad_fxn=_quantize_mxfp8_fused_bwd)
-  return fp8_out, e8_out, si_out
@@ -26,7 +26,9 @@ constexpr int REG_N      = BLOCK_COL / WARPS_COL / 2;

 using G = kittens::group<NUM_WARPS>;

-__global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3 *A_ptr, fp8e4m3 *B_ptr, fp8e8m0 *scale_A_ptr, fp8e8m0 *scale_B_ptr,
+__global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3 *A_ptr, fp8e4m3 *B_ptr,
+    const uint32_t *__restrict__ scale_A_iter,
+    const uint32_t *__restrict__ scale_B_iter,
    const uint8_t *__restrict__ a_e8_unused,
    const uint8_t *__restrict__ b_e8_unused) {
    constexpr int M = GEMM_M, N = GEMM_N, K = GEMM_K;
@@ -38,19 +40,15 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
    constexpr int k_iters      = K / BLOCK_K;
    constexpr int NUM_THREADS  = NUM_WARPS * WARP_THREADS;

-    kittens::gl<fp8e8m0, k_iters * (M / BLOCK_ROW), 1, 16, 64> scale_A_gl{scale_A_ptr, nullptr, nullptr, nullptr, nullptr};
-    kittens::gl<fp8e8m0, k_iters * (N / BLOCK_COL), 1, 16, 64> scale_B_gl{scale_B_ptr, nullptr, nullptr, nullptr, nullptr};
-
-    using ST_A     = st_fp8e4m3<HALF_ROW, BLOCK_K, st_16x128_s>;
-    using ST_B     = st_fp8e4m3<HALF_COL, BLOCK_K, st_16x128_s>;
-    using ST_Scale = st<fp8e8m0, 16, 64, st_16x64_s>;
-    using RT_A     = rt_fp8e4m3<REG_M, BLOCK_K>;
-    using RT_B     = rt_fp8e4m3<REG_N, BLOCK_K>;
-    using RT_C     = rt_fl<REG_M, REG_N, col_l, rt_16x16_s>;
+    using ST_A = st_fp8e4m3<HALF_ROW, BLOCK_K, st_16x128_s>;
+    using ST_B = st_fp8e4m3<HALF_COL, BLOCK_K, st_16x128_s>;
+    using RT_A = rt_fp8e4m3<REG_M, BLOCK_K>;
+    using RT_B = rt_fp8e4m3<REG_N, BLOCK_K>;
+    using RT_C = rt_fl<REG_M, REG_N, col_l, rt_16x16_s>;

    __shared__ ST_A As[2][2];
    __shared__ ST_B Bs[2][2];
-    __shared__ ST_Scale scale_A_smem[2], scale_B_smem[2];
+    __shared__ uint8_t smem_scales[2048];

    RT_A a;
    RT_B b0, b1;
@@ -83,87 +81,54 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
    G::prefill_swizzled_offsets(As[0][0], A, sw_A);
    G::prefill_swizzled_offsets(Bs[0][0], B, sw_B);

-    const T *a_base = (const T *)&A[{0, 0, 0, 0}];
-    const T *b_base = (const T *)&B[{0, 0, 0, 0}];
-    const int a_row_stride = A.template stride<2>() * sizeof(T);
-    const int b_row_stride = B.template stride<2>() * sizeof(T);
-    i32x4 a_srd = make_srsrc(a_base, M * a_row_stride, a_row_stride);
-    i32x4 b_srd = make_srsrc(b_base, N * b_row_stride, b_row_stride);
-
-    const int wid = warpid() % NUM_WARPS;
-    constexpr int elem_per_warp = (16 / sizeof(T)) * kittens::WARP_THREADS;
-    uint32_t a_lds_00 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&As[0][0].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t a_lds_01 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&As[0][1].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t a_lds_10 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&As[1][0].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t a_lds_11 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&As[1][1].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t b_lds_00 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&Bs[0][0].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t b_lds_01 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&Bs[0][1].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t b_lds_10 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&Bs[1][0].data[0]) + wid * elem_per_warp * sizeof(T)));
-    uint32_t b_lds_11 = __builtin_amdgcn_readfirstlane(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&Bs[1][1].data[0]) + wid * elem_per_warp * sizeof(T)));
-
    int a_row_h0 = warp_m * REG_M;
    int a_row_h1 = HALF_ROW + warp_m * REG_M;
    int b_row_h0 = warp_n * REG_N;
    int b_row_h1 = HALF_COL + warp_n * REG_N;

    int tic = 0, toc = 1;
-    int tic_scales = 0, toc_scales = 1;

-    uint32_t a_lds[2][2] = {{a_lds_00, a_lds_01}, {a_lds_10, a_lds_11}};
-    uint32_t b_lds[2][2] = {{b_lds_00, b_lds_01}, {b_lds_10, b_lds_11}};
-
-    if constexpr (k_iters >= 6 && (k_iters % 2 == 0)) {
-    G::load(Bs[tic][0], B, {0, 0, block_col * 2, 0}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[tic][0]));
-    G::load(As[tic][0], A, {0, 0, block_row * 2, 0}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[tic][0]));
-    G::load(Bs[tic][1], B, {0, 0, block_col * 2 + 1, 0}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[tic][1]));
-    G::load(As[tic][1], A, {0, 0, block_row * 2 + 1, 0}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[tic][1]));
+    G::load(Bs[tic][0], B, {0, 0, block_col * 2, 0}, sw_B);
+    G::load(As[tic][0], A, {0, 0, block_row * 2, 0}, sw_A);
+    G::load(Bs[tic][1], B, {0, 0, block_col * 2 + 1, 0}, sw_B);
+    G::load(As[tic][1], A, {0, 0, block_row * 2 + 1, 0}, sw_A);

    if (warp_m == 1) __builtin_amdgcn_s_barrier();
    asm volatile("s_waitcnt vmcnt(4)");
    __builtin_amdgcn_s_barrier();

-    G::load(As[toc][0], A, {0, 0, block_row * 2, 1}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[toc][0]));
-    G::load(Bs[toc][0], B, {0, 0, block_col * 2, 1}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[toc][0]));
-    G::load(Bs[toc][1], B, {0, 0, block_col * 2 + 1, 1}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[toc][1]));
+    G::load(As[toc][0], A, {0, 0, block_row * 2, 1}, sw_A);
+    G::load(Bs[toc][0], B, {0, 0, block_col * 2, 1}, sw_B);
+    G::load(Bs[toc][1], B, {0, 0, block_col * 2 + 1, 1}, sw_B);
+
    asm volatile("s_waitcnt vmcnt(6)");
    __builtin_amdgcn_s_barrier();

-    G::load(scale_A_smem[0], scale_A_gl, {0 * tiles_M + block_row, 0, 0, 0});
-    G::load(scale_B_smem[0], scale_B_gl, {0 * tiles_N + block_col, 0, 0, 0});
-    asm volatile("s_waitcnt vmcnt(0)");
-    asm volatile("s_waitcnt lgkmcnt(0)");
-    __builtin_amdgcn_s_barrier();
-
-    int sa_idx = block_row, sb_idx = block_col;
-
    #pragma unroll 2
-    for (int k = 0; k < k_iters - 2; k++, tic ^= 1, toc ^= 1, tic_scales ^= 1, toc_scales ^= 1) {
-        if (k + 1 < k_iters) {
-            sa_idx += tiles_M; sb_idx += tiles_N;
-            G::load(scale_A_smem[toc_scales], scale_A_gl, {sa_idx, 0, 0, 0});
-            G::load(scale_B_smem[toc_scales], scale_B_gl, {sb_idx, 0, 0, 0});
-        }
+    for (int k = 0; k < k_iters - 2; k++, tic ^= 1, toc ^= 1) {
+        load_scales_to_lds(smem_scales, scale_A_iter, scale_B_iter, block_m, block_n, k, M, N);
+
        auto bs0 = subtile_inplace<REG_N, BLOCK_K>(Bs[tic][0], {warp_n, 0});
        load(b0, bs0);
        auto as0 = subtile_inplace<REG_M, BLOCK_K>(As[tic][0], {warp_m, 0});
        load(a, as0);
-        G::load(As[toc][1], A, {0, 0, block_row * 2 + 1, k + 1}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[toc][1]));
+        G::load(As[toc][1], A, {0, 0, block_row * 2 + 1, k + 1}, sw_A);
        asm volatile("s_waitcnt lgkmcnt(8)");
        __builtin_amdgcn_s_barrier();

-        fp8e8m0_4 sa_h0 = pack_scales(scale_A_smem[tic_scales].data, a_row_h0);
-        fp8e8m0_4 sb_h0 = pack_scales(scale_B_smem[tic_scales].data, b_row_h0);
-        fp8e8m0_4 sb_h1 = pack_scales(scale_B_smem[tic_scales].data, b_row_h1);
-        fp8e8m0_4 sa_h1 = pack_scales(scale_A_smem[tic_scales].data, a_row_h1);
+        fp8e8m0_4 sa_h0 = pack_scales(smem_scales, 0, a_row_h0);
+        fp8e8m0_4 sb_h0 = pack_scales(smem_scales, 1024, b_row_h0);
+
        __builtin_amdgcn_s_setprio(2);
        mma_ABt_scaled(cA, a, b0, cA, &sa_h0, &sb_h0);
        __builtin_amdgcn_s_setprio(0);
        __builtin_amdgcn_s_barrier();
        __builtin_amdgcn_sched_barrier(0);

+        fp8e8m0_4 sb_h1 = pack_scales(smem_scales, 1024, b_row_h1);
        auto bs1 = subtile_inplace<REG_N, BLOCK_K>(Bs[tic][1], {warp_n, 0});
        load(b1, bs1);
-        G::load(As[tic][0], A, {0, 0, block_row * 2, k + 2}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[tic][0]));
+        G::load(As[tic][0], A, {0, 0, block_row * 2, k + 2}, sw_A);
        asm volatile("s_waitcnt lgkmcnt(0)");
        __builtin_amdgcn_s_barrier();

@@ -172,9 +137,10 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
        __builtin_amdgcn_s_setprio(0);
        __builtin_amdgcn_s_barrier();

+        fp8e8m0_4 sa_h1 = pack_scales(smem_scales, 0, a_row_h1);
        auto as1 = subtile_inplace<REG_M, BLOCK_K>(As[tic][1], {warp_m, 0});
        load(a, as1);
-        G::load(Bs[tic][0], B, {0, 0, block_col * 2, k + 2}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[tic][0]));
+        G::load(Bs[tic][0], B, {0, 0, block_col * 2, k + 2}, sw_B);
        asm volatile("s_waitcnt lgkmcnt(0)");
        __builtin_amdgcn_s_barrier();

@@ -184,7 +150,7 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
        __builtin_amdgcn_s_barrier();
        __builtin_amdgcn_sched_barrier(0);

-        G::load(Bs[tic][1], B, {0, 0, block_col * 2 + 1, k + 2}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[tic][1]));
+        G::load(Bs[tic][1], B, {0, 0, block_col * 2 + 1, k + 2}, sw_B);
        asm volatile("s_waitcnt vmcnt(6)");
        __builtin_amdgcn_s_barrier();

@@ -196,24 +162,19 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3

    { // Epilogue k = k_iters - 2
        int k = k_iters - 2;
-        if (k + 1 < k_iters) {
-            sa_idx += tiles_M; sb_idx += tiles_N;
-            G::load(scale_A_smem[toc_scales], scale_A_gl, {sa_idx, 0, 0, 0});
-            G::load(scale_B_smem[toc_scales], scale_B_gl, {sb_idx, 0, 0, 0});
-        }
-        asm volatile("s_waitcnt vmcnt(0)");
-        asm volatile("s_waitcnt lgkmcnt(0)");
+        load_scales_to_lds(smem_scales, scale_A_iter, scale_B_iter, block_m, block_n, k, M, N);
        __builtin_amdgcn_s_barrier();
-        fp8e8m0_4 sa_h0 = pack_scales(scale_A_smem[tic_scales].data, a_row_h0);
-        fp8e8m0_4 sa_h1 = pack_scales(scale_A_smem[tic_scales].data, a_row_h1);
-        fp8e8m0_4 sb_h0 = pack_scales(scale_B_smem[tic_scales].data, b_row_h0);
-        fp8e8m0_4 sb_h1 = pack_scales(scale_B_smem[tic_scales].data, b_row_h1);
+
+        fp8e8m0_4 sa_h0 = pack_scales(smem_scales, 0, a_row_h0);
+        fp8e8m0_4 sa_h1 = pack_scales(smem_scales, 0, a_row_h1);
+        fp8e8m0_4 sb_h0 = pack_scales(smem_scales, 1024, b_row_h0);
+        fp8e8m0_4 sb_h1 = pack_scales(smem_scales, 1024, b_row_h1);

        auto bs0 = subtile_inplace<REG_N, BLOCK_K>(Bs[tic][0], {warp_n, 0});
        load(b0, bs0);
        auto as0 = subtile_inplace<REG_M, BLOCK_K>(As[tic][0], {warp_m, 0});
        load(a, as0);
-        G::load(As[toc][1], A, {0, 0, block_row * 2 + 1, k + 1}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[toc][1]));
+        G::load(As[toc][1], A, {0, 0, block_row * 2 + 1, k + 1}, sw_A);
        __builtin_amdgcn_s_barrier();

        asm volatile("s_waitcnt lgkmcnt(0)");
@@ -256,17 +217,17 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
        __builtin_amdgcn_sched_barrier(0);

        tic ^= 1; toc ^= 1;
-        tic_scales ^= 1; toc_scales ^= 1;
    }

    { // Epilogue k = k_iters - 1 (final)
-        asm volatile("s_waitcnt vmcnt(0)");
-        asm volatile("s_waitcnt lgkmcnt(0)");
+        int k = k_iters - 1;
+        load_scales_to_lds(smem_scales, scale_A_iter, scale_B_iter, block_m, block_n, k, M, N);
        __builtin_amdgcn_s_barrier();
-        fp8e8m0_4 sa_h0 = pack_scales(scale_A_smem[tic_scales].data, a_row_h0);
-        fp8e8m0_4 sa_h1 = pack_scales(scale_A_smem[tic_scales].data, a_row_h1);
-        fp8e8m0_4 sb_h0 = pack_scales(scale_B_smem[tic_scales].data, b_row_h0);
-        fp8e8m0_4 sb_h1 = pack_scales(scale_B_smem[tic_scales].data, b_row_h1);
+
+        fp8e8m0_4 sa_h0 = pack_scales(smem_scales, 0, a_row_h0);
+        fp8e8m0_4 sa_h1 = pack_scales(smem_scales, 0, a_row_h1);
+        fp8e8m0_4 sb_h0 = pack_scales(smem_scales, 1024, b_row_h0);
+        fp8e8m0_4 sb_h1 = pack_scales(smem_scales, 1024, b_row_h1);

        auto as0 = subtile_inplace<REG_M, BLOCK_K>(As[tic][0], {warp_m, 0});
        load(a, as0);
@@ -302,38 +263,6 @@ __global__ __launch_bounds__(512, 2) void mxfp8_gemm_kernel(bf16 *C_ptr, fp8e4m3
        __builtin_amdgcn_s_barrier();
    }

-    } else {
-    #pragma unroll 1
-    for (int kk = 0; kk < k_iters; kk++) {
-        G::load(As[0][0], A, {0, 0, block_row * 2,     kk}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[0][0]));
-        G::load(As[0][1], A, {0, 0, block_row * 2 + 1, kk}, sw_A, a_srd, a_base, __builtin_amdgcn_readfirstlane(a_lds[0][1]));
-        G::load(Bs[0][0], B, {0, 0, block_col * 2,     kk}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[0][0]));
-        G::load(Bs[0][1], B, {0, 0, block_col * 2 + 1, kk}, sw_B, b_srd, b_base, __builtin_amdgcn_readfirstlane(b_lds[0][1]));
-        G::load(scale_A_smem[0], scale_A_gl, {kk * tiles_M + block_row, 0, 0, 0});
-        G::load(scale_B_smem[0], scale_B_gl, {kk * tiles_N + block_col, 0, 0, 0});
-        asm volatile("s_waitcnt vmcnt(0)");
-        asm volatile("s_waitcnt lgkmcnt(0)");
-        __builtin_amdgcn_s_barrier();
-
-        fp8e8m0_4 sa_h0 = pack_scales(scale_A_smem[0].data, a_row_h0);
-        fp8e8m0_4 sa_h1 = pack_scales(scale_A_smem[0].data, a_row_h1);
-        fp8e8m0_4 sb_h0 = pack_scales(scale_B_smem[0].data, b_row_h0);
-        fp8e8m0_4 sb_h1 = pack_scales(scale_B_smem[0].data, b_row_h1);
-
-        auto bs0 = subtile_inplace<REG_N, BLOCK_K>(Bs[0][0], {warp_n, 0}); load(b0, bs0);
-        auto bs1 = subtile_inplace<REG_N, BLOCK_K>(Bs[0][1], {warp_n, 0}); load(b1, bs1);
-        auto as0 = subtile_inplace<REG_M, BLOCK_K>(As[0][0], {warp_m, 0}); load(a, as0);
-        asm volatile("s_waitcnt lgkmcnt(0)");
-        mma_ABt_scaled(cA, a, b0, cA, &sa_h0, &sb_h0);
-        mma_ABt_scaled(cB, a, b1, cB, &sa_h0, &sb_h1);
-        auto as1 = subtile_inplace<REG_M, BLOCK_K>(As[0][1], {warp_m, 0}); load(a, as1);
-        asm volatile("s_waitcnt lgkmcnt(0)");
-        mma_ABt_scaled(cC, a, b0, cC, &sa_h1, &sb_h0);
-        mma_ABt_scaled(cD, a, b1, cD, &sa_h1, &sb_h1);
-        __builtin_amdgcn_s_barrier();
-    }
-    }
-
    store(C, cA, {0, 0, block_row * WARPS_ROW * 2 + warp_m, block_col * WARPS_COL * 2 + warp_n});
    store(C, cB, {0, 0, block_row * WARPS_ROW * 2 + warp_m, block_col * WARPS_COL * 2 + WARPS_COL + warp_n});
    store(C, cC, {0, 0, block_row * WARPS_ROW * 2 + WARPS_ROW + warp_m, block_col * WARPS_COL * 2 + warp_n});
@@ -1,10 +0,0 @@
-/**
- * @file
- * @brief Aggregate header for CDNA4 ThunderKittens core include tree.
- */
-
-#pragma once
-
-#include "common/common.cuh"
-#include "types/types.cuh"
-#include "ops/ops.cuh"
@@ -1,81 +0,0 @@
-/**
- * @file
- * @brief An aggregate header file for all the register and shared types defined by ThunderKittens.
- */
-
-#pragma once
-
-#include "register/register.cuh"
-#include "shared/shared.cuh"
-#include "global/global.cuh"
-
-/* ----------  WRAPPERS FOR PRETTINESS  ---------- */
-
-namespace kittens {
-
-/**
- * @brief Row vector type alias.
- *
- * This template alias provides a convenient way to refer to the row vector type
- * associated with a given class or type `T`. It assumes that the class `T` has
- * a nested type named `row_vec`.
- *
- * @tparam T The class or type for which the row vector type is defined.
- *
- * Example usage:
- * @code
- * kittens::row_vec<decltype(some_tile)> row_vector;
- * @endcode
- */
-template<typename T>
-using row_vec = T::row_vec;
-
-/**
- * @brief Column vector type alias.
- *
- * This template alias provides a convenient way to refer to the column vector type
- * associated with a given class or type `T`. It assumes that the class `T` has
- * a nested type named `col_vec`.
- *
- * @tparam T The class or type for which the column vector type is defined.
- *
- * Example usage:
- * @code
- * kittens::col_vec<decltype(some_tile)> col_vector;
- * @endcode
- */
-template<typename T>
-using col_vec = T::col_vec;
-
-// ^ this code lives here because it applies to both sv and rv types
-
-// register tile layouts
-using row_l = ducks::rt_layout::row;
-using col_l = ducks::rt_layout::col;
-
-// register vector layouts
-using align_l = ducks::rv_layout::align;
-using ortho_l = ducks::rv_layout::ortho;
-using naive_l = ducks::rv_layout::naive;
-
-// register tile shapes
-using rt_16x16_s = ducks::rt_shape::rt_16x16;
-using rt_32x32_s = ducks::rt_shape::rt_32x32;
-using rt_32x32_8_s = ducks::rt_shape::rt_32x32_8;
-using rt_16x32_s = ducks::rt_shape::rt_16x32;
-using rt_32x16_s = ducks::rt_shape::rt_32x16;
-using rt_32x16_4_s = ducks::rt_shape::rt_32x16_4;
-using rt_16x32_4_s = ducks::rt_shape::rt_16x32_4;
-using rt_16x128_s = ducks::rt_shape::rt_16x128;
-
-// shared tile shapes
-using st_16x16_s = ducks::st_shape::st_16x16;
-using st_16x16_swizzled_s = ducks::st_shape::st_16x16_swizzled;
-using st_32x32_s = ducks::st_shape::st_32x32;
-using st_16x32_s = ducks::st_shape::st_16x32;
-using st_32x16_s = ducks::st_shape::st_32x16;
-using st_8x32_s = ducks::st_shape::st_8x32;
-using st_16x64_s = ducks::st_shape::st_16x64;
-using st_16x128_s = ducks::st_shape::st_16x128;
-
-}
@@ -438,35 +438,6 @@ __device__ __forceinline__ T buffer_load_dwordx2(
  return result;
 }

-template<int GPR_START>
-__device__ __forceinline__ void buffer_load_dwordx3(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
-  if constexpr (GPR_START >= 256) {
-    asm volatile("buffer_load_dwordx3 a[%0:%1], %2, %3, %4 offen offset:%5"
-      :
-      : "n"(GPR_START - 256), "n"(GPR_START + 2 - 256), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-      : "memory");
-  } else {
-    asm volatile("buffer_load_dwordx3 v[%0:%1], %2, %3, %4 offen offset:%5"
-      :
-      : "n"(GPR_START), "n"(GPR_START + 2), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-      : "memory");
-  }
-}
-
-// Returns a u32x3 (ext_vector_type(3)). Note sizeof(u32x3) == 16 due to vector
-// alignment padding, but the compiler still allocates exactly 3 consecutive VGPRs
-// for the "=v" operand and emits buffer_load_dwordx3 v[N:N+2].
-template<typename T = u32x3>
-__device__ __forceinline__ T buffer_load_dwordx3(
-  const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  T result;
-  asm volatile("buffer_load_dwordx3 %0, %1, %2, %3 offen offset:%4"
-    : "=v"(result)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-  return result;
-}
-
 template<int GPR_START>
 __device__ __forceinline__ void buffer_load_dwordx4(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
  if constexpr (GPR_START >= 256) {
@@ -494,116 +465,6 @@ __device__ __forceinline__ T buffer_load_dwordx4(
  return result;
 }

-template<typename T = uint32_t>
-__device__ __forceinline__ T buffer_load_ubyte(
-  const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  T result;
-  asm volatile("buffer_load_ubyte %0, %1, %2, %3 offen offset:%4"
-    : "=v"(result)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-  return result;
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ T buffer_load_sbyte(
-  const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  T result;
-  asm volatile("buffer_load_sbyte %0, %1, %2, %3 offen offset:%4"
-    : "=v"(result)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-  return result;
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ T buffer_load_ushort(
-  const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  T result;
-  asm volatile("buffer_load_ushort %0, %1, %2, %3 offen offset:%4"
-    : "=v"(result)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-  return result;
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ T buffer_load_sshort(
-  const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  T result;
-  asm volatile("buffer_load_sshort %0, %1, %2, %3 offen offset:%4"
-    : "=v"(result)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-  return result;
-}
-
-// d16 variants merge the loaded sub-dword into the low (or high, for _hi) 16 bits
-// of the destination register, leaving the other half untouched: read-modify-write.
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_ubyte_d16(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_ubyte_d16 %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_ubyte_d16_hi(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_ubyte_d16_hi %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_sbyte_d16(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_sbyte_d16 %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_sbyte_d16_hi(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_sbyte_d16_hi %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_short_d16(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_short_d16 %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_load_short_d16_hi(
-  T& dst, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_load_short_d16_hi %0, %1, %2, %3 offen offset:%4"
-    : "+v"(dst)
-    : "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
 template<int GPR>
 __device__ __forceinline__ void buffer_store_dword(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
  // AGPRS
@@ -658,32 +519,6 @@ __device__ __forceinline__ void buffer_store_dwordx2(
    : "memory");
 }

-template<int GPR_START>
-__device__ __forceinline__ void buffer_store_dwordx3(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
-  // AGPRS
-  if constexpr (GPR_START >= 256) {
-    asm volatile("buffer_store_dwordx3 a[%0:%1], %2, %3, %4 offen offset:%5"
-      :
-      : "n"(GPR_START - 256), "n"(GPR_START + 2 - 256), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-      : "memory");
-  // VGPRS
-  } else {
-    asm volatile("buffer_store_dwordx3 v[%0:%1], %2, %3, %4 offen offset:%5"
-      :
-      : "n"(GPR_START), "n"(GPR_START + 2), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-      : "memory");
-  }
-}
-
-template<typename T = u32x3>
-__device__ __forceinline__ void buffer_store_dwordx3(
-  const T& value, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  asm volatile("buffer_store_dwordx3 %0, %1, %2, %3 offen offset:%4"
-    :
-    : "v"(value), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
 template<int GPR_START>
 __device__ __forceinline__ void buffer_store_dwordx4(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
  // AGPRS
@@ -711,50 +546,6 @@ __device__ __forceinline__ void buffer_store_dwordx4(
    : "memory");
 }

-// Stores the low 8 bits of the value register.
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_store_byte(
-  const T& value, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_store_byte %0, %1, %2, %3 offen offset:%4"
-    :
-    : "v"(value), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-// Stores the high 16 bits' low 8 bits (bits [23:16]) of the value register.
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_store_byte_d16_hi(
-  const T& value, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_store_byte_d16_hi %0, %1, %2, %3 offen offset:%4"
-    :
-    : "v"(value), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-// Stores the low 16 bits of the value register.
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_store_short(
-  const T& value, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_store_short %0, %1, %2, %3 offen offset:%4"
-    :
-    : "v"(value), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
-// Stores the high 16 bits of the value register.
-template<typename T = uint32_t>
-__device__ __forceinline__ void buffer_store_short_d16_hi(
-  const T& value, const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const uint32_t i_offset = 0) {
-  static_assert(sizeof(T) == sizeof(uint32_t));
-  asm volatile("buffer_store_short_d16_hi %0, %1, %2, %3 offen offset:%4"
-    :
-    : "v"(value), "v"(v_offset), "s"(*(const i32x4*)&br), "s"(s_offset), "i"(i_offset)
-    : "memory");
-}
-
 template<int GPR>
 __device__ __forceinline__ void buffer_atomic_pk_add_bf16(const buffer_resource& br, const uint32_t v_offset, const uint32_t s_offset = 0, const int i_offset = 0) {
  if constexpr (GPR >= 256) {
@@ -52,8 +52,6 @@ __device__ __forceinline__ int laneid() { return threadIdx.x & 0x3f; }

 using i32x2 = int32_t __attribute__((ext_vector_type(2)));
 using u32x2 = uint32_t __attribute__((ext_vector_type(2)));
-using i32x3 = int32_t __attribute__((ext_vector_type(3)));
-using u32x3 = uint32_t __attribute__((ext_vector_type(3)));
 using i32x4 = int32_t __attribute__((ext_vector_type(4)));
 using u32x4 = uint32_t __attribute__((ext_vector_type(4)));

@@ -5,12 +5,9 @@

 #pragma once

-#if defined(KITTENS_CDNA4)
-#include "cdna4/includes.cuh"
-#elif defined(KITTENS_UDNA1)
-#include "udna1/includes.cuh"
-#endif
-
+#include "common/common.cuh"
+#include "types/types.cuh"
+#include "ops/ops.cuh"
 #include "pyutils/util.cuh"


@@ -248,7 +248,7 @@ __device__ inline static void load(RT &dst, const ST &src) {
                                        "ds_read_b64_tr_b16 %0, %2 offset:%3\n"
                                        "ds_read_b64_tr_b16 %1, %2 offset:%4\n"
                                        // "s_waitcnt lgkmcnt(0)\n"
-                                        : "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx])),
+                                        : "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx])), 
                                        "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx + 2]))
                                        : "v"(addr), "i"(offset), "i"(offset + 4 * ST::underlying_subtile_row_bytes)
                                        : "memory"
@@ -259,7 +259,7 @@ __device__ inline static void load(RT &dst, const ST &src) {
                                        "ds_read_b64_tr_b16 %0, %2 offset:%4\n"
                                        "ds_read_b64_tr_b16 %1, %3 offset:%4\n"
                                        // "s_waitcnt lgkmcnt(0)\n"
-                                        : "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx])),
+                                        : "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx])), 
                                        "=v"(*reinterpret_cast<float2*>(&dst.tiles[register_row][register_col].data[idx + 2]))
                                        : "v"(addr), "v"(next_addr), "i"(offset)
                                        : "memory"
@@ -688,88 +688,4 @@ __device__ inline static void store(ST &dst, const RT &src) {
    }
 }

-template<ducks::rt::col_layout RT, ducks::st::all ST>
-__device__ inline static void load(RT &dst, const ST &src, int col_offset) {
-    static_assert(RT::cols == ST::rows,
-                  "col_layout load with col_offset: ST.rows must equal RT::cols");
-    static_assert(RT::width == 1, "col_layout load with col_offset: only width==1 supported");
-
-    using T2 = RT::dtype;
-    using U  = ST::dtype;
-    using U2 = base_types::packing<U>::packed_type;
-
-    const int laneid = kittens::laneid();
-    const uint32_t src_ptr = (uint32_t)(uintptr_t)(&src.data[0]);
-    constexpr int subtile_bytes = ST::underlying_subtile_bytes;
-
-    if constexpr (std::is_same_v<T2, fp8e4m3_4>) {
-        const int block_id = laneid / 16;
-        const int l_within = laneid % 16;
-        const int tr_k_grp = l_within / 2;
-        const int m_half   = l_within & 1;
-
-        #pragma unroll
-        for (int i = 0; i < RT::height; i++) {
-            const int m_col = col_offset + i * RT::base_tile_rows + m_half * 8;
-
-            const int subtile_base = block_id;
-            uint32_t addr = src_ptr
-                          + (uint32_t)(subtile_base * subtile_bytes)
-                          + src.swizzle({tr_k_grp, m_col});
-
-            asm volatile(
-                "ds_read_b64_tr_b8 %0, %2 offset:0\n"
-                "ds_read_b64_tr_b8 %1, %2 offset:%3\n"
-                : "=&v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[0])),
-                  "=&v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[4]))
-                : "v"(addr), "i"(4 * subtile_bytes)
-                : "memory"
-            );
-
-            addr ^= 1088u;
-
-            asm volatile(
-                "ds_read_b64_tr_b8 %0, %2 offset:0\n"
-                "ds_read_b64_tr_b8 %1, %2 offset:%3\n"
-                : "=&v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[2])),
-                  "=&v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[6]))
-                : "v"(addr), "i"(4 * subtile_bytes)
-                : "memory"
-            );
-        }
-    } else if constexpr (std::is_same_v<U2, bf16_2> || std::is_same_v<U2, half_2>) {
-        const int row_offset = ((laneid % 16) / 4) + ((laneid / 16) * 4);
-        const int col_offset_lane = (laneid % 4) * 4;
-
-        #pragma unroll
-        for (int i = 0; i < RT::height; i++) {
-            const int m_col = col_offset + i * RT::base_tile_rows + col_offset_lane;
-            const uint32_t addr = src_ptr + src.swizzle({row_offset, m_col});
-            const uint32_t next_addr = src_ptr + src.swizzle({row_offset + 4, m_col});
-
-            if constexpr (RT::base_tile_stride == 8) {
-                asm volatile(
-                    "ds_read_b64_tr_b16 %0, %2 offset:0\n"
-                    "ds_read_b64_tr_b16 %1, %3 offset:0\n"
-                    : "=v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[0])),
-                      "=v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[2]))
-                    : "v"(addr), "v"(next_addr)
-                    : "memory"
-                );
-            } else if constexpr (RT::base_tile_stride == 4) {
-                asm volatile(
-                    "ds_read_b64_tr_b16 %0, %1 offset:0\n"
-                    : "=v"(*reinterpret_cast<float2*>(&dst.tiles[i][0].data[0]))
-                    : "v"(addr)
-                    : "memory"
-                );
-            } else {
-                static_assert(false, "Unsupported stride for col_layout load with col_offset");
-            }
-        }
-    } else {
-        static_assert(false, "Unsupported type for col_layout load with col_offset");
-    }
-}
-
 } // namespace kittens
@@ -201,10 +201,10 @@ __device__ static inline void mma_AB_base(rt_base<float, ducks::rt_layout::col,
 * @param[in] b The second input rt_base<bf16_2, row_layout> matrix in row-major mode.
 * @param[in] c The input rt_base<float2, row_layout> accumulator matrix.
 */
-template<ducks::rt_shape::all D_shape, ducks::rt_layout::all A_layout, ducks::rt_shape::all A_shape, ducks::rt_layout::all B_layout, ducks::rt_shape::all B_shape, ducks::rt_shape::all C_shape, typename MM_Operand_T=bf16>
+template<ducks::rt_shape::all D_shape, ducks::rt_shape::all A_shape, ducks::rt_shape::all B_shape, ducks::rt_shape::all C_shape, typename MM_Operand_T=bf16>
 __device__ static inline void mma_ABt_base(rt_base<float, ducks::rt_layout::col, D_shape> &d,
-    const rt_base<MM_Operand_T, A_layout, A_shape> &a,
-    const rt_base<MM_Operand_T, B_layout, B_shape> &b,
+    const rt_base<MM_Operand_T, ducks::rt_layout::row, A_shape> &a,
+    const rt_base<MM_Operand_T, ducks::rt_layout::row, B_shape> &b, // in row-major mode
    const rt_base<float, ducks::rt_layout::col, C_shape> &c) {

    static_assert(std::is_same_v<D_shape, C_shape>, "D and C must have the same shape");
@@ -243,32 +243,6 @@ __device__ static inline void mma_ABt_base(rt_base<float, ducks::rt_layout::col,
    }
 }

-/**
- * @brief Pack 4 E8M0 scale bytes from LDS into one fp8e8m0_4 register.
- *
- * @param smem_scales LDS pointer to scale tile data.
- * @param row_offset Starting row within the scale region (warp's tile offset).
- * @return fp8e8m0_4 with 4 scale bytes packed for MFMA opsel.
- */
-__device__ __forceinline__ fp8e8m0_4 pack_scales(
-    const fp8e8m0 *smem_scales, int row_offset) {
-    int lid   = laneid();
-    int r16   = lid % 16;
-    int k_sub = lid / 16;
-
-    const fp8e8m0_4 *s4 = (const fp8e8m0_4 *)smem_scales;
-    fp8e8m0_4 w0 = s4[row_offset + 0 * 16 + r16];
-    fp8e8m0_4 w1 = s4[row_offset + 1 * 16 + r16];
-    fp8e8m0_4 w2 = s4[row_offset + 2 * 16 + r16];
-    fp8e8m0_4 w3 = s4[row_offset + 3 * 16 + r16];
-
-    fp8e8m0_4 sel = 0x0C0C0000u | (k_sub << 8) | (4u + k_sub);
-    fp8e8m0_4 lo  = __builtin_amdgcn_perm(w0, w1, sel);
-    fp8e8m0_4 hi  = __builtin_amdgcn_perm(w2, w3, sel);
-
-    return lo | (hi << 16);
-}
-
 /**
 * @brief Base dot product operation for row layout.
 *
@@ -280,10 +254,10 @@ __device__ __forceinline__ fp8e8m0_4 pack_scales(
 * @param[in] b The second input rt_base<Operand_T, row_layout> matrix.
 * @param[in] c The input rt_base<float, col_layout> accumulator matrix.
 */
-template<int opsel_a, int opsel_b, int cbsz = 0, int blgp = 0, ducks::rt_shape::all D_shape, ducks::rt_layout::all A_layout, ducks::rt_shape::all A_shape, ducks::rt_layout::all B_layout, ducks::rt_shape::all B_shape, ducks::rt_shape::all C_shape, typename MM_Operand_T>
+template<int opsel_a, int opsel_b, int cbsz = 0, int blgp = 0, ducks::rt_shape::all D_shape, ducks::rt_shape::all A_shape, ducks::rt_shape::all B_shape, ducks::rt_shape::all C_shape, typename MM_Operand_T>
 __device__ static inline void mma_ABt_base_scaled(rt_base<float, ducks::rt_layout::col, D_shape> &d,
-    const rt_base<MM_Operand_T, A_layout, A_shape> &a,
-    const rt_base<MM_Operand_T, B_layout, B_shape> &b,
+    const rt_base<MM_Operand_T, ducks::rt_layout::row, A_shape> &a,
+    const rt_base<MM_Operand_T, ducks::rt_layout::row, B_shape> &b,
    const rt_base<float, ducks::rt_layout::col, C_shape> &c,
    const fp8e8m0_4 *scale_a,
    const fp8e8m0_4 *scale_b) {
@@ -467,7 +441,7 @@ __device__ static inline void mma_AB(D &d,
 * @param[in] b The second input rt_bf<M, K, row_layout> matrix in row-major mode.
 * @param[in] c The input rt_fl<N, M, row_layout> accumulator matrix.
 */
-template<ducks::rt::col_layout D, ducks::rt::all A, ducks::rt::all B, ducks::rt::col_layout C>
+template<ducks::rt::col_layout D, ducks::rt::row_layout A, ducks::rt::row_layout B, ducks::rt::col_layout C>
 __device__ static inline void mma_ABt(D &d,
                                const A &a,
                                const B &b, // notice row and (M, K) instead of col and (K, M)
@@ -525,7 +499,7 @@ __device__ static inline void mma_ABt(D &d,
 * @param[in] scale_a Pointer to the packed E8M0 scale for the A matrix.
 * @param[in] scale_b Pointer to the packed E8M0 scale for the B matrix.
 */
-template<int cbsz = 0, int blgp = 0, ducks::rt::col_layout D, ducks::rt::all A, ducks::rt::all B, ducks::rt::col_layout C>
+template<int cbsz = 0, int blgp = 0, ducks::rt::col_layout D, ducks::rt::row_layout A, ducks::rt::row_layout B, ducks::rt::col_layout C>
 __device__ static inline void mma_ABt_scaled(D &d,
                                const A &a,
                                const B &b,
@@ -0,0 +1,74 @@
+/**
+ * @file
+ * @brief MXFP8 block scale loading and packing utilities.
+ *
+ * Provides functions for staging E8M0 block scales in LDS and packing them
+ * into fp8e8m0_4 registers for use with scaled MFMA instructions.
+ */
+
+#pragma once
+
+#include "../../../../common/common.cuh"
+
+namespace kittens {
+
+/**
+ * @brief Load iteration-major packed E8M0 scales from global memory into LDS.
+ *
+ * First 256 threads each load one uint32 (4 packed E8M0 bytes) for A and B.
+ * A scales are placed at smem[0..1023], B scales at smem[1024..2047].
+ *
+ * @param smem_scales LDS buffer, must be >= 2048 bytes.
+ * @param scale_A_iter Iteration-major A scales: [k_iter * M + row] as uint32.
+ * @param scale_B_iter Iteration-major B scales: [k_iter * N + row] as uint32.
+ * @param block_m Starting row offset for A within the current block.
+ * @param block_n Starting row offset for B within the current block.
+ * @param k_iter Current K iteration index.
+ * @param M_dim M dimension of the matrix.
+ * @param N_dim N dimension of the matrix.
+ */
+__device__ __forceinline__ void load_scales_to_lds(
+    uint8_t *smem_scales,
+    const uint32_t *__restrict__ scale_A_iter,
+    const uint32_t *__restrict__ scale_B_iter,
+    int block_m, int block_n, int k_iter, int M_dim, int N_dim) {
+    int tid = threadIdx.x;
+    if (tid < 256) {
+        uint32_t sa = scale_A_iter[k_iter * M_dim + block_m + tid];
+        uint32_t sb = scale_B_iter[k_iter * N_dim + block_n + tid];
+        *(uint32_t *)&smem_scales[tid * 4] = sa;
+        *(uint32_t *)&smem_scales[1024 + tid * 4] = sb;
+    }
+}
+
+/**
+ * @brief Pack 4 E8M0 scale bytes from LDS into one fp8e8m0_4 register.
+ *
+ * Each lane (r16 = laneid%16, k_sub = laneid/16) loads 4 dwords from
+ * consecutive 16-row groups, then uses v_perm_b32 to extract byte k_sub
+ * from each, producing the packed scale register for scaled MFMA.
+ *
+ * @param smem_scales LDS pointer to scale region.
+ * @param lds_base Byte offset within smem_scales (0 for A, 1024 for B).
+ * @param row_offset Starting row within the scale region (warp's tile offset).
+ * @return fp8e8m0_4 with 4 scale bytes packed for MFMA opsel.
+ */
+__device__ __forceinline__ fp8e8m0_4 pack_scales(
+    const uint8_t *smem_scales, int lds_base, int row_offset) {
+    int lid   = laneid();
+    int r16   = lid % 16;
+    int k_sub = lid / 16;
+
+    const uint32_t *s32 = (const uint32_t *)(smem_scales + lds_base);
+    uint32_t w0 = s32[row_offset + 0 * 16 + r16];
+    uint32_t w1 = s32[row_offset + 1 * 16 + r16];
+    uint32_t w2 = s32[row_offset + 2 * 16 + r16];
+    uint32_t w3 = s32[row_offset + 3 * 16 + r16];
+
+    uint32_t sel = 0x0C0C0000u | (k_sub << 8) | (4u + k_sub);
+    uint32_t lo  = __builtin_amdgcn_perm(w0, w1, sel);
+    uint32_t hi  = __builtin_amdgcn_perm(w2, w3, sel);
+
+    return (fp8e8m0_4)(lo | (hi << 16));
+}
+} // namespace kittens
@@ -9,5 +9,6 @@
 #include "maps.cuh"
 #include "reductions.cuh"
 #include "mma.cuh"
+#include "scales.cuh"

 #include "assembly/tile.cuh"
@@ -1,5 +1,6 @@
 #pragma once

+#include "../ops/ops.cuh"
 #include <iostream>

 #define CHECK_CUDA_ERROR(val) check((val), #val, __FILE__, __LINE__)
@@ -41,7 +41,7 @@ struct st_16x16 {
        } else {
            static_assert(false, "Unsupported type");
        }
-
+        
    }
 };

@@ -205,23 +205,6 @@ struct st_8x32 {
    }
 };

-struct st_16x64 {
-    static constexpr int rows = 16;
-    static constexpr int cols = 64;
-
-    template<typename _T>
-    static constexpr int bytes_per_thread() {
-        static_assert(sizeof(_T) == 1 || sizeof(_T) == 2 || sizeof(_T) == 4, "Unsupported type");
-        return 16;
-    }
-
-    template<typename _T>
-    __device__ __forceinline__ static const uint32_t swizzle (int2 coord) {
-        static_assert(sizeof(_T) == 1 || sizeof(_T) == 2 || sizeof(_T) == 4, "Unsupported type");
-        return sizeof(_T) * (coord.x * cols + coord.y);
-    }
-};
-
 struct st_16x128 {
    static constexpr int rows = 16;
    static constexpr int cols = 128;
@@ -253,13 +236,12 @@ struct st_16x128 {
 };

 template<typename T>
-concept all = std::is_same_v<T, st_16x16> ||
-              std::is_same_v<T, st_16x16_swizzled> ||
-              std::is_same_v<T, st_32x32> ||
-              std::is_same_v<T, st_16x32> ||
-              std::is_same_v<T, st_32x16> ||
+concept all = std::is_same_v<T, st_16x16> || 
+              std::is_same_v<T, st_16x16_swizzled> || 
+              std::is_same_v<T, st_32x32> || 
+              std::is_same_v<T, st_16x32> || 
+              std::is_same_v<T, st_32x16> || 
              std::is_same_v<T, st_8x32>  ||
-              std::is_same_v<T, st_16x64> ||
              std::is_same_v<T, st_16x128>;


@@ -75,7 +75,6 @@ using st_32x32_s = ducks::st_shape::st_32x32;
 using st_16x32_s = ducks::st_shape::st_16x32;
 using st_32x16_s = ducks::st_shape::st_32x16;
 using st_8x32_s = ducks::st_shape::st_8x32;
-using st_16x64_s = ducks::st_shape::st_16x64;
 using st_16x128_s = ducks::st_shape::st_16x128;

 }
@@ -1,449 +0,0 @@
-/**
- * @file
- * @brief Basic operations on generic types.
- */
-
-#pragma once
-
-#include <limits>
-#include "base_types.cuh"
-
-namespace kittens {
-
-/**
- * @namespace base_ops
- *
- * @brief A namespace for operations on basic data types.
- */
-namespace base_ops {
-
-/* ----------  CONST OPS  ---------- */
-
-/**
- * @brief Represents the zero constant operation.
- *
- * This operation returns the zero value of the specified type.
- *
- * @tparam T The data type for which to return the zero value.
- * @return The zero value of type T.
- */
-struct zero {
-    template<typename T, typename... args> __device__ static inline constexpr T op(args... _) { return base_types::constants<T>::zero();      }
-};
-/**
- * @brief Represents the ones constant operation.
- *
- * This operation returns the ones value of the specified type.
- *
- * @tparam T The data type for which to return the ones value.
- * @return The ones value of type T.
- */
-struct ones {
-    template<typename T, typename... args> __device__ static inline constexpr T op(args... _) { return base_types::constants<T>::ones();       }
-};
-/**
- * @brief Represents the positive infinity constant operation.
- *
- * This operation returns the positive infinity value of the specified type.
- *
- * @tparam T The data type for which to return the positive infinity value.
- * @return The positive infinity value of type T.
- */
-struct pos_infty {
-    template<typename T, typename... args> __device__ static inline constexpr T op(args... _) { return base_types::constants<T>::pos_infty(); }
-};
-/**
- * @brief Represents the negative infinity constant operation.
- *
- * This operation returns the negative infinity value of the specified type.
- *
- * @tparam T The data type for which to return the negative infinity value.
- * @return The negative infinity value of type T.
- */
-struct neg_infty {
-    template<typename T, typename... args> __device__ static inline constexpr T op(args... _) { return base_types::constants<T>::neg_infty(); }
-};
-
-
-/* ----------  UNARY OPS  ---------- */
-
-/**
- * @brief Exponential function operation.
- *
- * This operation calculates the exponential of the input value.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The exponential of the input value.
- */
-struct exp {
-    template<typename T> static __device__ inline T op(const T &x) { return exp(x); }
-};
-template<> __device__ inline float  exp::op<float> (const float &x ) { return __expf(x);                        }
-template<> __device__ inline float2 exp::op<float2>(const float2 &x) { return float2{__expf(x.x), __expf(x.y)}; }
-template<> __device__ inline bf16   exp::op<bf16>  (const bf16 &x  ) { return hexp(x);                          }
-template<> __device__ inline bf16_2 exp::op<bf16_2>(const bf16_2 &x) { return h2exp(x);                         }
-template<> __device__ inline half   exp::op<half>  (const half &x  ) { return hexp(x);                          }
-template<> __device__ inline half_2 exp::op<half_2>(const half_2 &x) { return h2exp(x);                         }
-
-// /**
-//  * @brief Exponential function operation, in base 2
-//  *
-//  * This operation calculates the exponential of the input value, in base 2.
-//  *
-//  * @tparam T The data type of the input and output values.
-//  * @param x[in] The input value.
-//  * @return The exponential of the input value.
-//  */
-// struct exp2 {
-//     template<typename T> static __device__ inline T op(const T &x) { return exp2f(x); }
-// };
-// template<> __device__ inline float  exp2::op<float> (const float &x ) { return exp2f(x);                        }
-// template<> __device__ inline float2 exp2::op<float2>(const float2 &x) { return float2{exp2f(x.x), exp2f(x.y)}; }
-// template<> __device__ inline bf16   exp2::op<bf16>  (const bf16 &x  ) { return hexp2(x);                          }
-// template<> __device__ inline bf16_2 exp2::op<bf16_2>(const bf16_2 &x) { return h2exp2(x);                         }
-// template<> __device__ inline half   exp2::op<half>  (const half &x  ) { return hexp2(x);                          }
-// template<> __device__ inline half_2 exp2::op<half_2>(const half_2 &x) { return h2exp2(x);                         }
-
-
-/**
- * @brief Base-2 exponential operation using `__builtin_amdgcn_exp2_f32`
- *
- * Maps directly to `v_exp_f32_e32` on AMD, for highest performance.
- * Expects `x` to be in a safe numerical range (e.g., [-64, 88]).
- */
- struct exp2 {
-    template <typename T>
-    static __device__ inline T op(const T &x) {
-        return exp2f(x);  // fallback
-    }
-};
-
-// Force hardware v_exp_f32 for float
-template<>
-__device__ inline float exp2::op<float>(const float &x) {
-    return __builtin_amdgcn_exp2f(x);  // Emits v_exp_f32_e32
-}
-
-// Force hardware v_exp_f32 for float2
-template<>
-__device__ inline float2 exp2::op<float2>(const float2 &x) {
-    return {
-        __builtin_amdgcn_exp2f(x.x),
-        __builtin_amdgcn_exp2f(x.y)
-    };
-}
-
-// Delegate to low-precision approximations
-template<> __device__ inline half    exp2::op<half>(const half &x)     { return hexp2(x);  }
-template<> __device__ inline half_2  exp2::op<half_2>(const half_2 &x) { return h2exp2(x); }
-template<> __device__ inline bf16    exp2::op<bf16>(const bf16 &x)     { return hexp2(x);  }
-template<> __device__ inline bf16_2  exp2::op<bf16_2>(const bf16_2 &x) { return h2exp2(x); }
-
-
-
-/**
- * @brief Natural log function operation.
- *
- * This operation calculates the natural logarithm of the input value.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The natural logarithm of the input value.
- */
-struct log {
-    template<typename T> static __device__ inline T op(const T &x) { return log(x); }
-};
-template<> __device__ inline float  log::op<float> (const float &x ) { return __logf(x);                        }
-template<> __device__ inline float2 log::op<float2>(const float2 &x) { return float2{__logf(x.x), __logf(x.y)}; }
-template<> __device__ inline bf16   log::op<bf16>  (const bf16 &x  ) { return hlog(x);                          }
-template<> __device__ inline bf16_2 log::op<bf16_2>(const bf16_2 &x) { return h2log(x);                         }
-template<> __device__ inline half   log::op<half>  (const half &x  ) { return hlog(x);                          }
-template<> __device__ inline half_2 log::op<half_2>(const half_2 &x) { return h2log(x);                         }
-/**
- * @brief Logarithm base 2 operation.
- *
- * This operation calculates the logarithm base 2 of the input value.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The logarithm base 2 of the input value.
- */
-struct log2 {
-    template<typename T> static __device__ inline T op(const T &x) { return log2(x); }
-};
-template<> __device__ inline float  log2::op<float> (const float &x ) { return __log2f(x);                        }
-template<> __device__ inline float2 log2::op<float2>(const float2 &x) { return float2{__log2f(x.x), __log2f(x.y)}; }
-template<> __device__ inline bf16   log2::op<bf16>  (const bf16 &x  ) { return hlog2(x);                          }
-template<> __device__ inline bf16_2 log2::op<bf16_2>(const bf16_2 &x) { return h2log2(x);                         }
-template<> __device__ inline half   log2::op<half>  (const half &x  ) { return hlog2(x);                          }
-template<> __device__ inline half_2 log2::op<half_2>(const half_2 &x) { return h2log2(x);                         }
-/**
- * @brief Absolute value operation.
- *
- * This operation calculates the absolute value of the input.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The absolute value of the input.
- */
-struct abs {
-    template<typename T> static __device__ inline T op(const T &x) { return abs(x); }
-};
-template<> __device__ inline float  abs::op<float> (const float &x ) { return fabsf(x);                       }
-template<> __device__ inline float2 abs::op<float2>(const float2 &x) { return float2{fabsf(x.x), fabsf(x.y)}; }
-template<> __device__ inline bf16   abs::op<bf16>  (const bf16 &x  ) { return __habs(x);                      }
-template<> __device__ inline bf16_2 abs::op<bf16_2>(const bf16_2 &x) { return __habs2(x);                     }
-template<> __device__ inline half   abs::op<half>  (const half &x  ) { return __habs(x);                      }
-template<> __device__ inline half_2 abs::op<half_2>(const half_2 &x) { return __habs2(x);                     }
-/**
- * @brief Rectified Linear Unit (ReLU) operation.
- *
- * This operation applies the ReLU function to the input, which is the
- * maximum of zero and the input value.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The result of ReLU function applied to the input.
- */
-struct relu {
-    template<typename T> static __device__ inline T op(const T &x) { return max(x, base_types::constants<T>::zero()); }
-};
-template<> __device__ inline float  relu::op<float> (const float &x ) { return max(x, 0.f);                                  }
-template<> __device__ inline float2 relu::op<float2>(const float2 &x) { return float2{max(x.x, 0.f), max(x.y, 0.f)};         }
-template<> __device__ inline bf16   relu::op<bf16>  (const bf16 &x  ) { return __hmax(x, base_types::constants<bf16>::zero());    }
-template<> __device__ inline bf16_2 relu::op<bf16_2>(const bf16_2 &x) { return __hmax2(x, base_types::constants<bf16_2>::zero()); }
-template<> __device__ inline half   relu::op<half>  (const half &x  ) { return __hmax(x, base_types::constants<half>::zero());    }
-template<> __device__ inline half_2 relu::op<half_2>(const half_2 &x) { return half_2{__hmax(x.x, base_types::constants<half>::zero()), 
-                                                                                     __hmax(x.y, base_types::constants<half>::zero())}; }
-
-
-constexpr float SQRT_2_OVER_PI   = 0.7978845608028654f;
-constexpr float GELU_COEFF       = 0.044715f;
-constexpr float GELU_INNER_COEFF = GELU_COEFF * SQRT_2_OVER_PI;
-constexpr float DGELU_COEFF      = 3.0f * GELU_COEFF * SQRT_2_OVER_PI;
-
-static __device__ inline float fast_tanh(float x) {
-    x = fmaxf(fminf(x, 20.f), -20.f);
-    float e2x = __builtin_amdgcn_exp2f(x * 2.8853900817779268f);
-    return (e2x - 1.0f) * __frcp_rn(e2x + 1.0f);
-}
-
-/**
- * @brief Gaussian Error Linear Unit (GELU) activation.
- *
- * Computes the GELU approximation: x * 0.5 * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3))).
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The GELU activation applied to the input.
- */
-struct gelu {
-    template<typename T> static __device__ inline T op(const T &x);
-};
-template<> __device__ inline float gelu::op<float>(const float &x) {
-    return x * (0.5f + 0.5f * fast_tanh(x * (SQRT_2_OVER_PI + GELU_INNER_COEFF * x * x)));
-}
-template<> __device__ inline float2 gelu::op<float2>(const float2 &x) {
-    return float2{gelu::op<float>(x.x), gelu::op<float>(x.y)};
-}
-
-/**
- * @brief Derivative of the GELU activation.
- *
- * Computes the derivative of the GELU approximation with respect to the input.
- *
- * @tparam T The data type of the input and output values.
- * @param x[in] The input value.
- * @return The derivative of GELU evaluated at the input.
- */
-struct dgelu {
-    template<typename T> static __device__ inline T op(const T &x);
-};
-template<> __device__ inline float dgelu::op<float>(const float &x) {
-    float tanh_out = fast_tanh(SQRT_2_OVER_PI * x * (1.f + GELU_COEFF * x * x));
-    return 0.5f * x * ((1.f - tanh_out * tanh_out) * (SQRT_2_OVER_PI + DGELU_COEFF * x * x)) +
-           0.5f * (1.f + tanh_out);
-}
-template<> __device__ inline float2 dgelu::op<float2>(const float2 &x) {
-    return float2{dgelu::op<float>(x.x), dgelu::op<float>(x.y)};
-}
-
-/**
- * @brief Copy operation.
- *
- * This operation returns the input value unchanged.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The input value.
- * @return The same value as the input.
- */
-struct copy { // for non-compile-time setters.
-    template<typename T> static __device__ inline T op(const T &a) { return a; }
-};
-
-
-/* ----------  BINARY OPS  ---------- */
-
-/**
- * @brief Copy2 operation.
- *
- * This operation returns the second input value unchanged.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value (ignored).
- * @param b[in] The second input value.
- * @return The same value as the second input.
- */
-struct copy2 { // this turns out to be a slightly hacky op that makes some code cleaner :/
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return b; }
-};
-/**
- * @brief Sum operation.
- *
- * This operation calculates the sum of two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The sum of the input values.
- */
-struct sum {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return a+b; }
-};
-template<> __device__ inline float2 sum::op<float2>(const float2 &a, const float2 &b) { return float2{a.x+b.x, a.y+b.y}; }
-template<> __device__ inline bf16   sum::op<bf16>  (const bf16   &a, const bf16   &b) { return __hadd(a, b);             }
-template<> __device__ inline bf16_2 sum::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __hadd2(a, b);            }
-template<> __device__ inline half   sum::op<half>  (const half   &a, const half   &b) { return __hadd(a, b);             }
-template<> __device__ inline half_2 sum::op<half_2>(const half_2 &a, const half_2 &b) { return __hadd2(a, b);            }
-/**
- * @brief Subtraction operation.
- *
- * This operation calculates the difference between two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The difference between the input values.
- */
-struct sub {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return a-b; }
-};
-template<> __device__ inline float2 sub::op<float2>(const float2 &a, const float2 &b) { return float2{a.x-b.x, a.y-b.y}; }
-template<> __device__ inline bf16   sub::op<bf16>  (const bf16   &a, const bf16   &b) { return __hsub(a, b);             }
-template<> __device__ inline bf16_2 sub::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __hsub2(a, b);            }
-template<> __device__ inline half   sub::op<half>  (const half   &a, const half   &b) { return __hsub(a, b);             }
-template<> __device__ inline half_2 sub::op<half_2>(const half_2 &a, const half_2 &b) { return __hsub2(a, b);            }
-/**
- * @brief Multiplication operation.
- *
- * This operation calculates the product of two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The product of the input values.
- */
-struct mul {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return a*b; }
-};
-template<> __device__ inline float2 mul::op<float2>(const float2 &a, const float2 &b) { return float2{a.x*b.x, a.y*b.y}; }
-template<> __device__ inline bf16   mul::op<bf16>  (const bf16   &a, const bf16   &b) { return __hmul(a, b);             }
-template<> __device__ inline bf16_2 mul::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __hmul2(a, b);            }
-template<> __device__ inline half   mul::op<half>  (const half   &a, const half   &b) { return __hmul(a, b);             }
-template<> __device__ inline half_2 mul::op<half_2>(const half_2 &a, const half_2 &b) { return __hmul2(a, b);            }
-/**
- * @brief Division operation.
- *
- * This operation calculates the quotient of two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The quotient of the input values.
- */
-struct div {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return a/b; }
-};
-template<> __device__ inline float2 div::op<float2>(const float2 &a, const float2 &b) { return float2{a.x/b.x, a.y/b.y}; }
-template<> __device__ inline bf16   div::op<bf16>  (const bf16   &a, const bf16   &b) { return __hdiv(a, b);             }
-template<> __device__ inline bf16_2 div::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __h2div(a, b);            } // this op is a special snowflake
-template<> __device__ inline half   div::op<half>  (const half   &a, const half   &b) { return __hdiv(a, b);             }
-template<> __device__ inline half_2 div::op<half_2>(const half_2 &a, const half_2 &b) { return __h2div(a, b);            }
-/**
- * @brief Maximum operation.
- *
- * This operation calculates the maximum of two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The maximum of the input values.
- */
- struct max {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return ::max(a, b); }
-};
-template<>  __device__ inline float2 max::op<float2>(const float2 &a, const float2 &b) { return float2{::max(a.x, b.x), ::max(a.y, b.y)};  }
-template<>  __device__ inline bf16   max::op<bf16>  (const bf16   &a, const bf16   &b) { return __hmax(a, b);                              }
-template<>  __device__ inline bf16_2 max::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __hmax2(a, b);                             }
-template<>  __device__ inline half   max::op<half>  (const half   &a, const half   &b) { return __hmax(a, b);                              }
-template<>  __device__ inline half_2 max::op<half_2>(const half_2 &a, const half_2 &b) { return half_2{__hmax(a.x, b.x), __hmax(a.y, b.y)}; }
-/**
- * @brief Minimum operation.
- *
- * This operation calculates the minimum of two input values.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @return The minimum of the input values.
- */
-struct min {
-    template<typename T> static __device__ inline T op(const T &a, const T &b) { return ::min(a, b); }
-};
-template<>  __device__ inline float2 min::op<float2>(const float2 &a, const float2 &b) { return float2{::min(a.x, b.x), ::min(a.y, b.y)};   }
-template<>  __device__ inline bf16   min::op<bf16>  (const bf16   &a, const bf16   &b) { return __hmin(a, b);                               }
-template<>  __device__ inline bf16_2 min::op<bf16_2>(const bf16_2 &a, const bf16_2 &b) { return __hmin2(a, b);                              }
-template<>  __device__ inline half   min::op<half>  (const half   &a, const half   &b) { return __hmin(a, b);                               }
-template<>  __device__ inline half_2 min::op<half_2>(const half_2 &a, const half_2 &b) { return half_2{__hmin(a.x, b.x), __hmin(a.y, b.y)};  }
-
-
-/* ----------  TERNARY OPS  ---------- */
-
-/**
- * @brief Fused multiply-add operation A * B + C.
- *
- * This operation performs a fused multiply-add, computing (A * B) + C with only one rounding.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The second input value.
- * @param c[in] The third input value to be added.
- * @return The result of the fused multiply-add operation.
- */
-struct fma_AxBtC {
-    template<typename T> static __device__ inline T op(const T &a, const T &b, const T &c) {
-        return sum::op<T>(mul::op<T>(a, b), c);
-    }
-};
-/**
- * @brief Fused multiply-add operation A * C + B.
- *
- * This operation performs a fused multiply-add, computing (A * C) + B with only one rounding.
- * This is particularly useful for attention mechanisms in neural networks.
- *
- * @tparam T The data type of the input and output values.
- * @param a[in] The first input value.
- * @param b[in] The third input value to be added.
- * @param c[in] The second input value.
- * @return The result of the fused multiply-add operation.
- */
-struct fma_AxCtB { // this is the one needed for attention
-    template<typename T> static __device__ inline T op(const T &a, const T &b, const T &c) {
-        return sum::op<T>(mul::op<T>(a, c), b);
-    }
-};
-
-} // namespace base_ops
-
-} // namespace kittens
@@ -1,454 +0,0 @@
-/**
- * @file
- * @brief Declarations, manipulations, and wrappers for basic types.
- * 
- * This file is a bunch of utilities for going back and forth between different types.
- * 
- * Many of them are for the compiler, so as to clean up the code. It unfortunately
- * seems necessary when we have types we really care about that are less than word width.
- */
-
-#pragma once
-
-#include <hip/hip_bf16.h>
-#include <hip/hip_fp16.h>
-#include <hip/hip_fp8.h>
-#include <hip/hip_fp4.h>
-#include <hip/amd_detail/amd_hip_ocp_types.h>
-#include <hip/hip_runtime.h>
-#include <string>
-#include <bit>
-
-typedef uint32_t __amd_fp8x4_storage_t;
-
-namespace kittens {
-
-// /**
-//  * @brief Bfloat16 floating-point type.
-//  */
-using bf16 = __hip_bfloat16;
-/**
- * @brief Half-precision floating-point type.
- */
-using half = __half;
-// /**
-//  * @brief Packed word of two bfloat16 floating-point values.
-//  */
-using bf16_2 = __hip_bfloat162;
-/**
- * @brief Packed word of two half-precision floating-point values.
- */
-using half_2 = __half2;
-/**
- * @brief float8 floating-point type.
- */
-using fp8e4m3 = __hip_fp8_e4m3;
-/**
- * @brief Packed word of two float8 floating-point values.
- */
-using fp8e4m3_2 = __hip_fp8x2_e4m3;
-/**
- * @brief Packed word of four float8 floating-point values.
- */
-using fp8e4m3_4 = __hip_fp8x4_e4m3;
-/**
- * @brief 8-bit exponent-only block-scaling scale type.
- */
-using fp8e8m0 = __amd_scale_t;
-/**
- * @brief Packed word of two 8-bit exponent-only block-scaling scale values.
- */
-using fp8e8m0_2 = __amd_fp8x2_storage_t;
-/**
- * @brief Packed word of four 8-bit exponent-only block-scaling scale values.
- */
-using fp8e8m0_4 = __amd_fp8x4_storage_t;
-/**
- * @brief FP4 E2M1 floating-point type.
- */
-using fp4e2m1   = __hip_fp4_e2m1;
-/**
- * @brief Packed word of two FP4 E2M1 floating-point values.
- */
-using fp4e2m1_2 = __hip_fp4x2_e2m1;
-/**
- * @brief Packed word of four FP4 E2M1 floating-point values.
- */
-using fp4e2m1_4 = __hip_fp4x4_e2m1;
-
-namespace ducks {
-/**
- * @namespace base_types
- *
- * @brief A namespace for concepts for basic data types.
- */
-namespace base_types {
-
-template<typename T>
-concept T2 = std::is_same_v<T, float2> || std::is_same_v<T, bf16_2> || std::is_same_v<T, half_2> || std::is_same_v<T, fp8e4m3_4>
-    || std::is_same_v<T, fp4e2m1_4>;
-template<typename T>
-concept T1 = std::is_same_v<T, float>  || std::is_same_v<T, bf16  > || std::is_same_v<T, half> || std::is_same_v<T, fp8e4m3>
-    || std::is_same_v<T, fp4e2m1>;
-
-} // namespace base_types
-} // namespace ducks
-
-/**
- * @namespace base_types
- *
- * @brief A namespace for ThunderKittens basic data types.
- */
-namespace base_types {
-
-/**
- * @brief Provides compile-time constants for different types.
- *
- * @tparam T The type for which to provide constants.
- */
-template<typename T> struct constants {
-    /**
-     * @brief Zero
-     * @return Constexpr zero with type T
-     */
-    static __device__ inline constexpr T zero()      { return T{0}; }
-    /**
-     * @brief Ones
-     * @return Constexpr ones with type T
-     */
-    static __device__ inline constexpr T ones()       { return T{1}; }
-    /**
-     * @brief Positive infinity. Particularly useful for initializing before a min op.
-     * @return Constexpr positive infinity with type T
-     */
-    static __device__ inline constexpr T pos_infty() { return T{INFINITY}; } // I'll find a better way at some point but this appears to work.
-    /**
-     * @brief Negative infinity. Particularly useful for initializing before a max op.
-     * @return Constexpr negative infinity with type T
-     */
-    static __device__ inline constexpr T neg_infty() { return T{-INFINITY}; }
-};
-template<> struct constants<float2> {
-    static __device__ inline constexpr float2 zero()      { return float2{0.f, 0.f}; }
-    static __device__ inline constexpr float2 ones()       { return float2{1.f, 1.f}; }
-    static __device__ inline constexpr float2 pos_infty() { return float2{constants<float>::pos_infty(), constants<float>::pos_infty()}; }
-    static __device__ inline constexpr float2 neg_infty() { return float2{constants<float>::neg_infty(), constants<float>::neg_infty()}; }
-};
-template<> struct constants<bf16> {
-    static __device__ inline constexpr bf16 zero()      { return std::bit_cast<bf16>(uint16_t(0x0000)); } // unfortunately __float2bf16_rn is not constexpr
-    static __device__ inline constexpr bf16 ones()       { return std::bit_cast<bf16>(uint16_t(0x3F80)); }
-    static __device__ inline constexpr bf16 pos_infty() { return std::bit_cast<bf16>(uint16_t(0x7F80)); }
-    static __device__ inline constexpr bf16 neg_infty() { return std::bit_cast<bf16>(uint16_t(0xFF80)); }
-};
-template<> struct constants<bf16_2> {
-    static __device__ inline bf16_2 zero()      { return bf16_2{constants<bf16>::zero(),      constants<bf16>::zero()};      }
-    static __device__ inline bf16_2 ones()       { return bf16_2{constants<bf16>::ones(),       constants<bf16>::ones()};       }
-    static __device__ inline bf16_2 pos_infty() { return bf16_2{constants<bf16>::pos_infty(), constants<bf16>::pos_infty()}; }
-    static __device__ inline bf16_2 neg_infty() { return bf16_2{constants<bf16>::neg_infty(), constants<bf16>::neg_infty()}; }
-};
-template<> struct constants<half> {
-    static __device__ inline constexpr half zero()      { return std::bit_cast<half>(uint16_t(0x0000)); }
-    static __device__ inline constexpr half ones()       { return std::bit_cast<half>(uint16_t(0x3C00)); }
-    static __device__ inline constexpr half pos_infty() { return std::bit_cast<half>(uint16_t(0x7C00)); }
-    static __device__ inline constexpr half neg_infty() { return std::bit_cast<half>(uint16_t(0xFC00)); }
-};
-template<> struct constants<half_2> {
-    static __device__ inline constexpr half_2 zero()      { return std::bit_cast<half_2>(uint32_t(0x00000000)); }
-    static __device__ inline constexpr half_2 ones()       { return std::bit_cast<half_2>(uint32_t(0x3C003C00)); }
-    static __device__ inline constexpr half_2 pos_infty() { return std::bit_cast<half_2>(uint32_t(0x7C007C00)); }
-    static __device__ inline constexpr half_2 neg_infty() { return std::bit_cast<half_2>(uint32_t(0xFC00FC00)); }
-};
-template<> struct constants<fp8e4m3> {
-    static __device__ inline constexpr fp8e4m3 zero() { return std::bit_cast<fp8e4m3>(uint8_t(0x00)); }
-    static __device__ inline constexpr fp8e4m3 one() { return std::bit_cast<fp8e4m3>(uint8_t(0x38)); }
-};
-template<> struct constants<fp8e4m3_2> {
-    static __device__ inline constexpr fp8e4m3_2 zero() { return std::bit_cast<fp8e4m3_2>(uint16_t(0x0000)); }
-    static __device__ inline constexpr fp8e4m3_2 one() { return std::bit_cast<fp8e4m3_2>(uint16_t(0x3838)); }
-};
-template<> struct constants<fp8e4m3_4> {
-    static __device__ inline constexpr fp8e4m3_4 zero() { return std::bit_cast<fp8e4m3_4>(uint32_t(0x00000000)); }
-    static __device__ inline constexpr fp8e4m3_4 one() { return std::bit_cast<fp8e4m3_4>(uint32_t(0x38383838)); }
-};
-template<> struct constants<fp8e8m0> {
-    static __device__ inline constexpr fp8e8m0 zero() { return std::bit_cast<fp8e8m0>(uint8_t(0x00)); } // not actually 0
-    static __device__ inline constexpr fp8e8m0 one() { return std::bit_cast<fp8e8m0>(uint8_t(0x7F)); }
-};
-template<> struct constants<fp8e8m0_2> {
-    static __device__ inline constexpr fp8e8m0_2 zero() { return std::bit_cast<fp8e8m0_2>(uint16_t(0x0000)); } // not actually 0
-    static __device__ inline constexpr fp8e8m0_2 one() { return std::bit_cast<fp8e8m0_2>(uint16_t(0x7F7F)); }
-};
-template<> struct constants<fp8e8m0_4> {
-    static __device__ inline constexpr fp8e8m0_4 zero() { return std::bit_cast<fp8e8m0_4>(uint32_t(0x00000000)); } // not actually 0
-    static __device__ inline constexpr fp8e8m0_4 one() { return std::bit_cast<fp8e8m0_4>(uint32_t(0x7F7F7F7F)); }
-};
-template<> struct constants<fp4e2m1> {
-    static __device__ inline constexpr fp4e2m1 zero() { return std::bit_cast<fp4e2m1>(uint8_t(0x00)); }
-    static __device__ inline constexpr fp4e2m1 one()  { return std::bit_cast<fp4e2m1>(uint8_t(0x02)); }
-};
-template<> struct constants<fp4e2m1_4> {
-    static __device__ inline constexpr fp4e2m1_4 zero() { return std::bit_cast<fp4e2m1_4>(uint16_t(0x0000)); }
-    static __device__ inline constexpr fp4e2m1_4 one()  { return std::bit_cast<fp4e2m1_4>(uint16_t(0x2222)); }
-};
-template<> struct constants<int> {
-    static __device__ inline constexpr int zero()      { return 0; }
-    static __device__ inline constexpr int ones()       { return 1; }
-};
-template<> struct constants<int2> {
-    static __device__ inline constexpr int2 zero()      { return int2{0, 0}; }
-    static __device__ inline constexpr int2 ones()       { return int2{1, 1}; }
-};
-
-/**
- * @brief Provides information about packing of elements for a given type.
- *
- * @tparam T The type for which to provide packing information.
- */
-template<typename T> struct packing {
-    /**
-     * @brief The number of elements packed together.
-     *
-     * @return constexpr int representing number of elements within the type.
-     */
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    /**
-     * @brief Packs a single T element twice (replicated) into its packed type.
-     *
-     * @param i[in] The element to pack.
-     * @return The packed type.
-     */
-    static __device__ inline constexpr T pack(const auto &i);
-};
-template<> struct packing<bf16> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = bf16;
-    using packed_type = bf16_2;
-    static __device__ inline bf16_2 pack(const bf16 &i) { return bf16_2{i, i}; }
-};
-template<> struct packing<bf16_2> {
-    static __host__ __device__ inline constexpr int num() { return 2; }
-    using unpacked_type = bf16;
-    using packed_type = bf16_2;
-    static __device__ inline bf16_2 pack(const bf16 &i) { return bf16_2{i, i}; } // this replication makes code cleaner later.
-};
-template<> struct packing<half> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = half;
-    using packed_type = half_2;
-    static __device__ inline constexpr half_2 pack(const half &i) { return half_2{i, i}; }
-};
-template<> struct packing<half_2> {
-    static __host__ __device__ inline constexpr int num() { return 2; }
-    using unpacked_type = half;
-    using packed_type = half_2;
-    static __device__ inline constexpr half_2 pack(const half &i) { return half_2{i, i}; } // this replication makes code cleaner later.
-};
-template<> struct packing<float> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = float;
-    using packed_type = float2;
-    static __device__ inline constexpr float2 pack(const float &i) { return float2{i, i}; }
-};
-template<> struct packing<float2> {
-    static __host__ __device__ inline constexpr int num() { return 2; }
-    using unpacked_type = float;
-    using packed_type = float2;
-    static __device__ inline constexpr float2 pack(const float &i) { return float2{i, i}; } // this replication makes code cleaner later.
-};
-template<> struct packing<int> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = int;
-    using packed_type = int2;
-    static __device__ inline constexpr int2 pack(const int &i) { return int2{i, i}; } // this replication makes code cleaner later.
-};
-template<> struct packing<int2> {
-    static __host__ __device__ inline constexpr int num() { return 2; }
-    using unpacked_type = int;
-    using packed_type = int2;
-    static __device__ inline constexpr int2 pack(const int &i) { return int2{i, i}; } // this replication makes code cleaner later.
-};
-template<> struct packing<float4> {
-    static __host__ __device__ inline constexpr int num() { return 4; }
-};
-template<> struct packing<int4> {
-    static __host__ __device__ inline constexpr int num() { return 4; }
-};
-template<> struct packing<fp8e4m3> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = fp8e4m3;
-    using packed_type = fp8e4m3_4;
-};
-template<> struct packing<fp8e4m3_4> {
-    static __host__ __device__ inline constexpr int num() { return 4; }
-    using unpacked_type = fp8e4m3;
-    using packed_type = fp8e4m3_4;
-};
-template<> struct packing<fp8e8m0> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = fp8e8m0;
-    using packed_type = fp8e8m0_4;
-};
-template<> struct packing<fp8e8m0_4> {
-    static __host__ __device__ inline constexpr int num() { return 4; }
-    using unpacked_type = fp8e8m0;
-    using packed_type = fp8e8m0_4;
-};
-template<> struct packing<fp4e2m1> {
-    static __host__ __device__ inline constexpr int num() { return 1; }
-    using unpacked_type = fp4e2m1;
-    using packed_type = fp4e2m1_4;
-};
-template<> struct packing<fp4e2m1_4> {
-    static __host__ __device__ inline constexpr int num() { return 4; }
-    using unpacked_type = fp4e2m1;
-    using packed_type = fp4e2m1_4;
-};
-
-/**
- * @brief Provides templated functionality to convert between different types.
- *
- * @tparam T The target type for conversion.
- * @tparam U The source type for conversion.
- */
-template<typename T, typename U> struct convertor {
-    /**
-     * @brief Converts a value of type U to type T.
-     *
-     * @param u[in] The value of type U to convert.
-     * @return T The converted value of type T.
-     */
-    static __host__ __device__ inline T convert(const U & u) {
-        return (T)u;
-    }
-};
-template<> struct convertor<float, bf16> {
-    static __host__ __device__ inline float convert(const bf16 & u) {
-        return 	__bfloat162float(u);
-    }
-};
-// template<> struct convertor<bf16, float> {
-//     static __host__ __device__ inline bf16 convert(const float & u) {
-//         return 	__float2bfloat16(u);
-//     }
-// };
-template<> struct convertor<bf16, float> {
-    static __host__ __device__ inline bf16 convert(const float &u) {
-        // Fast unsafe conversion (truncation only)
-        return std::bit_cast<bf16>(
-            static_cast<uint16_t>(
-                std::bit_cast<uint32_t>(u) >> 16
-            )
-        );
-    }
-};
-template<> struct convertor<float2, bf16_2> {
-    static __host__ __device__ inline float2 convert(const bf16_2 & u) {
-        return 	__bfloat1622float2(u);
-    }
-};
-
-template<> struct convertor<bf16_2, float2> {
-    static __host__ __device__ inline bf16_2 convert(const float2 &u) {
-        uint32_t result;
-        asm volatile("v_cvt_pk_bf16_f32 %0, %1, %2" 
-                     : "=v"(result) 
-                     : "v"(u.x), "v"(u.y));
-        return *reinterpret_cast<bf16_2*>(&result);
-    }
-};
-
-
-template<> struct convertor<float, half> {
-    static __host__ __device__ inline float convert(const half & u) {
-        return __half2float(u);
-    }
-};
-template<> struct convertor<half, float> {
-    static __host__ __device__ inline half convert(const float & u) {
-        return __float2half(u);
-    }
-};
-template<> struct convertor<float2, half_2> {
-    static __host__ __device__ inline float2 convert(const half_2 & u) {
-        return __half22float2(u);
-    }
-};
-template<> struct convertor<half_2, float2> {
-    static __host__ __device__ inline half_2 convert(const float2 & u) {
-        return __float22half2_rn(u);
-    }
-};
-template<> struct convertor<bf16, half> {
-    static __host__ __device__ inline bf16 convert(const half & u) {
-        return __float2bfloat16(__half2float(u));
-    }
-};
-template<> struct convertor<half, bf16> {
-    static __host__ __device__ inline half convert(const bf16 & u) {
-        return __float2half(__bfloat162float(u));
-    }
-};
-template<> struct convertor<bf16_2, half_2> {
-    static __host__ __device__ inline bf16_2 convert(const half_2 & u) {
-        return __float22bfloat162_rn(__half22float2(u));
-    }
-};
-template<> struct convertor<half_2, bf16_2> {
-    static __host__ __device__ inline half_2 convert(const bf16_2 & u) {
-        return __float22half2_rn(__bfloat1622float2(u));
-    }
-};
-template<> struct convertor<fp8e4m3_4, float4> {
-    static __host__ __device__ inline fp8e4m3_4 convert(const float4& u) {
-        return fp8e4m3_4(u);
-    }
-};
-template<> struct convertor<float4, fp8e4m3_4> {
-    static __host__ __device__ inline float4 convert(const fp8e4m3_4& u) {
-        fp8e4m3 *vals = reinterpret_cast<fp8e4m3*>(const_cast<fp8e4m3_4*>(&u));
-        return make_float4(float(vals[0]), float(vals[1]), float(vals[2]), float(vals[3]));
-    }
-};
-template<> struct convertor<fp8e4m3_2, float2> {
-    static __host__ __device__ inline fp8e4m3_2 convert(const float2& u) {
-        return fp8e4m3_2(u);
-    }
-};
-template<> struct convertor<float2, fp8e4m3_2> {
-    static __host__ __device__ inline float2 convert(const fp8e4m3_2& u) {
-        fp8e4m3 *vals = reinterpret_cast<fp8e4m3*>(const_cast<fp8e4m3_2*>(&u));
-        return make_float2(float(vals[0]), float(vals[1]));
-    }
-};
-template<> struct convertor<fp8e4m3, float> {
-    static __host__ __device__ inline fp8e4m3 convert(const float & u) {
-        return fp8e4m3(u);
-    }
-};
-template<> struct convertor<float, fp8e4m3> {
-    static __host__ __device__ inline float convert(const fp8e4m3 & u) {
-        return float(u);
-    }
-};
-template<> struct convertor<fp4e2m1, float> {
-    static __host__ __device__ inline fp4e2m1 convert(const float & u) {
-        return fp4e2m1(u);
-    }
-};
-template<> struct convertor<float, fp4e2m1> {
-    static __host__ __device__ inline float convert(const fp4e2m1 & u) {
-        return float(u);
-    }
-};
-template<> struct convertor<fp4e2m1_4, float4> {
-    static __host__ __device__ inline fp4e2m1_4 convert(const float4& u) {
-        return fp4e2m1_4(u);
-    }
-};
-template<> struct convertor<float4, fp4e2m1_4> {
-    static __host__ __device__ inline float4 convert(const fp4e2m1_4& u) {
-        return float4(u);
-    }
-};
-}
-}
@@ -1,13 +0,0 @@
-/**
- * @file
- * @brief A collection of common resources on which HipKittens depends.
- */
- 
-
-#pragma once
-
-#include "util.cuh"
-#include "base_types.cuh"
-#include "base_ops.cuh"
-
-#include "macros.cuh"
@@ -1,56 +0,0 @@
-#pragma once
-
-// Reset
-#define TK_RESET "\033[0m"
-
-// Foreground colors
-#define TK_FG_BLACK "\033[30m"
-#define TK_FG_RED "\033[31m"
-#define TK_FG_GREEN "\033[32m"
-#define TK_FG_YELLOW "\033[33m"
-#define TK_FG_BLUE "\033[34m"
-#define TK_FG_MAGENTA "\033[35m"
-#define TK_FG_CYAN "\033[36m"
-#define TK_FG_WHITE "\033[37m"
-
-// Background colors
-#define TK_BG_BLACK "\033[40m"
-#define TK_BG_RED "\033[41m"
-#define TK_BG_GREEN "\033[42m"
-#define TK_BG_YELLOW "\033[43m"
-#define TK_BG_BLUE "\033[44m"
-#define TK_BG_MAGENTA "\033[45m"
-#define TK_BG_CYAN "\033[46m"
-#define TK_BG_WHITE "\033[47m"
-
-// Bright foreground colors
-#define TK_FG_BRIGHT_BLACK "\033[90m"
-#define TK_FG_BRIGHT_RED "\033[91m"
-#define TK_FG_BRIGHT_GREEN "\033[92m"
-#define TK_FG_BRIGHT_YELLOW "\033[93m"
-#define TK_FG_BRIGHT_BLUE "\033[94m"
-#define TK_FG_BRIGHT_MAGENTA "\033[95m"
-#define TK_FG_BRIGHT_CYAN "\033[96m"
-#define TK_FG_BRIGHT_WHITE "\033[97m"
-
-// Bright background colors
-#define TK_BG_BRIGHT_BLACK "\033[100m"
-#define TK_BG_BRIGHT_RED "\033[101m"
-#define TK_BG_BRIGHT_GREEN "\033[102m"
-#define TK_BG_BRIGHT_YELLOW "\033[103m"
-#define TK_BG_BRIGHT_BLUE "\033[104m"
-#define TK_BG_BRIGHT_MAGENTA "\033[105m"
-#define TK_BG_BRIGHT_CYAN "\033[106m"
-#define TK_BG_BRIGHT_WHITE "\033[107m"
-
-// Text styles
-#define TK_BOLD "\033[1m"
-#define TK_DIM "\033[2m"
-#define TK_ITALIC "\033[3m"
-#define TK_UNDERLINE "\033[4m"
-#define TK_BLINK "\033[5m"
-#define TK_REVERSE "\033[7m"
-#define TK_HIDDEN "\033[8m"
-
-// Macro to combine styles
-#define TK_STYLE(...)  "\033[" #__VA_ARGS__ "m"
@@ -1,437 +0,0 @@
-/**
- * @file
- * @brief General utilities for ThunderKittens.
- */
-
-#pragma once
-
-#include <stdint.h>
-#include <type_traits>
-#include <concepts>
-#include <memory>
-
-#include <hip/hip_runtime.h>
-
-#include "base_types.cuh"
-
-#ifndef __forceinline__
-#define __forceinline__ __attribute__((always_inline))
-#endif
-
-/**
- * @namespace kittens
- *
- * @brief The main namespace of ThunderKittens.
- */
-namespace kittens {
-
-/* ----------  GENERAL CONSTANTS FOR KITTENS  ---------- */
-/**
- * @brief Constant representing number of threads in a warp.
- *
- * gfx1250 (UDNA1) is wave-32.
- */
-constexpr int WARP_THREADS{32};
-
-/**
-
- * @brief Get the warp ID of the current thread.
- * @return The warp ID.
- */
-__device__ __forceinline__ int warpid() { return threadIdx.x >> 5; }
-
-/**
- * @brief Get the number of warps in the threadblock.
- * @return The number of warps in the threadblock.
- */
- __device__ __forceinline__ int num_warps() { return blockDim.x / WARP_THREADS; }
-
-/**
- * @brief Get the lane ID of the current thread within its warp.
- * @return The lane ID.
- */
-__device__ __forceinline__ int laneid() { return threadIdx.x & 0x1f; }
-
-using i32x2 = int32_t __attribute__((ext_vector_type(2)));
-using u32x2 = uint32_t __attribute__((ext_vector_type(2)));
-using i32x3 = int32_t __attribute__((ext_vector_type(3)));
-using u32x3 = uint32_t __attribute__((ext_vector_type(3)));
-using i32x4 = int32_t __attribute__((ext_vector_type(4)));
-using u32x4 = uint32_t __attribute__((ext_vector_type(4)));
-
-struct buffer_resource {
-    uint64_t ptr;
-    uint32_t range;
-    uint32_t config;
-};
-
-/**
- * @brief Compute the ceiling division of two integers.
- * @param a The dividend.
- * @param b The divisor.
- * @return The ceiling division result.
- */
-__host__ __device__ inline int ceil_div(int a, int b) {
-    return (a + b - 1) / b;
-  }
-
-/**
-   * @brief Transform a workgroup ID to a new workgroup ID based on the chunk size and number of XCDs.
-   * @param workgroup_id The original workgroup ID.
-   * @param num_workgroups The total number of workgroups.
-   * @param num_xcds The number of XCDs.
-   * @param chunk_size The chunk size.
-   * @return The new workgroup ID.
-   */
-   __host__ __device__ inline int chiplet_transform_chunked(
-    int workgroup_id, 
-    int num_workgroups,
-    int num_xcds,
-    int chunk_size 
-) {
-    // Current XCD
-    int xcd = workgroup_id % num_xcds;
-
-    // Largest full (NUM_XCDS*CHUNK_SIZE)-aligned block
-    int block = num_xcds * chunk_size;
-    int limit = (num_workgroups / block) * block;
-
-    // If pid beyond the last full block, leave unchanged
-    if (workgroup_id > limit) return workgroup_id;
-
-    // Local PID (within round-robin assignment)
-    int local_pid    = workgroup_id / num_xcds;
-    int chunk_idx    = local_pid / chunk_size;
-    int pos_in_chunk = local_pid % chunk_size;
-
-    // New PID
-    return chunk_idx * block + xcd * chunk_size + pos_in_chunk;
-}
-
-
-/**
- * @brief gfx1250 LDS capacity constants.
- *
- * On gfx1250, the **LDS scratchpad and the L1 data cache are one 384 KB SRAM
- * pool per Compute Unit (CU)**, partitioned into six 64 KB segments. 
- * At least one segment must remain L1, leaving up to five segments
- * (320 KB) addressable as LDS.
- *
- * `MAX_SHARED_MEMORY_PER_SEGMENT` is one 64 KB segment; `MAX_SHARED_MEMORY` is
- * the full addressable LDS across all five segments. A kernel that fits in one
- * segment requests `MAX_SHARED_MEMORY_PER_SEGMENT`; one that needs more requests
- * a larger dynamic shared-memory size at launch via `hipFuncSetAttribute`.
- */
-constexpr int MAX_SHARED_MEMORY_PER_SEGMENT = 65536;
-constexpr int SHARED_MEMORY_NUM_SEGMENTS    = 5;
-constexpr int MAX_SHARED_MEMORY             = MAX_SHARED_MEMORY_PER_SEGMENT * SHARED_MEMORY_NUM_SEGMENTS;
-constexpr int NUM_XCDS = 1;
-constexpr int CUS_PER_XCD = 64;
-constexpr int NUM_CUS = CUS_PER_XCD * NUM_XCDS;
-
-/* ----------  CUSTOM TYPES  ---------- */
-typedef uint32_t      uint2_t __attribute__((ext_vector_type(2)));
-
-/* ----------  TYPE HELPERS  ---------- */
-
-/**
- * @namespace ducks
- *
- * @brief ThunderKittens' namespace for template metaprogramming..
- * 
- * This includes primarily dummy types and concept wrappers, along
- * with a few additional utilities.
- */
-namespace ducks {
-
-/**
- * @brief A type representing an empty default for a template.
- */
-struct default_type {};
-
-// This macro can't be done as a template, so it doesn't really have a location in kittens.
-#define typeof(A) typename std::remove_const<typename std::remove_reference<decltype(A)>::type>::type
-
-}
-
-/* ----------  SHUFFLE UTILS  ---------- */
-
-/**
- * @brief Mask constant for all active threads in a warp.
- */
-static constexpr uint64_t MASK_ALL = 0xFFFFFFFFFFFFFFFF;
-
-/**
- * @brief Perform a shuffle down operation on a packed type synchronously across a warp.
- * @tparam T The type of the value to be shuffled.
- * @param mask[in] The mask of active threads.
- * @param f[in] The value to be shuffled.
- * @param delta[in] The number of positions to shuffle down.
- * @return The result of the shuffle operation.
- */
-template<typename T>
-__device__ static inline T packed_shfl_down(uint64_t mask, const T &f, int delta) {
-
-    if constexpr (std::is_same_v<T, bf16_2> || std::is_same_v<T, bf16>) {
-        static_assert(sizeof(__hip_bfloat162) == sizeof(unsigned int));
-        union {
-          __hip_bfloat162 bf162;
-          unsigned int ui;
-        } u;
-
-        if constexpr (std::is_same_v<T, bf16_2>) {
-            u.bf162 = *reinterpret_cast<const __hip_bfloat162*>(&f);
-        } else {
-            u.bf162 = __hip_bfloat162{*reinterpret_cast<const __hip_bfloat16*>(&f), 
-                                       *reinterpret_cast<const __hip_bfloat16*>(&f)};
-        }
-
-        u.ui = __shfl_down_sync<unsigned long long, unsigned int>(mask, u.ui, delta, 64);
-        if constexpr (std::is_same_v<T, bf16>) {
-            return *reinterpret_cast<const T*>(&u.bf162.x);  // Extract single bf16 from the .x component
-        } else {
-            return u.bf162;  // Return full bf162 for bf16_2 case
-        }
-    } else {
-        return __shfl_down(f, delta);
-    }
-}
-template<>
-__device__ inline float2 packed_shfl_down<float2>(uint64_t mask, const float2 &f, int delta) {
-    float2 r;
-    r.x = __shfl_down(f.x, delta);
-    r.y = __shfl_down(f.y, delta);
-    return r;
-}
-/**
- * @brief Perform a packed shuffle operation synchronously across a warp.
- * @tparam T The type of the value to be shuffled.
- * @param mask[in] The mask of active threads.
- * @param f[in] The value to be shuffled.
- * @param src[in] The source lane from which to shuffle.
- * @return The result of the shuffle operation.
- */
-template<typename T>
-__device__ static inline T packed_shfl(uint64_t mask, const T &f, int src) {
-    return __shfl(f, src);
-}
-template<>
-__device__ inline bf16 packed_shfl(uint64_t mask, const bf16 &f, int src) {
-    float r = __shfl(base_types::convertor<float, bf16>::convert(f), src);
-    return base_types::convertor<bf16, float>::convert(r);
-}
-template<>
-__device__ inline bf16_2 packed_shfl(uint64_t mask, const bf16_2 &f, int src) {
-    float2 r;
-    r.x = __shfl(base_types::convertor<float, bf16>::convert(f.x), src);
-    r.y = __shfl(base_types::convertor<float, bf16>::convert(f.y), src);
-    return base_types::convertor<bf16_2, float2>::convert(r);
-}
-template<>
-__device__ inline half packed_shfl(uint64_t mask, const half &f, int src) {
-    float r = __shfl(base_types::convertor<float, half>::convert(f), src);
-    return base_types::convertor<half, float>::convert(r);
-}
-template<>
-__device__ inline half_2 packed_shfl(uint64_t mask, const half_2 &f, int src) {
-    float2 r;
-    r.x = __shfl(base_types::convertor<float, half>::convert(f.x), src);
-    r.y = __shfl(base_types::convertor<float, half>::convert(f.y), src);
-    return base_types::convertor<half_2, float2>::convert(r);
-}
-template<>
-__device__ inline float2 packed_shfl<float2>(uint64_t mask, const float2 &f, int src) {
-    float2 r;
-    r.x = __shfl(f.x, src);
-    r.y = __shfl(f.y, src);
-    return r;
-}
-
-using bytes_4  = HIP_vector_type<float, 1>;
-using bytes_8  = HIP_vector_type<float, 2>;
-using bytes_16 = HIP_vector_type<float, 4>;
-
-/* ----------  SHARED MEMORY UTILS  ---------- */
-
-// namespace ducks {
-// namespace sb {
-// struct identifier {};
-// }
-// }
-
-// template<typename Args...>
-// struct sb {
-//     using identifier = ducks::sb::identifier;
-//     Args... args;
-// };
-
-// namespace ducks {
-// namespace sb {
-// template<typename T> concept all = requires {
-//     typename T::identifier;
-// } && std::is_same_v<T::identifier, identifier>;
-// }
-// }
-
-#define KITTENS_ALIGN_AS(n) alignas(n)
-#define KITTENS_DEFAULT_ALIGN KITTENS_ALIGN_AS(16)
-
-/**
- * @brief Dummy structure for alignment purposes. Needed for WGMMA and TMA calls.
- */
-struct KITTENS_DEFAULT_ALIGN alignment_dummy { int dummy; };
-
-namespace detail {
-/// @brief 16B (`int4`) vector types tagged with the address spaces the gfx1250
-///        `*_load_async_to_lds_b128` builtins require (AS1 = global, AS3 = LDS).
-using i32x4_vec   = int __attribute__((__vector_size__(16)));
-using i32x4_gvec  = int __attribute__((__vector_size__(16))) __attribute__((address_space(1)));
-using i32x4_lvec  = int __attribute__((__vector_size__(16))) __attribute__((address_space(3)));
-} // namespace detail
-
-/**
- * @brief Compile-time tag selecting an LDS segment for tile placement on gfx1250.
- *
- * Background. LDS and L1 share one 384 KB SRAM pool per Compute Unit (CU),
- * partitioned at dispatch into six 64 KB segments (see `MAX_SHARED_MEMORY`
- * above). Up to five segments (indices 0..4, total 320 KB) are addressable as
- * LDS scratchpad; at least one segment must remain L1. By convention we leave
- * segment 5 as L1, so LDS-tile placement uses indices 0..4.
- *
- * Why segments matter. The LDS half of the pool is fronted by two read ports
- * delivering 256 B/cycle each. The two ports can issue in the same cycle only
- * when they target **different** segments, so placing operand `A` in
- * `segment<0>` and operand `B` in `segment<1>` lets the hardware satisfy both
- * reads in parallel and reach the full 512 B/cycle peak. Co-locating `A` and
- * `B` in the same segment serialises them at 256 B/cycle.
- *
- * @tparam IDX 0..4 -- segment index. The allocator aligns the allocation start
- * to `IDX * 64 KB` so multiple tiles can share a single segment.
- */
-template<int IDX>
-struct segment {
-    static_assert(IDX >= 0 && IDX < SHARED_MEMORY_NUM_SEGMENTS,
-                  "segment index must be in [0, 5)");
-    static constexpr int index       = IDX;
-    static constexpr int byte_offset = IDX * MAX_SHARED_MEMORY_PER_SEGMENT;
-};
-
-namespace ducks {
-namespace segment_tag {
-template<typename T> struct is_segment : std::false_type {};
-template<int I>      struct is_segment<::kittens::segment<I>> : std::true_type {};
-template<typename T> concept all = is_segment<T>::value;
-} // namespace segment_tag
-} // namespace ducks
-/**
- * @brief Very simple allocator for dynamic shared memory. Advances pointer and tracks alignments.
- *
- * Maintains a bump cursor `ptr` that advances on every `allocate*()` call. On
- * gfx1250 the allocator also remembers `base` -- the unmoved origin of the
- * shared-memory region captured at construction -- so segment-aware
- * allocations (`allocate_in<segment<IDX>>`) can jump to `base + IDX * 64 KB`
- * regardless of how far the bump cursor has already advanced.
- *
- * @tparam default_alignment The default alignment this allocator will enforce. If <=0 (default -1) it will not align.
- */
-template<int default_alignment=16> 
-struct shared_allocator {
-    int *ptr;   ///< Bump cursor; advances on every allocate*() call.
-    int *base;  ///< Frozen origin captured at construction; never moves.
-                ///< Reference point for `allocate_in<segment<IDX>>` segment starts.
-
-    private:
-        // Recursive template to generate N-dimensional array type
-        template<typename A, size_t... dims>
-        struct variadic_array;
-        template<typename A, size_t first_dim, size_t... rest_dims>
-        struct variadic_array<A, first_dim, rest_dims...> {
-            using type = typename variadic_array<A, rest_dims...>::type[first_dim];
-        };
-        template<typename A>
-        struct variadic_array<A> {
-            using type = A;
-        };
-        template<typename A, size_t... dims> 
-        using variadic_array_t = typename variadic_array<A, dims...>::type;
-
-        template<int alignment>
-        __device__ inline void align_ptr() {
-            if constexpr (alignment > 0) {
-                uint64_t p = reinterpret_cast<uint64_t>(ptr);
-                if(p % alignment != 0) {
-                    ptr = (int*)(p + (alignment-(p%alignment)));
-                }
-            }
-        }
-
-    public:
-        /**
-        * @brief Construct a new shared allocator using a pointer to extern shared memory.
-        *
-        * `_ptr` is captured into the bump cursor `ptr`; on gfx1250 it is also
-        * stashed into `base` so segment-aware allocations can recover the
-        * original origin regardless of how far the cursor has advanced.
-        *
-        * @param[in] _ptr Pointer to the start of the extern shared memory.
-        */
-        __device__ shared_allocator(int *_ptr): ptr(_ptr), base(_ptr) {}
-        /**
-        * @brief Allocate shared memory for a single instance or N-dimensional array of type A.
-        * @tparam A The type of the object to allocate.
-        * @tparam dims... A list of dimensions for the N-dimensional array.
-        * @return Reference to the allocated object.
-        */
-        template<typename A, size_t... dims> 
-        __device__ inline variadic_array_t<A, dims...>& allocate() {
-            // static_assert(sizeof(A) % default_alignment == 0, "Type is not aligned properly for array allocation");
-            align_ptr<default_alignment>();
-            using at = variadic_array_t<A, dims...>;
-            at*p = reinterpret_cast<at*>(ptr);
-            ptr += sizeof(at)/sizeof(int);
-            return *p;
-        }
-        /**
-        * @brief Allocate shared memory for a single instance or N-dimensional array of type A.
-        * @tparam alignment An alignment to enforce for this particular object.
-        * @tparam A The type of the object to allocate.
-        * @tparam dims... A list of dimensions for the N-dimensional array.
-        * @return Reference to the allocated object.
-        */
-        template<int alignment, typename A, size_t... dims> 
-        __device__ inline variadic_array_t<A, dims...>& allocate() {
-            // static_assert(sizeof(A) % alignment == 0, "Type is not aligned properly for array allocation");
-            align_ptr<alignment>();
-            using at = variadic_array_t<A, dims...>;
-            at*p = reinterpret_cast<at*>(ptr);
-            ptr += sizeof(at)/sizeof(int);
-            return *p;
-        }
-
-        /**
-        * @brief Allocate shared memory inside a specific LDS segment on gfx1250.
-        *
-        * Positions the allocator pointer at `base + IDX * 64KB` (where `base`
-        * is the dynamic-shared-memory pointer this allocator was constructed
-        * with), then allocates the requested type there. Multiple
-        * `allocate_in<segment<IDX>>` calls into the same segment pack tightly.
-        *
-        * @tparam SEG    A `kittens::segment<IDX>` tag.
-        * @tparam A      The type of the object to allocate.
-        * @tparam dims   Optional array dimensions.
-        */
-        template<typename SEG, typename A, size_t... dims>
-            requires ducks::segment_tag::all<SEG>
-        __device__ inline variadic_array_t<A, dims...>& allocate_in() {
-            int* target = base + (SEG::byte_offset / sizeof(int));
-            // If we've already allocated past the requested segment, keep
-            // packing where we are; otherwise jump forward to the segment.
-            if (ptr < target) ptr = target;
-            using at = variadic_array_t<A, dims...>;
-            at* p = reinterpret_cast<at*>(ptr);
-            ptr += sizeof(at) / sizeof(int);
-            return *p;
-        }
-};
-
-} // namespace kittens
@@ -1,10 +0,0 @@
-/**
- * @file
- * @brief Aggregate header for UDNA1 (gfx1250) ThunderKittens core include tree.
- */
-
-#pragma once
-
-#include "common/common.cuh"
-#include "types/types.cuh"
-#include "ops/ops.cuh"
@@ -1,32 +0,0 @@
-/**
- * @file
- * @brief An aggregate header of all group (multi-warp) operations defined by ThunderKittens
- */
-
-#pragma once
-
-#include "../../common/common.cuh"
-#include "../../types/types.cuh"
-#include "../warp/warp.cuh" // several group memory ops rely on underlying warp-scope ops
-
-// A "warpgroup" is a special group of 4 consecutive warps defined by NVIDIA for certain SM_90+ operations.
-#define KITTENS_CHECK_WARPGROUP static_assert(N_WARPS==4, "PTX warpgroup (N_WARPS=4) function called from a non-warpgroup group.");
-
-namespace kittens {
-/*
-This is meant to be used with a `using group_N = kittens::group<NUM_WORKERS>;` at the start of every kernel.
-*/
-template<int N_WARPS>
-struct group {
-static constexpr int GROUP_WARPS = N_WARPS; // This alias produces nice parallelism.
-static constexpr int GROUP_THREADS = N_WARPS * kittens::WARP_THREADS; // This alias produces nice parallelism.
-__device__ static inline int laneid() { return threadIdx.x % GROUP_THREADS; }
-__device__ static inline int warpid() { return laneid() / kittens::WARP_THREADS; }
-__device__ static inline int groupid() { return threadIdx.x / GROUP_THREADS; }
-
-#include "memory/memory.cuh"
-};
-
-using warpgroup = group<4>; // special scope commonly used by SM_90 and later.
-
-}
@@ -1,7 +0,0 @@
-/**
- * @file
- * @brief An aggregate header of colaborative group memory movement operations
- */
-
-#include "tile/tile.cuh"
-#include "vec/vec.cuh"
@@ -1,12 +0,0 @@
-/**
- * @file
- * @brief Group (collaborative warp) ops for loading shared tiles from and storing to global memory. 
- */
-template<int axis, bool assume_aligned, ducks::st::all ST, ducks::gl::all GL, ducks::coord::tile COORD=coord<ST>>
-__device__ static inline void store(const GL &dst, const ST &src, const COORD &idx) {
-    kittens::store<axis, assume_aligned, ST, GL, COORD, GROUP_THREADS>(dst, src, idx);
-}
-template<ducks::st::all ST, ducks::gl::all GL, ducks::coord::tile COORD=coord<ST>> // default case
-__device__ static inline void store(const GL &dst, const ST &src, const COORD &idx) {
-    kittens::store<2, false, ST, GL, COORD, GROUP_THREADS>(dst, src, idx);
-}
@@ -1,8 +0,0 @@
-/**
- * @file
- * @brief An aggregate header of group memory operations on tiles.
- */
-
-#include "global_to_shared.cuh"
-
-
@@ -1,9 +0,0 @@
-/**
- * @file
- * @brief Group (collaborative warp) ops for loading shared vectors from and storing to global memory. 
- */
-template<ducks::sv::all SV, ducks::gl::all GL, ducks::coord::vec COORD=coord<SV>> // default case
-__device__ static inline void store(const GL &dst, const SV &src, const COORD &idx) {
-    kittens::store<SV, GL, COORD, GROUP_THREADS>(dst, src, idx);
-}
-
@@ -1,6 +0,0 @@
-/**
- * @file
- * @brief An aggregate header of group memory operations on vectors.
- */
-
-#include "global_to_shared.cuh"
@@ -1,9 +0,0 @@
-/**
- * @file
- * @brief A collection of all of the operations that ThunderKittens defines.
- */
-
-#pragma once
-
-#include "warp/warp.cuh"
-#include "group/group.cuh"
@@ -1,67 +0,0 @@
-/**
- * @file
- * @brief Workgroup-cluster primitives for gfx1250.
- *
- * The HIP compute hierarchy is:
- * **Grid -> Cluster -> Workgroup -> Wave -> Thread**.
- *
- * The on-chip cache hierarchy visible to the shader is two levels:
- * **L1 (per-WGP) -> L2 (chip-wide)**.
- *
- * gfx1250 supports CUDA thread block clusters (known as workgroup clusters)
- * where workgroups dispatched together can share a cluster-wide split barrier
- * and use multicast loads. When multiple workgroups in a cluster request the
- * same line, the fabric coalesces their requests and a single L2 return
- * broadcasts to up to 5 workgroups in one cycle. The multicast loads
- * force-miss the L1, so plan locality assuming no L1 hit on those lines.
- *
- * The runtime side (HIP launch API) is still landing; in the meantime
- * this header provides the **device-side** primitives that take a `M0`
- * multicast mask and route through the same async-load builtins. Outside a
- * cluster (`workgroup_mask == 0`) the multicast-aware load reduces to a
- * non-multicast `cluster_load_async_to_lds_*`, so kernels can be authored
- * once and run in either mode.
- */
-
-#pragma once
-
-
-#include "../../../common/common.cuh"
-#include "../sync/barrier.cuh"
-
-namespace kittens {
-namespace cluster {
-
-/**
- * @brief Build the `M0` mask for a cluster multicast load.
- *
- * @param wg_bits        16-bit mask, bit `i` set ⇒ deliver result to WG `i` of the cluster.
- * @param early_timeout  If true, set bit 16 -- the load returns to whichever waves
- *                       have already joined as soon as the L2 returns; late joiners
- *                       issue a follow-up transaction. Useful when a few stragglers
- *                       would otherwise stall fast workgroups.
- *
- * @return The `M0` value to pass as the `cluster_mask` argument of
- *         `kittens::load_async`/`kittens::load_tdm`.
- */
-__device__ __host__ __forceinline__ constexpr uint32_t mask(
-    uint16_t wg_bits,
-    bool early_timeout = false)
-{
-    return static_cast<uint32_t>(wg_bits) | (static_cast<uint32_t>(early_timeout) << 16);
-}
-
-/**
- * @brief Cluster-wide split barrier.
- *
- * Outside a cluster this lowers to a workgroup-wide `sync::sync()`. Inside
- * a cluster the same `s_barrier_signal -1 / s_barrier_wait -1` pair extends to
- * every workgroup in the cluster by hardware-managed forwarding.
- */
-__device__ __forceinline__ void sync() {
-    ::kittens::sync::sync();
-}
-
-} // namespace cluster
-} // namespace kittens
-
@@ -1,10 +0,0 @@
-/**
- * @file
- * @brief An aggregate header of warp memory operations, where a single warp loads or stores data on its own.
- */
-
-#pragma once
-
-#include "util/util.cuh"
-#include "tile/tile.cuh"
-#include "vec/vec.cuh"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
George HotzandGitHub	eee8d261e3	Merge branch 'master' into remove_define_var	2026-06-17 17:50:53 -07:00
George HotzandGitHub	f1a0643b15	Merge branch 'master' into remove_define_var	2026-06-17 16:40:59 -07:00
George HotzandGitHub	b8c70eb3e9	Merge branch 'master' into remove_define_var	2026-06-17 15:58:57 -07:00
geohot	0c3fdda48b	work	2026-06-17 11:29:59 -07:00
geohot	28bd22db0b	passing?	2026-06-17 11:03:30 -07:00
geohot	1c7cc0a379	do things pass	2026-06-17 09:30:37 -07:00
geohot	123585b93c	passing	2026-06-17 09:07:19 -07:00
geohot	27fe5e23a8	remove DEFINE_VAR	2026-06-17 08:51:11 -07:00