Ripple Carry Adder — Computer Arithmetic -

💡 What is a Ripple Carry Adder?

Imagine you’re adding two big numbers on paper, digit by digit.
You start from the rightmost side (the “ones” place), and if there’s a carry, you pass it to the next column.
The next column then depends on that carry before it can give the final answer.

That’s exactly how a Ripple Carry Adder (RCA) works — but instead of digits, it adds binary bits (0s and 1s).

In short:

A Ripple Carry Adder is a circuit that adds two binary numbers by connecting several Full Adders in a chain, where each adder’s carry “ripples” into the next one.

🧱 The Basic Building Block — The Full Adder

Before we dive into the full Ripple Carry Adder, let’s recall what a Full Adder does.

A Full Adder adds three bits:

Two input bits (say, A and B)
One carry bit from the previous stage (Cin)

It gives two outputs:

Sum (S)
Carry (Cout) — which will be passed to the next adder.

Here’s the logic for one Full Adder:

Inputs	Outputs
A	B	Cin	Sum	Cout
—	—	—	—	—
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
1	0	0	1	0
1	1	0	0	1
1	0	1	0	1
0	1	1	0	1
1	1	1	1	1

From this, the Boolean equations are:

Sum  = A ⊕ B ⊕ Cin  
Cout = (A · B) + (B · Cin) + (A · Cin)

⚙️ How the Ripple Carry Adder Works

Now, let’s say we want to add two 4-bit binary numbers:

A3 A2 A1 A0
B3 B2 B1 B0

Each pair (Ai, Bi) is added by one Full Adder.
We connect four Full Adders in a row — the carry from one adder becomes the input carry for the next.

Here’s how it flows:

Carry in ---> [FA0] ---> [FA1] ---> [FA2] ---> [FA3] ---> Carry out
                 |          |          |          |
               Sum0       Sum1       Sum2       Sum3

Each [FA] is a Full Adder.
The carry signal ripples through them — from right to left — which is why we call it a Ripple Carry Adder.

🔍 Step-by-Step Example

Let’s add two 4-bit numbers:

A = 1101 (13 in decimal)
B = 0111 (7 in decimal)

| Bit Position | A | B | Carry In | Sum | Carry Out |
| ———— | – | – | ——– | — | ——— |
| 0 (LSB) | 1 | 1 | 0 | 0 | 1 |
| 1 | 0 | 1 | 1 | 0 | 1 |
| 2 | 1 | 1 | 1 | 1 | 1 |
| 3 (MSB) | 1 | 0 | 1 | 0 | 1 |

So the result is:
Sum = 0100, Carry Out = 1

Combine them: 10100 (20 in decimal) ✅

🧩 Block Diagram of a 4-bit Ripple Carry Adder

Here’s a simple representation:

         +-------------------+    +-------------------+    +-------------------+    +-------------------+
 A0 ---> |                   |    |                   |    |                   |    |                   |
 B0 ---> |     FULL ADDER    |--->|     FULL ADDER    |--->|     FULL ADDER    |--->|     FULL ADDER    |
Cin ---> |        FA0        |    |        FA1        |    |        FA2        |    |        FA3        |
         |                   |    |                   |    |                   |    |                   |
      S0 |-------------------| S1 |-------------------| S2 |-------------------| S3 |-------------------|
         +-------------------+    +-------------------+    +-------------------+    +-------------------+

👉 Notice how the carry out of each Full Adder connects to the carry in of the next one.
That’s the “ripple” effect in action!

🧠 Why It’s Called “Ripple Carry”

Think of it like a line of people passing a ball:
The first person gets it, then passes it to the next, then the next, and so on.
Each must wait for the previous person before they can act.

Similarly, each adder in the chain must wait for the carry from the previous stage before finishing its own output.
This waiting causes a delay that “ripples” through the circuit — hence the name!

⏱️ The Problem — Carry Propagation Delay

The biggest drawback of the Ripple Carry Adder is speed.
Because every adder depends on the previous one’s carry, the total delay adds up.

If each Full Adder takes, say, t nanoseconds to produce its carry, then a 4-bit adder will take about 4t nanoseconds to finish.
For a 64-bit adder, the delay could be 64t! 😬

This is why faster adders like Carry Look-Ahead Adders were invented — but that’s a topic for another day.

⚖️ Advantages and Disadvantages

Advantages	Disadvantages
Simple and easy to design	Slow due to carry ripple delay
Uses minimal hardware	Not suitable for large bit operations
Great for small circuits	Delay increases linearly with number of bits