Beyond Zero and One: Could Computing Become Ternary or Quaternary?

From Binary Logic to Multi-Valued Computing

Since the earliest days of digital computing, most computers have been built around an idea that appears remarkably simple: everything can be represented using only two states.

0
1

Text becomes numbers, images become matrices of values, and programs become machine instructions. In the end, all of them are reduced to long sequences of bits.

This raises an important question:

Why should we limit ourselves to two states? Why not use three or four electrical states in every signal, allowing each signal to carry more information and potentially producing faster, denser computers?

This idea is neither science fiction nor entirely new. It has been tested historically, some forms of it are already used in modern memory and communication systems, and it remains an active area of semiconductor and unconventional-computing research.

However, moving from zero and one to three or four states is far more difficult than it may initially appear.

A Bit Is Not Literally an Electrical Flash

It is commonly said that zero means the absence of electricity and one means its presence. This explanation is useful as a simplification, but it is not completely accurate.

In modern digital circuits, logical values are represented by voltage ranges.

A simplified system might interpret them as:

Low voltage  → 0
High voltage → 1

Zero does not necessarily mean exactly zero volts, and one does not correspond to only one precise voltage. What matters is that the circuit can reliably distinguish the low-voltage range from the high-voltage range.

A region is usually left between them in which the signal is considered uncertain. This separation allows the circuit to tolerate:

• Electrical noise.

• Temperature changes.

• Manufacturing variations.

• Voltage drops.

• Interference between wires.

The strength of binary computing therefore does not come merely from having two states. It comes from the large electrical separation between those states, which makes them fast and reliable to distinguish.

What Happens If We Add a Third State?

The voltage range could theoretically be divided into three levels:

Low    → 0
Medium → 1
High   → 2

The unit of information in a ternary system is called a trit rather than a bit.

Another possibility is balanced ternary, which uses:

-1
 0
+1

Balanced ternary has several attractive mathematical properties, especially for representing positive and negative numbers and performing certain arithmetic operations.

A quaternary system could use four states:

0
1
2
3

Those four states could also represent two binary bits:

00
01
10
11

The immediate advantage is clear: a binary signal carries one bit, whereas a four-state signal can carry two bits.

A ternary digit carries approximately:

log₂(3) ≈ 1.585 bits

This means fewer digits may be required to represent the same numerical value.

Why Is Multi-Valued Computing Attractive?

From a programmer’s perspective, the idea appears promising for several reasons.

Higher Information Density

If every wire can represent more than two values, fewer wires and logical elements may be needed to represent some forms of data.

For example, a value with 16 possible states requires:

4 bits

in binary, but only:

2 digits

in a quaternary system.

Shorter Registers

Numbers could theoretically be represented with fewer digits, potentially reducing the length of some internal processor paths.

Reduced Data Movement

If every signal carries more than one bit, a bus may transfer more information without requiring a proportional increase in the number of wires.

Better Suitability for Certain Algorithms

Some algorithms and mathematical operations may map more naturally to ternary or multi-valued logic, especially in probabilistic computing, neural processing, and approximate computation.

However, greater information density does not automatically mean greater speed.

The Fundamental Problem: Distance Between States

Suppose a circuit operates across a voltage range from zero to one volt.

In a binary system, each state can occupy a wide region:

0.0–0.3 V → 0
0.7–1.0 V → 1

A large safety margin remains between the two ranges.

In a quaternary system, the same voltage range must be divided into four narrower regions:

Level 0
Level 1
Level 2
Level 3

The closer these levels become, the more difficult it is to determine the correct value quickly and reliably.

A signal intended to represent one level may be mistaken for a neighboring level because of:

• Minor electrical noise.

• Current leakage.

• Higher temperatures.

• Small variations between transistors.

• Cell wear.

• Signal degradation during transmission.

The circuit may therefore require more precise sensing, longer reading times, and additional error-correction mechanisms.

The benefit gained from increasing the number of states may then disappear.

Why Is the Transistor So Well Suited to Binary Logic?

In its simplest interpretation, a transistor behaves like a switch:

Off
On

This maps naturally to:

0
1

Operating a transistor in a stable intermediate state makes it less like an ideal switch and more like an analog component.

In that region, it may consume more power, become more sensitive to variation, and be harder to reproduce consistently across billions of devices.

Binary logic did not dominate because it is necessarily the most mathematically elegant system. It dominated because it fits the physical behavior of CMOS transistors exceptionally well.

