Dispatch · ISA
ISA as a Wire
A historical exploration of how operations from other instruction sets might map onto Tomato’s configurable datapath—not a compatibility claim.
“We support sixty-six ISAs” was an unsupported headline. Tomato does not run foreign binaries. The profile collection records exploratory mappings between external mnemonics or operations and Tomato datapath capabilities.
The number was always a footnote. The mechanism is the story.
No interpreter. The opcode hits the muxes.
For Tomato instructions, the 9-bit opcode indexes control signals for ALU planes, immediate shape, write-back source, byte lane, and PC overlay. That direct Tomato decode says nothing about foreign instruction encoding or compatibility.
A profile asks a narrower research question: which named operations resemble paths Tomato already has, and which are blocked? Answering that question does not implement a foreign decoder, ABI, memory model, system behavior, or end-to-end binary execution.
The overlay word
The 32-bit instruction is tight on purpose. Low bits are not wasted on a fourth register they cannot hold. They overlay, depending on the mnemonic, as COND, jump mode, or an immediate fragment. Same slices of copper. Different assembly spellings. That is how a branch condition, a jump flavor, and a short literal can share a field without a pre-decode shifter sitting in front of the IR.
The 32-bit wordLow bits overlay as COND, jump mode, or immediate
The immediate box
Sixteen Tomato immediate selections are decoded on the register board: imm8, imm12, imm13, imm16, LUI, and related forms. Profiles compare those forms with literal operations described by other ISAs; matching a width does not make an external encoding native.
The dual-LUT
The custom three-source ALU resolves f(a,b,c) + g(a,b,c) + cin. Tomato instructions can select LUT truth tables for operations in that family. A mathematical match to an operation named by another ISA is useful exploration data, but it does not execute that ISA’s encoded instruction.
An ISA is no longer a rigid contract. It is a parametric mapping from an external binary onto the physical copper.
About thirty-seven, casually
The spreadsheet contains profile rows for many named architectures and extensions. Counting those files measures the breadth of the exploration database only. It does not count supported ISAs.
The profiles can identify reusable Tomato operations and gaps worth studying. They remain unclaimed until an actual implementation and end-to-end verification establish a specific scope.
| What it is not | What it is |
|---|---|
| Tomato runs 66 ISAs | The datapath is parameterized by the instruction word |
| It has an x86 mode | Profiles compare some x86 operations with Tomato paths |
| Foreign binaries decode as Tomato controls | Only Tomato’s own burned opcodes drive the implemented controls |
| Profile count is ISA support | Profile count is exploration-dataset coverage |
The honest edge
Tomato currently claims neither foreign binary compatibility nor native execution of another ISA. Similar ALU, shift, immediate, or load/store operations are datapath comparisons, not a substitute for decoding and verifying the full architecture.
docs/isa/profiles.csv indexes the exploration data. The burned Tomato ISA and ROM tables govern implemented instruction encoding; FPGA RTL governs FPGA behavior; physical/KiCad evidence governs the discrete boards. This dated page records why the profiles were explored.
From the build
The work behind the words.
The modular control design documented in the build journal.
Tetris in Tomato OS, written for the custom instruction set.