Project Details

This One Goes up to Three

In the world of computing, we’ve long accepted that two is enough. Binary - that austere system of 0s and 1s - powers every modern computer, smartphone, and smart toaster. It’s simple, reliable, and has been refined over decades into an industrial juggernaut. But what if I told you that two isn’t always the best number? What if there was a way to represent more information with the same number of digits, to make negation trivial, to sidestep the need for a separate sign bit?

That’s where ternary comes in. Base-3 computing.

And no, this isn’t just theoretical. I actually built one.

Not in hardware (yet), but in Python: a complete, runnable ternary computer simulator that executes programs written in a custom ternary assembly language. It uses balanced ternary - trits valued at −1, 0, and +1 as opposed to unbalanced ternary which has trits valued at 2, 1 and 0 - and runs demos ranging from a simple counter to a cellular automaton to a single-layer perceptron classifier. The whole thing is open source for educational purposes on GitHub: https://github.com/brandonssmith/ternary.

The title of this article is a nod to This Is Spinal Tap, where the band proudly shows off an amplifier whose knobs go up to eleven - “one louder” than the usual ten. Binary computing goes up to two (yes, I know it's actually 0, 1, but going up to 2 doesn't sound as good, nor as accurate). Ternary computing goes up to three. And in some ways, that extra state really does make things louder, richer, and occasionally more elegant.

Why Bother with Ternary?

Most people encounter ternary only in passing: as a mathematical curiosity, or perhaps in the context of old Soviet computers like the Setun (1958–1970), one of the few real-world ternary machines ever built at scale. The Setun and its successor, Setun-70, demonstrated that ternary could be more efficient than binary in terms of component count and power consumption -  but binary won the war of attrition anyway. Transistors got cheaper, binary circuits got simpler, and the ecosystem locked in.

Yet the idea never quite died. Every few years someone rediscovers balanced ternary and realizes it has properties that binary lacks:

• No separate sign bit: −1 is simply the additive inverse of +1. Negating a number is just flipping every non-zero trit from + to − and vice versa - no carry propagation needed.
• Compact representation: With three states instead of two, you can represent more values in the same number of digits. A 9-trit word in balanced ternary covers roughly the same range as a 14-bit binary word (19,683 vs. 16,384 unsigned), but with built-in signedness.
• Natural three-way comparison: The most-significant trit alone tells you if a number is negative, zero, or positive -  no need to compare against zero first.
• Potential for more efficient logic: Some operations, like multiplication by 3 or division by 3, are trivial shifts in ternary, just as ×2 is a shift in binary.

Of course, there are downsides. Ternary logic is more complex to implement in hardware (three voltage levels instead of two), and the entire software ecosystem is built around binary. So why build a simulator in 2025?

Because it’s fun. Because it may now have actual applications in AI due to tokenization. Because it forces you to rethink basic assumptions. Because it’s a chance to play with an alternate reality where computers didn’t settle on two states. And because sometimes the best way to appreciate binary is to see what happens when you throw an extra state into the mix.

What This Simulator Does

The project is a from-scratch Python implementation of a simple ternary CPU emulator. It features:

• Balanced ternary with 9-trit words (range ≈ −9,841 to +9,841)
• A full set of ternary logic gates (NOT, AND, OR, XOR, NAND, NOR)
• A ripple-carry ternary adder/subtractor in the ALU
• 243 words of RAM and a handful of registers
• A minimal RISC-like instruction set (LOAD, STORE, ADD, SUB, JMP, JZ, HALT, etc.)
• A command-line interface for loading, stepping, and debugging programs
• Several working demos, including:
  • A ternary counter with decimal conversion
  • Conway’s Game of Life on a 9×9 grid with ternary cell states
  • A single-layer perceptron classifier
  • A tiny Mandelbrot set explorer (low-res ASCII art)

All of it runs in pure Python - no external libraries required.

This one goes up to three.