# 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.

Group: Memory
URL: https://digiwleea.wleeaf.dev/learn/bit-to-byte/

> **KEY:** You built a [register bit](https://digiwleea.wleeaf.dev/learn/regbit/), a cell that stores one bit, and a [full adder](https://digiwleea.wleeaf.dev/learn/fulladder/), 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](https://digiwleea.wleeaf.dev/learn/register8/) 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](https://digiwleea.wleeaf.dev/learn/register8/) from eight [register bits](https://digiwleea.wleeaf.dev/learn/regbit/): 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](https://digiwleea.wleeaf.dev/learn/fulladder/) 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.

> **WARN:** 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.

**Q (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?

**A:** 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.

### FAQ

**Q:** How do you turn a 1-bit circuit into an 8-bit one?

**A:** 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.

**Q:** What is a bit slice?

**A:** 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.

**Q:** Do all wires connect to every slice when widening a circuit?

**A:** 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.

> **KEY:** This one pattern unlocks the whole byte-wide world. Next, apply it directly: eight register bits become the [8-bit register](https://digiwleea.wleeaf.dev/learn/register8/), and eight full adders become the 8-bit adder.