The Soviet Ternary Computer Setun

The best-known historical experiment in ternary computing was the Setun computer, developed at Moscow State University in the late 1950s.

Setun used balanced ternary:

-1
0
+1

It was not merely a theoretical model. It was a functioning computer used in several educational and research institutions.

Balanced ternary offered several interesting advantages:

• Natural representation of positive and negative numbers.

• Simpler implementation of certain arithmetic operations.

• Support for three-way conditional logic.

• Greater information density than binary digits.

However, Setun did not become a worldwide standard.

The reason was not necessarily that the idea failed technically. The global computer industry had already begun constructing a vast ecosystem around binary computing:

• Electronic components.

• Memory systems.

• Programming languages.

• Compilers.

• Operating systems.

• Design tools.

• Communication protocols.

• Semiconductor manufacturing processes.

Ternary computing did not merely have to outperform one machine. It had to compete against an entire industrial ecosystem that was expanding rapidly.

Multi-Level Computing Already Exists

It may appear that the world chose zero and one permanently, but the reality is more complex.

Modern systems already use multiple electrical states in several important areas.

NAND Flash Memory

Not every SSD memory cell stores only one bit.

Different NAND technologies store different amounts of information:

SLC → One bit per cell
MLC → Two bits per cell
TLC → Three bits per cell
QLC → Four bits per cell

For a QLC cell to store four bits, it must distinguish between:

16 different electrical levels

Modern technology is therefore already capable of operating with far more than two states.

But there is a clear price:

• Writes become slower.

• Reads become more complicated.

• Endurance decreases.

• Sensitivity to errors increases.

• More sophisticated error correction is required.

This provides an excellent illustration of the central rule:

Increasing the number of states raises information density, but reduces the safety margin between those states.

PAM4 Signaling

High-speed communication systems use PAM4, or four-level pulse-amplitude modulation, instead of only two signal levels.

Each symbol can therefore carry two bits:

00
01
10
11

This increases the data-transfer rate without requiring the signal frequency itself to double.

However, the receiver needs more precise circuitry to distinguish the four levels, and the communication channel becomes more sensitive to noise and distortion.

These systems therefore depend on:

• Advanced signal processing.

• Precise calibration.

• Channel equalization.

• Error correction.

• More complicated transmitters and receivers.

Multi-level signaling succeeded in communication systems because the increased transfer density justifies the added complexity. That does not automatically mean that a four-state CPU would be superior.

Why Do We Not Use Four States Inside the Processor?

The question seems reasonable: if memory and communication systems can use multiple levels, why not use them inside arithmetic logic units, registers, and processor cores?

The answer is that processors have very different requirements.

A processor must perform billions of switching operations every second across billions of transistors while maintaining:

• Extremely low latency.

• Limited power consumption.

• An almost negligible error rate.

• Stability across different temperatures.

• High manufacturing yield.

• Consistent behavior across all logic gates.

Memory may tolerate additional sensing time and error-correction mechanisms when reading a cell. A logic gate inside a processor pipeline cannot pause during every cycle to verify the exact signal level.

Binary logic therefore remains better suited to fast, general-purpose computation, while multi-level states are used where storage or transmission density matters more than minimum latency.

Could a Ternary Processor Be Faster?

A ternary processor could theoretically be more efficient for certain operations, but there is no general rule saying that it would always be faster.

The number of digits and wires may decrease, but at the same time:

• Logic gates may become slower.

• Power consumption may increase.

• Noise tolerance may decrease.

• Manufacturing may become more expensive.

• Memory and registers may become more complex.

• Design verification may become harder.

If one signal carries twice as much information but requires twice as long to distinguish reliably, no real performance improvement has been achieved.

Overall speed depends on the complete system, not merely on the number of values that one wire can represent.

The Effect on Software

Moving to a true ternary computer would involve far more than changing the size of the int type.

System programmers would need to reconsider many fundamental concepts.

New Data Types

A trit could replace the bit as the fundamental unit, and machine words could be composed of ternary digits.

Different Logical Operations

Binary computing commonly uses:

AND
OR
XOR
NOT

Ternary logic may require several possible definitions for these operations, depending on what the third state means.

Does it represent:

• An unknown value?

• A neutral value?

• An intermediate value?

• An unavailable state?

• A positive value in a balanced representation?

Each interpretation produces a different logical system.

A New Instruction-Set Architecture

