KohakuBlueleaf_KohakuTPU/docs/projects/kohakutpu/tinygrad.md

---
title: The tinygrad frontend
summary: tinygrad as an optional tensor frontend that dispatches into the same kernel library — where the seam is, what is switched off, and the ops where this path is worse than calling the library.
tags:
  - kohakutpu
  - compiler
  - software
---

# Tinygrad as the tensor frontend

> **Kind: Yours throughout.** An optional tensor frontend, where its seam falls
> and what it switches off are this project's software choices. The framework has
> no frontend and no opinion about one.

`ktpugrad` makes `Tensor(x, device="KTPU")` work by matching tinygrad's lowered
loop nest against this project's kernel library and dispatching the library
kernel. It is **an optional frontend, not a replacement for L5** — the reason is
§3.

## 1. The seam

On tinygrad 0.13 the ast is already a lowered loop nest by the time a backend
sees it: `Ops.PARAM` / `INDEX` / `RANGE` / `REDUCE` / `RECIPROCAL`, with no
ShapeTracker and strides as affine coefficients. There is no `Tensor.schedule`
and no `realize.get_runner`; **the ast exists only where `to_program` is called**,
which is therefore the seam. `ktpugrad.capture()` records asts through the
installed seam rather than rebuilding one, and `_PATTERNS` is captured at import:
rebuilding the pattern matcher from an already-rebound matcher re-snapshots a
stale dict and the seam silently stops firing.

`ktpugrad` touches nothing outside its own directory. The device takes its
machine from `kohakutpu.api.device()`, so the whole path is gradeable without a
card.

## 2. What is switched off, and why

On the `Renderer`:

| flag | set to | why |
|---|---|---|
| `has_local` | `False` | there is no thread and no `program_id`; a unit is programmed, not commanded |
| `has_shared` | `False` | no inter-unit barrier inside a kernel, so no shared scratch to put behind one |
| `shared_max` | `0` | follows |
| `local_max` | `(1,1,1)` | one program per unit |
| `tensor_cores` | `[]` | WMMA is a warp of threads cooperating on a fragment; our GEMM is a whole-tile instruction with `gm/gn/nk` as fields, not a warp op |
| `supports_float4` | `False` | vector width is a codegen concern; our fills are entry-granular, 4 lanes x 32 K |

By environment:

- **`NOOPT=1`** — skips `apply_tensor_cores` and `hand_coded_optimizations`, i.e.
  every `OptOps`: `UPCAST`, `UNROLL`, `LOCAL`, `GROUP`, `GROUPTOP`, `NOLOCALS`,
  `PADTO`, `SWAP`. All are loop transforms over generated code. **We generate no
  loops** — the equivalent decision here is `gm`/`gn`/`nk`, which `Compiled.compile`
  already chooses per shape.
- **`BEAM=0`** — beam search times candidate kernels by RUNNING them. Over JTAG at
  100 MHz that is not a search, it is a hang.

## 3. Where the mapping fails

1. **Our multi-stage fused kernels lose.** `softmax` is FOUR tinygrad kernels and
   ONE of ours; `rmsnorm`, `layernorm`, `group_norm_silu` and `flash_attention`
   are the same shape of loss. The scheduler has already cut them apart before we
   see them, so matching them back means re-fusing across kernel boundaries —
   which is a scheduler of our own, i.e. the thing adopting tinygrad was meant to
   avoid. **Adopting it wholesale would make attention and the norms slower than
   the library we already ship.**
2. **Reduces map only along a row.** `REDUCE_AXIS` over the LAST axis is
   `row_sum`/`row_max`. Any other axis has no mapping; the vector core reduces
   ALONG a row and nothing transposes.
3. **dtype.** tinygrad defaults to float32; this machine is fp16 in, MXFP7
   operands, FP22 accumulator. The frontend is pinned to `dtypes.float16`, and
   the accumulator's extra range is invisible to tinygrad's cost model. The
   product itself must be fp16 to match: an fp32 matmul over fp16 buffers has its
   casts exactly where the accumulator's are, so a matcher that only unwraps
   casts will match it and dispatch the wrong kernel.
4. **`Tensor.rand` costs 7 threefry kernels** of pure elementwise integer work.
   None of it maps; use `Tensor(numpy_array)`.

A fused elementwise chain was on this list and came off it: `x*2+1` is one
tinygrad kernel and two library entries, but `lang/vector.py` already turns an
expression tree into a vector chain, so the job was UOp-tree → L4 chain at the
level built for it — a translation rather than new machinery.

## 4. What generates

Matmul, epilogues, elementwise chains, and — via the chain generator — softmax
and the norms. Two readings carry more weight than their size suggests:

- **`rsqrt`, not `sqrt`, is what unlocked the norms.** tinygrad spells
  `rsqrt(z)` as `RECIP(SQRT(z))`, read as the PAIR onto `OpKind.RSQRT`, which
  lowers to a correct `VRSQRT`. Nothing maps `OpKind.SQRT`, so a bare `x.sqrt()`
  still refuses.
- **min and max arrive as selects.** `WHERE(CMPLT(a, b), b, a)` is `max(a, b)`
  and `WHERE(CMPLT(a, b), a, b)` is `min(a, b)`; `x.clip(lo, hi)` is two of them
  nested. Those are the only two select shapes read as arithmetic, because every
  other one is a real predicate.

## 5. The ceiling, and it is the one that matters for a DiT

**A row must be a multiple of 16 and at most VLMAX = 128.** So a DiT's attention
softmax at L=1024 REFUSES, and so does a layernorm over a 1024-wide model
dimension. This is pre-existing — `RowReduceKernel` carries the identical check —
but it means "softmax and the norms generate" is true at 64-wide rows and **false
at DiT rows**.

**And the escape hatch does not lift it.** Measured at 256 and 1024:
`ktpugrad.softmax`, `K.softmax`, `K.layernorm`, `K.rmsnorm`, `K.group_norm` and
`K.row_sum` all raise the same refusal, so the message names that rather than
sending the reader to a door that is also shut. The hierarchical form exists only
as `kernels.groupnorm.group_stats` — verified past 128, unexported, and wired
into no row-wise kernel.

`scaled_dot_product_attention` still needs the hatch: its score is a batched
contraction the matcher declines, and a rank-3 reduce is refused rather than
guessed at — reading `[2][32][64]` as rows=2 would be the wrong row count, so the
refusal is at rank and does not lean on a downstream span check.

Also refused, each by name: a fold down a column, a fold over two axes, a `MUL`
reduce, and a row where `VRED` cannot fold.

## 6. The shape of the answer

> tinygrad as an OPTIONAL frontend that dispatches into the same kernel library,
> with our own multi-stage kernels kept and reachable, and a documented list of
> the ops where the tinygrad path is slower than calling the library directly.

The refusals are asserted as tightly as the matches. A matcher that quietly
widened would dispatch a wrong kernel and report success — which is why every
refusal above is a test, and why the escape hatch is held to the same line: a
refused ast still raises rather than falling through to something that computes
a different thing.