Tyrone Marhguy

I build computers
from first principles.

Computer Engineering junior at the University of Pennsylvania. I design processors, build the hardware, and write the software that runs on them. My independent 32-bit computer is Tomato.

Engineering work & roles: Aragorn AI, Inc. · Vero Electric.

From Ghana to Penn: my storyWikipedia

Philadelphia, PA

Tyrone Marhguy
01 / The independent buildArchitecture / boards / software

Meet Tomato.
A computer of my own.

It started with a question: could I build a computer from individual transistors? That became an ALU, a rethink, and a 32-bit architecture. Today, my FPGA implementation boots TomatoOS and runs games over HDMI. I’m building the discrete machine board by board.

Running / FPGA My CPU. My assembler. TomatoOS on the screen. The demo auto-plays — desktop and games.
On the bench / Discrete hardware The ALU board is fabricated and being assembled. The complete discrete CPU is in progress.
RISC-V RV32I · instructionsTomato · ALU evaluations
Operation counts: ties, a RISC-V advantage, and compound-work advantages for Tomato.Vertical axis starts at zero. Each expression has one point per architecture. Ten examples compare RV32I instruction counts with Tomato ALU evaluations. Complete sequences are documented on the Tomato site.Operation count · lower is fewer01234567811223456681211111222AddSignedless-thanMask+ addMask− subtractChooseMajorityXOR3+ AND3TwoselectionsVote, mask+ addTwo-stagevote

Expressions run left to right. Lines connect discrete examples; this is not a scaling or timing curve.

See all ten expressions and their instruction sequences
The idea inside the machine

Change the logic.
Keep the datapath.

Two programmable truth tables feed one adder. An instruction can combine Boolean logic and arithmetic instead of sending the result back for another operation.

f(A, B, C) + g(A, B, C) + carry

524,288 control configurations = 256 × 256 truth-table pairs × 8 carry selections. Multiple settings can implement the same function; the instruction ROM selects a practical subset.

Try the full 32-bit playground

A + (B & C)

Base RV32I2 instructions
AND t0, B, C
ADD out, A, t0
Tomato Dual-LUT1 ALU evaluation
F = A · G = B & C
out = F + G

The mask feeds the adder directly. Both operations share one trip through the ALU.

Illustrative instruction sequences versus ALU evaluations, with operands already available. These counts do not measure CPU cycles or whole-program speed; ISA extensions and implementation choices can change the comparison.

Full comparison & methodology
An intentionally outsized register file

Half a Blackwell SM’s
register capacity.

The discrete register-file design addresses 32,768 × 32-bit locations: 128 KiB of logical storage, with 256 registers visible per instruction window.

Tomato design128 KiB
One Blackwell SM256 KiB

Capacity comparison only. Tomato uses banked, mirrored SRAM; a GPU SM has different porting, bandwidth, latency, and scheduling. This is a design specification, not a GPU performance claim.

A decision from the build log

I widened the design.
Then went back to 32 bits.

A 40-bit instruction looked clean on paper. It also meant wider fields and more board work. I returned to 32 bits so the design could move forward on the bench.

The journal follows the reasoning: what I tried, what complicated the hardware, and what changed.

Read the architectural rethink
02 / Beyond my own workbench

I also fix the tools I build with.

OpenROAD

A parser fix for technology files with trailing whitespace, so valid LEF58 input can load.

Inspect the patch

Verilator

Using peak resident memory for Linux statistics, so reported memory reflects the process’s physical footprint.

Inspect the patch
More contributions, including OpenFPGA
03 / More from the workbench

Projects

View all
From the bench

Recent writing

View all