A ternary ISA would require instructions designed for ternary arithmetic and logic. It would not simply be an x86 processor with one additional state.

Different Compilers

A compiler would need to support:

• Ternary data types.

• Ternary-specific optimizations.

• Ternary register allocation.

• New performance-cost models.

• Different rules for logical operations.

• A new ABI.

A Complete Operating-System Ecosystem

The transition would affect:

• Memory management.

• Executable-file formats.

• Pointers.

• Alignment.

• System calls.

• Interrupts.

• Storage.

• Communication protocols.

Ternary computing is therefore not merely a hardware modification. It would require an entirely new hardware and software ecosystem.

Does Quantum Computing Use More Than Two States?

Quantum computing is fundamentally different from classical multi-valued logic.

A qubit has two basis states:

|0⟩
|1⟩

Before measurement, however, it can exist in a quantum superposition of those states.

This does not mean that it uses a third electrical voltage between zero and one. It represents a physical and mathematical quantum state governed by the laws of quantum mechanics.

Multi-level quantum units also exist:

Qutrit  → Three basis states
Ququart → Four basis states

These are not ordinary ternary transistors, nor are they a direct extension of classical ternary computers.

Quantum computing deals with:

• Superposition.

• Entanglement.

• Quantum phase.

• Probabilistic measurement.

• Quantum error correction.

Classical multi-valued computing, by contrast, uses stable electrical levels that can be measured directly.

Where Is Current Research Focused?

There is genuine ongoing research into ternary and multi-valued logic using technologies such as:

• Carbon nanotubes.

• Two-dimensional semiconductor materials.

• Memristors.

• Spintronics.

• Nanoscale devices.

• Multi-threshold transistors.

• In-memory computing.

• Neuromorphic circuits.

Researchers have successfully created:

• Ternary logic gates.

• Ternary memory cells.

• Circuits capable of switching between binary and ternary logic.

• Small accelerators using multiple states.

• Neural networks based on ternary representations.

However, successfully constructing one experimental gate or memory cell is very different from building a general-purpose processor containing billions of reliable gates that can operate for years.

The major challenges are:

• Maintaining stable levels.

• Achieving consistent manufacturing.

• Reducing power consumption.

• Operating at high frequencies.

• Tolerating electrical noise.

• Scaling to billions of devices.

• Integrating with existing fabrication processes.

Where Might It Appear First?

Multi-valued computing is unlikely to begin by replacing complete x86-64 or ARM processors.

It is more likely to appear first in specialized units such as:

• Artificial-intelligence accelerators.

• In-memory computing systems.

• Signal-processing units.

• Computer-vision accelerators.

• Smart sensors.

• Neuromorphic systems.

• Probabilistic-computing units.

• Compression and encoding engines.

• High-speed communication interfaces.

In these applications, the system can be designed around a limited set of operations, making multi-level states easier to control than they would be in a general-purpose processor.

Will Binary Computing Ever Disappear?

It is unlikely to disappear in the near future.

Binary computing has advantages that are exceptionally difficult to overcome:

• Simple circuits.

• Strong resistance to noise.

• High speed.

• Relatively low power consumption.

• Mature manufacturing processes.

• Advanced design tools.

• A global software ecosystem.

• Decades of accumulated optimization.

However, the future may not remain purely binary.

A future computing system might combine:

• Binary logic for control and general-purpose computation.

• Multi-level memory for storage.

• PAM4 or higher-level signaling for communication.

• Analog units for approximate computation.

• Ternary accelerators for artificial intelligence.

• Quantum units for specialized problems.

Rather than one model defeating all others, several computational models may cooperate within the same system.

Conclusion

Ternary and quaternary computing are neither impossible nor merely abandoned Soviet ideas.

A real ternary computer was built and used. Modern memory cells distinguish among many electrical levels. Communication systems transmit data through four-state signaling. Research into multi-valued transistors and logic gates continues.

The main challenge is not discovering a state between zero and one. The challenge is making multiple states:

• Fast.

• Stable.

• Energy-efficient.

• Resistant to noise.

• Inexpensive to manufacture.

• Repeatable across billions of devices.

For computer programmers, the most important lesson is that binary computing is not a natural law imposed by the universe. It is an extraordinarily successful engineering choice.

A future system may distribute its workloads across binary processors, ternary units, multi-level memories, and quantum accelerators.

At that point, the question will no longer be:

Is the computer binary or ternary?

Instead, it will be:

Which form of representation is best suited to each type of computation?