Widening a 1-bit circuit
The just replicate it pattern
Widening a circuit to a byte means placing eight copies of the 1-bit version side by side, each handling one bit and all sharing the same control lines, the bit-slice replication pattern behind every multi-bit block.
You built a register bit, a cell that stores one bit, and a full adder, a cell that adds one column. Real computers work on whole bytes, so how do you get from a 1-bit cell to an 8-bit register or an 8-bit adder? This bridge gives the answer once, because the same pattern builds nearly every multi-bit block in the course.
The jump looks big: "one bit" to "a whole byte" sounds like an eightfold increase in cleverness. It is not. It is an eightfold increase in *copies*. The insight is almost anticlimactic: place eight copies of the 1-bit circuit side by side, one per bit position, and wire the shared control signals to all of them at once. Each copy, called a bit slice, minds its own bit; together they mind the byte.
What is shared, what is per-bit
The trick is knowing which wires fan out to every slice and which stay local. For an 8-bit register from eight register bits: each slice gets its own data bit
D0..D7 and produces its own stored output Q0..Q7 (per-bit), but the clock and the load line go to all eight in parallel (shared). One load pulse therefore captures all eight bits at the same instant, so the byte updates as a unit. That shared control is what makes eight independent cells behave like one register.The one wrinkle: sometimes slices must talk to their neighbors. Eight full adders become an 8-bit adder not just by sitting side by side but by wiring each slice's carry-out into the next slice's carry-in, forming a chain up the bit positions. Data bits are per-slice, but the carry threads through them in order. So the pattern is: replicate the cell, share the global controls, and chain any signal (like carry) that flows between positions.
A concrete analogy: a row of eight bank tellers. Each teller handles one customer (their bit), but they all follow the same "open" and "close" bell (the shared clock and load). If a task needs passing something down the line (a carry), teller
k hands it to teller k+1. Widen the bank by adding tellers; the procedure per teller never changes.Widening does not mean cross-wiring the *data* bits. Each slice's data stays on its own line; only the control lines are shared and only the intended inter-slice signal (such as carry) chains between neighbors. Accidentally tying data bits together shorts the byte. And a ripple carry through a long chain adds delay, each slice waits for the carry below it, which is exactly the speed problem the carry-lookahead lesson later solves.
Check yourself
To build an 8-bit register from eight 1-bit register cells, which wires go to all eight cells in common, and which are unique to each cell?
Answer
Shared by all eight: the clock and the load/enable line, so one pulse captures the whole byte at once. Unique per cell: each slice's own data input bit (
D0 through D7) and its stored output bit (Q0 through Q7). Replicate the cell, fan the control lines to every copy, keep the data bits separate.Frequently asked
How do you turn a 1-bit circuit into an 8-bit one?
Place eight copies of the 1-bit circuit side by side, one per bit position, and connect the shared control lines (like clock and load) to all of them. Each copy handles its own data bit; any signal that flows between positions, such as a carry, is chained from one copy to the next.
What is a bit slice?
A bit slice is one copy of a 1-bit circuit handling a single bit position within a wider block. An 8-bit register or adder is eight identical bit slices working in parallel under shared control.
Do all wires connect to every slice when widening a circuit?
No. Only the global control signals (clock, load, function select) fan out to every slice. Data bits stay on their own per-slice lines, and inter-position signals like carry chain from one slice to the next in order.
This one pattern unlocks the whole byte-wide world. Next, apply it directly: eight register bits become the 8-bit register, and eight full adders become the 8-bit adder.
Every lesson here builds toward one thing: a working CPU, from the transistor up.
Open the free lab →