3D integration & chiplets

known-good die (KGD)

A known-good die is a bare chip that has already been tested and proven to work before anyone solders it into a package or bonds it next to other chips. The name says it plainly: you have evidence this particular die is good, not just a hope. Normally a chip gets its real workout only after packaging, but the moment you start gluing several dies together into one product, that order turns dangerous — so you push the testing earlier, onto the loose die itself.

Here is why such a small idea rescues big designs. Defects fall on a wafer roughly at random, so the bigger a die is, the likelier it is to swallow at least one killer flaw — yield drops fast as area grows. A huge monolithic chip is one all-or-nothing lottery ticket: a single bad spot anywhere throws away the whole expensive die. If instead you disaggregate that design into several small chiplets, you can test each tiny die on its own, keep only the known-good ones, and assemble a package entirely from winners. The bad dies get tossed while they are still cheap — before you have spent money bonding them to good neighbours.

That is the quiet engine under the chiplet movement. Splitting a design only pays off if you can trust the pieces, and KGD testing is what makes the pieces trustworthy — it turns 'mix and match small dies' from a yield gamble into a yield strategy. The catch is that testing a bare, unpackaged die is genuinely hard: you must make reliable temporary contact with tiny pads and run meaningful tests without the protection and easy probing a finished package would give you, which is one reason fine-pitch, TSV-stacked memory like HBM leans so heavily on careful die-level test.

monolithic big die          4 small chiplets (test each, keep good)
+-----------------+         [die1 ok][die2 ok][die3 X][die4 ok]
|        X        |   -->        |       |    toss      |
|  one defect  =  |              keep the 3 known-good, swap
|  whole die lost |              in another good die -> good package
+-----------------+

One defect dooms a whole monolithic die; testing chiplets first lets you discard only the bad small die and build the package from known-good ones.

KGD is never a perfect guarantee — die-level tests can't reproduce every condition a packaged part sees, so a few escapes still surface only after assembly; the goal is to shrink that fraction enough that disaggregation stays a net win.

Also called
KGDknown good die