Every wide adder you've seen so far — ripple, carry-lookahead, Kogge-Stone — has one fundamental limit: the carry has to propagate. Even Kogge-Stone, the fastest parallel-prefix adder, takes log₂(N) gate levels to resolve a 32-bit sum. But what if you're not required to produce the final sum right now? What if you just need to reduce a pile of numbers as fast as possible? That's when you reach for a Carry-Save Adder (CSA).

The trick: a CSA takes three N-bit inputs and produces two N-bit outputs — a "sum" vector and a "carry" vector — such that when those two are eventually added together, you get the true sum of the three inputs. It's just a row of N full adders in parallel, with no horizontal connections. Each bit position independently computes its sum bit and carry-out. There is no carry propagation. The delay is exactly one full-adder delay, regardless of whether N is 8, 64, or 512.

• Sum bit: S[i] = A[i] ⊕ B[i] ⊕ C[i]
• Carry bit: Cout[i] = majority(A[i], B[i], C[i]) — but shifted left by one when consumed

You've traded one number for two. That sounds like a loss, but it's the setup for a beautiful cascade. Chain CSAs together — each stage takes three vectors and outputs two — and you can reduce a stack of K numbers down to just two in log₁.₅(K) stages. Then, and only then, do you pay for one real carry-propagate adder (CPA) at the end to collapse those final two vectors into the answer.

Real-world example: This is exactly how a Wallace tree multiplier reduces 32 partial products in a 32×32 multiplier. Instead of 31 sequential additions (each with log-N delay), you get roughly log₁.₅(32) ≈ 8 CSA stages plus one final CPA. It's also how multiply-accumulate (MAC) units in every DSP, GPU tensor core, and AI accelerator work: the accumulator is kept in carry-save form across many cycles, and the CPA only runs when you actually need to read out the result. Google's TPU MAC arrays live in carry-save form for their entire dot-product operation.

Rule of thumb: Reducing K operands to 2 with CSAs takes about K − 2 full-adder rows worth of hardware and ⌈log₁.₅(K/2)⌉ stages of full-adder delay. A CPA at the end costs one additional log-N delay. If you're adding fewer than 4 numbers, don't bother — just use two CPAs. Above 4, CSA reduction wins on both speed and area.

The philosophical shift is important: a CSA doesn't solve addition — it defers it. You keep the number in a redundant representation (sum + carry) for as long as possible, then pay the carry-propagation tax exactly once at the end.