What MLC NAND Actually Is

MLC NAND stores two bits per memory cell by placing the cell’s threshold voltage ($V_t$) into one of four distinct windows. Those four states encode the bit pairs 11, 10, 00, and 01 (exact Gray-code mapping varies by vendor and page type).⁠

• SLC: 2 voltage states → 1 bit
• MLC: 4 voltage states → 2 bits
• TLC: 8 voltage states → 3 bits
• QLC: 16 voltage states → 4 bits

Density roughly doubles versus SLC on the same silicon, at the cost of tighter $V_t$​ margins, slower program/erase, stronger ECC requirements, and lower raw endurance. Typical consumer planar MLC was specified around 3,000–10,000 program/erase (P/E) cycles; enterprise-tuned eMLC or FortisFlash parts were specified higher by using slower incremental-step pulse programming (ISPP), tighter screening, and sometimes reduced bits-in-use.⁠

Micron’s official positioning still describes MLC as “a good balance of performance and write endurance for a wide range of cost-sensitive, high-density applications,” with a separate eMLC / FortisFlash line for write-heavier workloads.⁠

Cell Physics and Programming

A NAND cell is a MOSFET with a charge-storage node (historically a floating gate; in modern Micron 3D NAND a charge-trap nitride film). Electrons tunneled onto that node raise $V_t$​. Because MLC uses four states instead of two, each state occupies a narrower voltage window. Programming therefore uses incremental step pulse programming (ISPP) with verify-after-each-pulse so the distribution does not overshoot into the next window.

Key operational constraints that appear in Micron (and IMFT-era) datasheets:

• Pages are the smallest programmable unit; blocks are the smallest erasable unit.
• Partial-page programming (NOP) is typically 1 on MLC versus 4 on SLC.
• Stronger ECC is required (historically 4+ bits per 512 B, later BCH/LDPC at 72 bits per 1 KB or more).
• Program disturb, read disturb, and data-retention tails grow as the process node shrinks and as more bits share the same cell.

Early Micron/Intel IMFT 20 nm 64 Gb MLC used a planar floating-gate cell with high-k inter-gate dielectric, metal control gate, and air-gap isolation to fight cell-to-cell interference. Cell pitch was ~40 nm in both word-line and bit-line directions.⁠

Micron’s first-generation 3D NAND (32-layer class) still used a floating-gate cell; later generations (128L, 176L, 232L and beyond) moved to charge-trap flash (CTF / CTN) with replacement-gate process and CMOS-under-array (CuA). Those later dies are almost exclusively TLC or QLC in volume products.⁠

Array Organization (Typical Micron MLC / Early 3D MLC)

NAND is organized as a hierarchy:

Level	Typical Micron MLC / early 3D MLC numbers	Role
Cell	2 bits, 4 $V_t$​ states	Storage element
Page	8–16 KB + spare	Smallest program unit
Block	128–1024+ pages	Smallest erase unit
Plane	2 or 4 planes per die	Parallelism
Die / LUN	1–16+ dies in a package	Independent CE / command queue

Example from Micron’s early 3D NAND flyer (32-layer class MLC vs TLC):

Parameter	3D MLC	3D TLC (same flyer)
Density example	256 Gb (32 GB)	384 Gb
Page size	16 384 + 2208 B	Same
Pages per block	1024	1536
Blocks × planes	548 × 4	548 × 4
tPROG typ/max	1300 / 2500 µs	1630 / 5000 µs
P/E cycles	3K + read retry	1500 LDPC / 500 BCH
tBERS typ/max	15 / 45 ms	Same

All-bit-line (ABL) architectures replaced older even/odd bit-line schemes so every bit line has its own sense amplifier, raising program throughput. Micron and IMFT adopted ABL on later planar nodes.⁠

Micron’s Product Lineage

Planar era (IMFT partnership with Intel)

• 34 nm → 25 nm → 20 nm → 16 nm MLC.
• Flagship example: 20 nm 64 Gb MLC, ~117 mm² die, planar FG + HKMG.
• 16 nm 128 Gb dual-plane parts appeared in Crucial consumer SSDs (pages 16 KB, 512 pages/block, 1024 blocks/plane).⁠

Early 3D (floating-gate, then CTF)

• 32-layer 3D MLC/TLC marketed as “3× planar capacity.”
• FortisFlash variants advertised higher endurance than commodity MLC without full enterprise usage restrictions.⁠

Modern 3D (CTF + CuA)

• 128L (B37R), 176L (B47R, 195 total gates including selectors/dummies, 2 decks of 88 word lines), 232L (B58R) and later G9 generations.
• Volume SKUs are TLC and QLC. 176L 512 Gb TLC die: ~49.8 mm², ~10.3 Gb/mm². 232L TLC dies reach ~14.6 Gb/mm² class.⁠

Micron still publishes an MLC part catalog and “Choosing the right NAND” guidance that lists MLC as the two-bit option, plus eMLC and FortisFlash. Many catalog lines are marked End of Life or Contact Sales. Industry-wide, planar 2D MLC lines are being shut down; 64 Gb MLC spot prices spiked after capacity cuts. TrendForce estimated a ~42% drop in global MLC capacity in 2026. Micron has limited remaining MLC output to existing customer demand.⁠

Reliability, Endurance, and Controller Compensation

Raw MLC cells wear faster than SLC because each program pulse must land in a narrower window and because oxide damage from Fowler–Nordheim tunneling accumulates. Controllers compensate with:

• Wear leveling and over-provisioning
• Stronger LDPC/BCH ECC and read retry
• SLC or pSLC caching (common on later TLC/QLC SSDs that still use Micron NAND)
• Temperature-aware refresh and data-retention management

eMLC / HET / FortisFlash techniques historically included die screening, slower tPROG, and sometimes operating the physical MLC cell as fewer effective bits to widen margins. Published eMLC numbers in the 10k–30k P/E range were common in the 2x–3x nm generation; they were never equivalent to true SLC (~100k cycles).⁠

Data retention after cycling is shorter than SLC; datasheets typically assume ~1 year at elevated temperature at end of life unless a higher-retention grade is specified.

Where MLC Still Matters in 2026

Use case	Why MLC (or eMLC) can still win	Reality check
Industrial / automotive embedded	Predictable endurance, long design-in life, existing qualification	Supply shrinking; many designs migrating to managed TLC e.MMC/UFS
Write-heavy appliances that cannot afford SLC cost	Better P/E than TLC at mid-density	FortisFlash / remaining catalog parts
Legacy firmware / controllers designed for 2-bit pages	Command set and page geometry match	New designs use TLC with pSLC cache
High-reliability logging	Wider $V_t$​ windows than TLC/QLC	Often replaced by pSLC mode on TLC dies

Mainstream client and data-center SSDs from Micron (3400, 3500, 2600 QLC, 3610 G9 QLC, etc.) use 176L–276L-class TLC or QLC with adaptive SLC/TLC caching rather than native MLC.⁠

Engineering Trade-offs Summary

• Density vs. margin: Two bits per cell is the last generation that still feels “comfortable” for analog $V_t$Vt​ control without massive ECC and folding overhead.
• 3D stacking vs. bits per cell: Micron (and peers) found it cheaper to add layers and move to TLC/QLC than to keep planar MLC or 3D MLC as the volume workhorse.
• Interface: ONFI / Toggle mode speeds rose from hundreds of MT/s on planar MLC to 2400+ MT/s on current 3D TLC dies.
• Process: Replacement-gate CTF + CuA + multi-deck strings (88+88 on 176L) is the current Micron template; floating-gate 3D was a transitional step.

MLC NAND from Micron is best understood as a mature two-bit technology that defined a decade of SSDs and embedded storage, then yielded volume leadership to higher-bit 3D NAND while remaining available in a thinning catalog for designs that still need its particular endurance/cost/page-geometry balance. For new platforms, the relevant Micron NAND discussion is almost always 176L+ TLC or G9 QLC with controller-managed caching—not raw MLC.

---

1) What MLC NAND Actually Is

Formal Definition

MLC NAND stores two bits of information in a single memory cell by placing that cell’s threshold voltage ($V_t$Vt​) into one of four discrete windows. Those four analog states are mapped to the digital pairs 11, 10, 00, and 01.

Cell type	Bits per cell	Voltage states	Typical raw P/E cycles (planar era)
SLC	1	2	~50,000–100,000
MLC	2	4	~3,000–10,000
TLC	3	8	~500–3,000
QLC	4	16	~100–1,500

In vendor catalogs and JEDEC-style documentation, “MLC” almost always means exactly two bits per cell. TLC and QLC are sometimes called “3-bit MLC” or “4-bit MLC” in older papers; that usage is now deprecated because it causes confusion.

Micron’s own product language still uses this definition: two bits per cell as a balance of density, performance, and endurance between SLC and TLC.

How One Cell Holds Two Bits

A NAND cell is a MOSFET whose threshold voltage is shifted by trapped charge (electrons on a floating gate or in a charge-trap nitride film).

• Erased cell: few electrons → low $V_t$ → reads as the erased state (commonly coded 11).
• Programmed cell: more electrons → higher $V_t$​.

For MLC the analog $V_t$​ axis is partitioned into four bands, separated by read-reference voltages (typically three references: R1, R2, R3). A sense amplifier compares the cell current (or developed bit-line voltage) against those references and reports which window the cell occupies.

Why four states, not two? Each additional bit requires a doubling of distinguishable levels ($2^n$ states for $n$ bits). Two bits therefore need four non-overlapping distributions with enough guard band that noise, disturb, temperature, and wear do not cause a cell to be read as the wrong state.

Programming uses incremental step pulse programming (ISPP): a series of short high-voltage pulses, each followed by a verify read, so the distribution is walked into the target window without overshooting into the next one. That is why MLC program time is longer than SLC program time (typically ~1.1–1.3 ms versus ~200–300 µs on comparable planar nodes).

Page Mapping: Lower Page and Upper Page

The two bits in one physical cell do not belong to the same logical page.

• Lower page (LSB): usually programmed first; coarser $V_t$​ placement.
• Upper page (MSB): programmed later; requires tighter placement because the cell already holds charge from the lower-page program.

A single word line therefore contains two pages of data. Controllers and ONFI command sequences address them separately. This is why an MLC device of a given physical array size presents twice as many pages as an SLC device built on the same array geometry.

Gray-code (or vendor-specific) mappings are chosen so that a single-level error flips only one of the two bits, reducing raw bit-error rate impact on ECC.

What Changes Versus SLC (and Versus TLC)

Versus SLC

• Same transistor, same tunnel oxide physics, twice the bits.
• Narrower $V_t$​ windows → more sensitive to program disturb, read disturb, and charge loss.
• Stronger ECC required.
• Partial-page programming (NOP) is typically restricted to 1 on MLC versus several on SLC.
• Endurance drops by roughly an order of magnitude on the same process node.

Versus TLC / QLC

• MLC still has relatively wide windows, so program pulses can be more aggressive and ECC lighter than on 8- or 16-level cells.
• That is why MLC remained the default for “performance” consumer SSDs and many embedded designs long after TLC existed, and why eMLC / FortisFlash variants were created for write-heavier enterprise use.

Physical Realizations Micron Used

1. Planar floating-gate MLC (IMFT era, down to ~16 nm)
   Polysilicon floating gate, later high-k inter-gate dielectric and metal control gate, air-gap isolation to cut cell-to-cell coupling.
2. Early 3D MLC (32-layer class)
   Vertical NAND strings, still floating-gate in Micron’s first 3D generation; four $V_t$ states per cell along the string.
3. Later 3D
   Micron moved volume production to charge-trap (CTF/CTN) + CMOS-under-array. Those high-layer-count dies (128L, 176L, 232L, G9) are sold almost exclusively as TLC or QLC; native two-bit MLC on those processes is a specialty or legacy catalog item.

The cell type (MLC) is independent of whether the array is 2D or 3D. MLC only specifies bits per cell and the number of $V_t$​ windows.

Common Misconceptions

• “MLC means multi-level, so TLC is also MLC.” In product and procurement language it does not. MLC = 2 bits.
• “MLC is obsolete.” Volume client/data-center NAND is TLC/QLC, but two-bit cells (and pSLC mode that uses a multi-level die as one effective bit) remain in embedded, industrial, and some high-endurance SKUs.
• “More bits always means worse reliability.” Controllers, over-provisioning, LDPC, and pSLC caches change the system-level result. Raw cell physics still favor fewer levels.
• “eMLC is a different cell.” Usually it is the same two-bit physical cell, screened and programmed more conservatively (slower ISPP, sometimes unused voltage margin) to buy extra P/E cycles.

Compact Technical Summary

MLC NAND is a four-state, two-bit-per-transistor NAND flash cell. Charge on a floating gate or charge-trap layer sets $V_t$​ into one of four windows; those windows encode two bits that are typically split across a lower page and an upper page on the same word line. Density doubles versus SLC on the same lithography and string architecture; analog margins, program time, ECC strength, and raw endurance all get worse. That trade-off defined a generation of Micron (and IMFT) planar parts and early 3D parts, and it remains the precise meaning of “MLC” when the term is used correctly.

---

2) Cell Physics and Programming

The Storage Node: Floating Gate versus Charge Trap

An MLC cell is a MOSFET whose threshold voltage encodes two bits. The storage node that holds the electrons differs by generation.

Planar and first-generation Micron 3D MLC (floating gate)
A polysilicon floating gate sits between a thin tunnel oxide (typically ~7–8 nm class) and an inter-poly dielectric (ONO or later high-k). Electrons reside on a conductive island. Any leakage path through a defect can discharge a large fraction of the stored charge, which is why planar scaling became painful: coupling ratio, interference, and defect sensitivity all worsened together. IMFT 20 nm MLC used a planar FG, thin poly FG, high-k inter-gate stack, metal control gate, and air gaps to cut neighbor coupling.

Later Micron 3D NAND (charge-trap nitride, CTF/CTN)
Charge is stored in discrete traps inside a silicon-nitride film (SONOS / TANOS-style stack: blocking oxide / trap nitride / tunnel oxide around a poly or macaroni channel). Electrons are not free to move laterally as they are on a floating gate. That localization is one reason CTF became the volume vehicle for 128L–232L+ Micron dies, even though those high-layer products shipped as TLC/QLC rather than native MLC. Replacement-gate processing and CMOS-under-array sit around this stack.

In both cases the observable is the same: trapped electrons raise $V_t$​. Four non-overlapping $V_t$​ distributions implement MLC.

Charge Transport: Fowler–Nordheim Tunneling

NAND (planar and 3D) programs and erases by Fowler–Nordheim (FN) tunneling, not channel hot-electron injection (that is a NOR-flash mechanism).⁠

A high electric field across the tunnel oxide distorts the SiO₂ barrier from trapezoidal to triangular. Electrons then tunnel from the channel inversion layer into the storage node (program) or from the storage node back toward the channel (erase). Tunnel current density is exponentially sensitive to oxide field:

$$J_{\mathrm{FN}} \propto E_{\mathrm{ox}}^2 \exp\left(-\frac{B}{E_{\mathrm{ox}}}\right)$$

Because the dependence is exponential, a few hundred millivolts of extra field produce a large change in injected charge. That is both the reason ISPP can walk $V_t$​ in fine steps and the reason disturb is dangerous: a slightly elevated field on an unselected cell still injects a measurable number of electrons over many cycles.

Program bias (selected cell)

• Selected word line: high $V_{\mathrm{pgm}}$​ (historically ~15–20+ V, stepped upward in ISPP).
• Selected bit line / channel: ~0 V.
• Result: large oxide field, electrons tunnel into FG or nitride.

Erase bias
Polarity reverses. On planar FG and many 3D CTF strings the substrate or channel is driven high while word lines are held low (or negative), so electrons leave the storage node. Some 3D architectures generate holes via gate-induced drain leakage (GIDL) at the select-gate edge, then use those holes to neutralize trapped electrons—still FN-class tunneling, different hole-supply method.⁠

Erase is a block operation: every cell on every word line of the block is returned toward the lowest $V_t$ window (the erased 11 state in typical MLC coding).

Incremental Step Pulse Programming (ISPP)

MLC cannot tolerate a single coarse program pulse. Four tight $V_t$ lobes must be placed with guard bands of only a few hundred millivolts. The industry solution is ISPP.⁠

1. Apply a short program pulse at starting voltage $V_{\mathrm{pgm0}}$​.
2. Verify-read the page against the target program-verify (PV) level for that state.
3. Cells that have crossed PV are inhibited on subsequent pulses.
4. Raise $V_{\mathrm{pgm}}$​ by a fixed step $\Delta V_{\mathrm{pgm}}$​ (often 0.2–0.5 V; MLC used finer steps than SLC).
5. Repeat until all target cells pass or a max-loop count is hit (fail).

Ideal ISPP produces $\Delta V_t \approx \Delta V_{\mathrm{pgm}}$​ per successful pulse (ISPP slope ≈ 1) once the cell is in the FN regime. Real 3D CTF cells show slope degradation, overshoot from random trap positions, and neighbor coupling; controllers and on-die algorithms compensate with smaller steps, extra verify levels, and two-pass or foggy-fine programming for the upper page.⁠

Why MLC needs tighter ISPP than SLC
SLC has one programmed lobe. MLC has three programmed lobes. Upper-page programming starts from a cell that already holds lower-page charge, so the remaining voltage budget is smaller and the verify grid is denser. Typical planar MLC used ~0.15 V-class steps and local self-boost inhibit; SLC could use ~0.5 V steps and simpler boosting.

Array Bias: Who Programs and Who Must Not

A NAND string is a series stack of cells plus source and drain select transistors. One word line is selected; all other word lines on the string receive a pass voltage $V_{\mathrm{pass}}$ so the channel can conduct or float as required.

Selected string (program)
Bit line = 0 V → drain select on → channel grounded → full $V_{\mathrm{pgm}}$​ appears across the tunnel oxide of the selected cell.

Unselected strings (inhibit)
Bit line held high so the drain select cuts off. The channel of that string is left floating and is capacitively boosted when $V_{\mathrm{pgm}}$​ and $V_{\mathrm{pass}}$​ rise (self-boosted program inhibit, SBPI). Channel potential climbs to ~6–10 V, collapsing the oxide field on unselected cells sharing the selected word line. Without boosting, those cells would experience program disturb.⁠

MLC often used local self-boosting or erased-area self-boosting (EASB) variants: selected word line’s neighbors are biased to isolate a short channel segment so the boosted potential is higher and more uniform. That extra boost margin is valuable when three programmed states must stay out of each other’s windows.⁠

Pass-voltage choice is a three-way compromise:

• Too low $V_{\mathrm{pass}}$​: unselected cells on the selected string do not pass channel potential cleanly (series resistance / incomplete inversion).
• Too high $V_{\mathrm{pass}}$​: pass disturb (weak FN on unselected word lines).
• MLC distributions leave less room for either error than SLC.

Two-Page Programming Sequence

Because two bits share one physical cell:

1. Lower page (LSB) is usually programmed first into a coarse pair of lobes (erased vs. a mid-level).
2. Upper page (MSB) is programmed later; ISPP then splits those lobes into the final four states.

A lower-page-only programmed cell is an intermediate “foggy” distribution. If power is lost between lower- and upper-page program, the controller must reconstruct or rewrite using spare and ECC. This two-pass nature is why MLC program throughput is not simply “twice SLC pages at the same tPROG.”

Read Sensing (Why Physics Constrains MLC)

Read applies a word-line voltage between adjacent $V_t$ lobes and senses whether the cell conducts. Three read-reference levels separate four states. As cells wear:

• Distributions widen (trap generation, random telegraph noise, lateral charge spreading in CTF).
• Mean $V_t$​ can shift (detrapping, interference).
• Read retry and LDPC become mandatory.

That is a direct consequence of packing four Gaussians onto one $V_t$ axis instead of two.

Wear and Failure Physics Tied to Programming

Every FN pulse stresses the tunnel oxide. Effects that matter more for MLC than SLC:

Mechanism	What happens	Why MLC feels it first
Program disturb	Weak FN on inhibited cells sharing a word line	Narrower target windows
Pass disturb	Weak FN on unselected word lines	Same
Read disturb	Many reads slowly add charge	Tight lobes, extra retries
Charge loss / detrapping	Electrons leave storage node over time/temp	Retention spec collapses after heavy cycling
Cell-to-cell interference	Neighbor $V_t$​ change couples into victim	Planar FG worst; 3D CTF better but not zero
ISPP overshoot	Random traps in nitride capture extra electrons	Broadens programmed lobes

Endurance ratings (3k–10k P/E for commodity MLC, higher for eMLC/FortisFlash) are the point at which these effects plus ECC still meet a datasheet raw-bit-error and retention target—not the point at which the transistor “breaks.”

Micron-Specific Context

• Planar IMFT MLC: FG + ISPP + self-boost / local-boost inhibit; 20 nm and 16 nm parts are the textbook examples of two-bit planar physics.
• Early 3D MLC flyer parts: same FN + ISPP methods, vertical string, 3k-cycle class MLC spec, tPROG ~1.3 ms typical.
• Modern high-layer Micron NAND: CTF + replacement gate + CuA; the programming physics is still FN + ISPP + boost inhibit, but native two-bit MLC is no longer the volume product. The same engine runs eight or sixteen $V_t$​ levels for TLC/QLC, with finer steps, more verify levels, and heavier controller assist.

Compact Physical Picture

An MLC NAND cell stores two bits as four $V_t$Vt​ windows created by a controlled number of electrons on a floating gate or in a nitride trap layer. Those electrons arrive and leave by Fowler–Nordheim tunneling. Incremental step pulses plus per-cell verify walk each cell into a narrow target window. Unselected strings survive only because their channels are capacitively boosted so the oxide field collapses. Everything that makes MLC harder than SLC—slower program, stronger ECC, lower endurance, two-pass pages—follows from fitting four distributions onto one analog axis and from the exponential sensitivity of tunnel current to a few tenths of a volt.

---

3) Micron’s Product Lineage

How to Read Micron NAND Generations

Micron’s flash history splits into three eras:

1. Planar NAND (mostly IMFT with Intel) — MLC was the volume workhorse.
2. First 3D NAND (32-layer floating-gate) — MLC still had a named product slot.
3. High-layer CTF + CuA 3D (96L through G9) — native MLC exits the mainstream; TLC/QLC take the dies.

“MLC” here means two bits per cell. Die markings (B37R, B47R, B58R, and so on) and layer counts describe geometry; they do not by themselves say how many $V_t$​ levels the product uses.

Era 1: Planar IMFT MLC (the volume years)

Intel and Micron manufactured NAND through IM Flash Technologies (IMFT). Planar MLC scaled by shrinking the floating-gate cell and changing array architecture (even/odd bit lines → all-bit-line, larger pages, more planes).

Generation (approx.)	Node	Representative density	Cell / notes	Role
Mid-2000s	72–50 nm	8–16 Gb	FG MLC, 2K–4K pages	Early SSDs, cards
Late 2000s	34 nm	32 Gb class	Enterprise MLC claims (~30k P/E on screened parts)	eMLC push
~2010–2011	25 nm	64 Gb	Smaller die vs prior 64 Gb	Consumer + enterprise
~2012	20 nm	64 Gb	Planar FG, HKMG, ~117 mm², ~0.0017 µm² cell	Flagship IMFT MLC teardown subject
~2014	16 nm	128 Gb	Dual-plane, 16 KB pages, 512 pages/block (typical Crucial-class parts)	Last high-volume planar MLC in client SSDs

Architectural trends on these parts:

• Page size grew from ~2 KB to 8–16 KB.
• Planes per die: typically two.
• Program throughput rose more from page size and ABL parallelism than from faster tPROG (tPROG stayed ~1 ms class).
• ECC strength and NOP restrictions tightened as windows shrank.

This is the generation most engineers still mean when they say “Micron 16 nm MLC” or “IMFT 20 nm MLC.”

Era 2: First 3D NAND — MLC still on the datasheet

In 2015 Intel and Micron announced 32-layer 3D NAND: 256 Gb MLC and 384 Gb TLC dies, floating-gate cell, vertical strings. Marketing positioned 3D MLC as roughly 3× planar capacity in the same form factor.⁠

Micron’s early 3D flyer listed explicit two-bit SKUs:

Item	3D MLC (flyer)	3D TLC (same flyer)
Example density	256 Gb (32 GB)	384 Gb
Bits/cell	2	3
Page	16 384 + 2208 B	Same
Pages/block	1024	1536
tPROG typ/max	1300 / 2500 µs	1630 / 5000 µs
P/E	3K + read retry	1500 LDPC / 500 BCH

FortisFlash appeared as a branding layer on 20 nm / 16 nm and early 3D stacks: same MLC/TLC physics, higher endurance than commodity parts, without full enterprise usage limits. eMLC / enterprise MLC was the write-optimized two-bit grade (slower ISPP, screening).

After the first 32-layer generation, layer count and cell type diverged. Micron moved from floating-gate 3D toward charge-trap (CTF/CTN), replacement gate, and CMOS-under-array. Two-bit product SKUs did not keep pace with layer count.

Era 3: High-layer 3D — TLC/QLC take the die

Micron’s public high-volume ladder (client/data-center NAND) is a layer-count and I/O-speed ladder, not an MLC ladder.

Micron 3D generation	Layers (active WLs)	Typical bits/cell in volume	Notable die / product hooks
First 3D	32	MLC and TLC both offered	256 Gb MLC / 384 Gb TLC announcement
Mid 3D	64 / 96	TLC dominant	1200 MT/s-class I/O
128L	128 (B37R class)	TLC	~66 mm² 512 Gb TLC, ~7.8 Gb/mm²; CuA CTF, 2 decks
176L	176 (B47R)	TLC	First 176L NAND; ~50 mm² 512 Gb, ~10.3 Gb/mm²; 195T gates; 88+88 decks; used in 3400-class SSDs
232L	232 (B58R)	TLC (QLC variants exist in the family)	~14.6 Gb/mm² class; ONFI 5.0 / ~2400 MT/s; 3500-class SSDs
G8 / G9	~232–276	TLC and QLC	G9 QLC in 2600 / 3610 client SSDs; adaptive write / multi-tier cache

TechInsights-style comparisons of 128L vs 176L show the same CTF + CuA recipe: die shrink, more word lines per deck, similar unit cell area (~0.020 µm²), higher bit density. Operation column in those teardowns is TLC, not MLC.⁠

Native two-bit programming did not disappear from the process (a TLC die can be run as pSLC or, in principle, as MLC). It disappeared from the product mix because three- and four-bit operation plus controller caches delivered lower $/GB at acceptable system endurance.

What Remains in the MLC Catalog

Micron still publishes an MLC NAND product page and part catalog, plus “choosing the right NAND” guidance that lists MLC as the two-bit option beside SLC, eMLC, and TLC. Many line items are End of Life, Obsolete, or Contact Sales; surviving parts skew toward embedded, industrial temperature, and existing-customer supply.

Industry context in 2026: major suppliers have cut or scheduled exit of planar 2D MLC lines. MLC capacity was forecast to fall sharply; spot prices for legacy 64 Gb MLC rose after the cuts. Micron’s remaining MLC output has been described as demand-limited rather than growth-oriented.

So the current “Micron MLC” story is:

• Historical core: IMFT planar 25/20/16 nm two-bit NAND.
• Transitional 3D: 32-layer FG 256 Gb MLC.
• Current volume: 176L–G9 CTF TLC/QLC.
• Current MLC: thin catalog + FortisFlash/eMLC-style grades + pSLC mode on newer dies.

Corporate and Fab Context (needed to read part numbers)

• IMFT: joint NAND manufacturing with Intel; produced the planar MLC nodes that filled early Crucial and OEM SSDs. The companies later split 3D paths (Intel/Solidigm floating-gate CuA vs Micron CTF CuA).
• Crucial: client brand that absorbed 16 nm planar MLC, then 3D TLC.
• FortisFlash: endurance/feature branding on selected MLC and TLC stacks, not a different cell physics.
• Die markings: B37R ≈ 128L TLC, B47R ≈ 176L TLC, B58R ≈ 232L TLC — useful when reverse-engineering an SSD, not an MLC indicator.

Lineage in One Sentence

Micron built its NAND business on planar two-bit (MLC) cells through 16 nm, put MLC on the first 32-layer 3D datasheets, then used layer count, CuA, and CTF to make TLC and QLC the economic product—leaving MLC as a qualified niche and a mode you can still emulate on a multi-level die, not as the roadmap’s next bit density.

---

4) Reliability, Endurance, and Controller Compensation

What Endurance Means on an MLC Cell

A program/erase (P/E) cycle is one block erase plus the programs that refill that block. Each Fowler–Nordheim pulse injects or removes charge through the tunnel oxide (or into/out of a charge-trap film). Damage accumulates as:

• Interface traps and oxide traps
• Stress-induced leakage paths
• Broader, shifted $V_t$​ distributions
• Worse random telegraph noise and retention tails

Commodity planar MLC was commonly specified at about 3,000–10,000 P/E cycles. eMLC / FortisFlash grades used screening and slower ISPP to publish higher figures (historically ~10,000–30,000 on some 3x–2x nm enterprise parts). SLC on a comparable node sat near 50,000–100,000. Those numbers are qualification points: the cycle count at which raw bit error rate, program/erase time, and data retention still meet a defined spec (often ~1 year retention at elevated temperature at end of life)—not the cycle at which the transistor is open-circuit.

Early Micron 3D MLC flyer parts listed 3K P/E plus read retry for two-bit operation versus lower cycle / stronger ECC numbers for TLC on the same 32-layer platform.

Failure Mechanisms That Hit MLC First

Because four $V_t$​ lobes share one voltage axis, MLC has less guard band than SLC. The mechanisms below all steal that band.

Mechanism	Physical cause	System symptom
Program disturb	Weak FN on inhibited cells on the selected word line	Rising RBER on “untouched” pages
Pass disturb	Elevated $V_{\mathrm{pass}}$​ on unselected word lines	Same, different address pattern
Read disturb	Many reads slowly add charge	Cold data goes bad after heavy read traffic
Retention / detrapping	Electrons leave FG or nitride over time and temperature	$V_t$ collapse toward erase; worse after heavy cycling
Interference	Neighbor program couples into victim $V_t$​	Upper-page errors, tighter need for two-pass program
Cycling-induced widening	Trap generation, RTN	ECC budget exhausted; tPROG/tBERS stretch
Over-program	ISPP overshoot, especially CTF random traps	Cell lands in the next state

MLC’s two-pass (lower then upper page) sequence adds a power-loss hazard: a cell left in an intermediate “foggy” distribution is not a valid four-state codeword until the upper page finishes.

Temperature accelerates almost every item in the table. Industrial and automotive Micron grades exist because Arrhenius-style retention and disturb models do not look the same at 85 °C or 105 °C as they do at 40 °C.

From Cell Cycles to Drive Writes

Raw P/E is not what a host sees. Firmware multiplies or divides that budget.

$$\text{Host bytes writable} \approx \frac{C_{\text{raw}} \times N_{\text{PE}} \times \text{OP factor}}{\text{WAF}}$$

Where:

• $C_{\text{raw}}$​ = physical NAND capacity
• $N_{\text{PE}}$ = rated cell P/E
• Over-provisioning (OP) hides spare blocks so user-visible capacity can be rewritten more times
• Write amplification factor (WAF) ≥ 1 because garbage collection, wear leveling, metadata, and folding rewrite more NAND than the host sent

Random small-block writes on a full drive produce high WAF; large sequential writes on a fresh drive produce WAF near 1. That is why the same MLC NAND can be specified as modest TBW on a client SSD and much higher TBW on an enterprise SSD with 28–60% OP. Historical Micron vs Intel 25 nm MLC comparisons showed that identical-looking IMFT silicon received different published P/E and different OP, so drive-level endurance diverged even when the cell was cousins.

Enterprise metrics:

• TBW — terabytes written over warranty
• DWPD — drive writes per day over the warranty window
• MWI / media wear indicator — SMART-style fraction of rated life consumed

Controller and On-Die Compensation Stack

Compensation is layered. Micron NAND provides some of it on-die; the rest lives in the SSD/e.MMC/UFS controller or host FTL.

1. Error correction

Planar MLC moved from a few bits of BCH per 512 B to tens of bits per 1 KB. Early 3D MLC flyers already listed 72-bit BCH or LDPC per 1 KB. TLC/QLC later standardized on LDPC with soft-decision reads. MLC’s four states need less ECC than eight or sixteen states, but far more than SLC.

2. Read retry and reference tracking

When a distribution has shifted, the controller (or on-die logic) retries the same page at offset word-line voltages. Micron’s 3K MLC spec explicitly included read retry. Without it, cycling and retention would fail the datasheet much earlier.

3. Wear leveling

Dynamic and static wear leveling spread erases across blocks so hot logs do not kill a few blocks while others sit erased. Static leveling is mandatory for MLC because retention-after-cycling is worse on heavily used blocks.

4. Over-provisioning and spare management

Spare blocks replace grown defect blocks and keep GC efficient. Higher OP is the simplest way to turn 3K-cycle MLC into a respectable enterprise TBW number.

5. Garbage collection and write coalescing

FTL maps host LBAs to NAND pages. Invalid pages accumulate; GC copies valid pages and erases the block. Poor GC is the usual reason WAF explodes on MLC (and every other NAND type).

6. Program algorithm tuning (eMLC / FortisFlash)

Enterprise two-bit grades historically:

• Slowed ISPP (larger tPROG, smaller $\Delta V_{\mathrm{pgm}}$​)
• Screened dies for tighter native distributions
• Sometimes left unused voltage margin (operating a two-bit cell more like a conservative two-bit or even a pseudo-SLC subset)

FortisFlash was Micron’s brand for “higher endurance than standard MLC/TLC without enterprise usage limitations.” It is a spec and algorithm package, not a different transistor.

7. pSLC / SLC-mode caching

On later multi-level Micron dies the controller programs a fraction of the array as one bit per cell. Burst writes hit that cache; background folding moves data into full MLC/TLC/QLC. This is the dominant system reason modern TLC SSDs feel fast and last long enough despite weaker raw cells. The same trick can be applied to an MLC die (use only two of four states).

8. Data retention management

• Periodic refresh / scrub of cold blocks
• Temperature-aware throttle and verify
• Stronger ECC decode effort as the media ages (soft-bit LDPC)

9. RAID-like and XOR protection inside the SSD

Die-level or page-level XOR parity survives a page or die failure that ECC alone cannot. More common on enterprise controllers wrapping Micron NAND than on the raw NAND itself.

---

How Micron Positioned the Grades

Grade	Bits used	Typical intent	Compensation emphasis
SLC	1	Mission-critical, industrial	Little ECC, high raw cycles
MLC	2	Cost-sensitive density with mid endurance	Wear level + moderate ECC + retry
eMLC / FortisFlash	2 (conservative)	Write-heavier embedded/enterprise	Slower program, screening, extra margin
TLC / QLC + pSLC cache	3 or 4 + 1-bit cache	Client and data-center volume	LDPC, folding, adaptive cache, high OP

Micron’s public “choosing the right NAND” guidance still frames MLC as the two-bit balance point and eMLC as the write-extended two-bit option. Volume SSDs have moved the compensation burden onto TLC/QLC plus cache rather than onto native MLC silicon.

Practical Reliability Budget (how to think about a design)

When qualifying Micron MLC (or pSLC-on-MLC) in a system:

1. Start from the datasheet P/E and retention-after-cycles, not from SLC folklore.
2. Multiply by physical / user capacity (OP).
3. Divide by a workload WAF (measure it; do not assume 1.0).
4. Apply temperature acceleration if the product sits above the qualification ambient.
5. Leave ECC headroom for retention at end of life, not only for fresh media.
6. Treat power-loss during upper-page program as a first-class fault.
7. If the design is write-heavy and cost-constrained, prefer eMLC/FortisFlash or pSLC mode over hoping commodity MLC plus firmware will match SLC.

Compact Takeaway

Micron MLC reliability is the story of four tight VtV_tVt​ windows wearing under FN stress, then being held inside spec by ISPP verify, inhibit boosting, ECC, read retry, wear leveling, over-provisioning, and (in enterprise grades) slower programming. The cell’s raw 3K–10K cycle class is real; the product lifetime is a firmware and spare-area calculation. As Micron’s volume NAND became TLC and QLC, those same compensation layers grew thicker—the physics did not get easier, the controller took more of the burden.

---

5) Where MLC Still Matters in 2026

The 2026 Reality Check

Volume NAND economics now favor 176-layer-class and newer 3D TLC/QLC. Micron’s shipping client parts (3400/3500-class TLC, 2600/3610-class QLC) use those dies plus pSLC/adaptive caches, not native MLC.

At the same time, major suppliers cut or scheduled exit of legacy 2D / mature-node MLC lines. Global MLC capacity was projected to fall on the order of 40% year over year in 2026. Contract prices hit record highs in the first half of the year. Some industrial and automotive buyers began migrating low- to mid-density MLC designs to 4 Gb / 8 Gb SLC rather than to TLC, because requalifying a three-bit cell was harder than paying for one-bit silicon. That spillover is one reason SLC contract prices were forecast to jump sharply in 2H26.

Micron’s remaining MLC output is widely described as demand-limited—serving existing customers and catalog sockets, not a growth node. FortisFlash / eMLC-style grades and the MLC part catalog still exist; many SKUs are EOL or “contact sales.”

So “where MLC matters” in 2026 is not “where it wins $/GB.” It is where qualification lock-in, page geometry, endurance between SLC and TLC, and 10-year product life still dominate the bill of materials.

---

Sockets That Still Justify Two Bits per Cell

Industrial automation and control

This is the largest remaining MLC demand pool in specialist market splits (industrial automation was cited near 44% of a narrowly defined MLC-flash application mix in 2025). PLCs, HMIs, CNC controllers, and factory gateways often:

• Were designed around a specific ONFI command set, page size, and ECC budget
• Need mid endurance (far above USB-stick TLC, below flight-recorder SLC)
• Sit in the field for a decade
• Cannot absorb a TLC controller change without recertifying the whole machine

Those designs are exactly the ones trapped when MLC wafers disappear: they either last-time-buy, move to SLC, or adopt pSLC mode on a 3D MLC/TLC die from an industrial module vendor.

Automotive electronics (non-infotainment-mass-storage)

Automotive is the second structural pocket. AEC-Q100 / AEC-Q104, PPAP, and 15-year lifetime rules freeze memory choices long after consumer NAND has moved on. Two-bit NAND (or pSLC) still appears in:

• Event data recorders and calibration stores
• Gateway and TCU firmware volumes that see moderate writes
• Legacy infotainment platforms already qualified on MLC e.MMC

New ADAS / central-compute platforms more often specify managed automotive TLC UFS/e.MMC or SLC for boot. The MLC residue is the already-qualified box, not the next architecture. Shortage-driven SLC substitution in 2026 is happening in this channel as well.

Networking, boot, and appliances

Routers, base-station cards, storage controllers’ boot devices, and telecom line cards need:

• Predictable tPROG / tBERS
• Modest density (2–32 GB class is common)
• Power-fail robustness
• Long FRU life

MLC (and SLC) fit that profile. High-layer QLC does not, unless a sophisticated FTL and pSLC cache are already in the design—which many ASIC-attached raw-NAND boards do not have.

Medical, aerospace, defense, and instrumentation

Small unit volume, brutal change-control, and data-integrity requirements keep two-bit (or one-bit) NAND in recorders, imaging buffers, and mission computers. Cost-per-bit is irrelevant next to recertification cost.

Legacy SSD and embedded modules still in production

A minority of industrial SSDs, CF/CFast, and raw-NAND SIPs continue to ship native MLC or MLC-in-pSLC. Swissbit-class vendors explicitly sell the same hardware in SLC, pSLC, and MLC modes so a customer can stay on a known controller while picking endurance. That is a 2026 product strategy, not a 2014 leftover.

---

Where MLC Does Not Matter Anymore

Segment	Why native MLC lost
Client NVMe SSDs	176L–G9 TLC/QLC + DRAM or HMB + pSLC cache beat MLC on $/GB and sequential speed
Hyperscale / AI corpus storage	QLC density and TBW-at-petabyte-scale dominate
Phones, UFS, high-density e.MMC	TLC/QLC managed NAND; JEDEC features hide cell type
USB / SD consumer	TLC/QLC only
New greenfield embedded if the team will take a modern FTL	3D TLC + pSLC is usually cheaper and still available

If the project can accept a controller that folds pSLC into TLC, buying native MLC in 2026 is usually the worse supply-chain decision.

---

The Substitution Map Designers Are Using

When a Micron (or peer) MLC EOL notice lands, 2026 practice looks like this:

1. Last-time buy if the product has <5 years of remaining production and the NAND is already qualified.
2. Drop-in SLC (4–8 Gb class) when endurance and simplicity beat density—this is the migration TrendForce documented as MLC prices spiked.
3. pSLC on 3D TLC or leftover 3D MLC when capacity must stay in the 16–128 GB range and the controller already supports mode bits.
4. Managed TLC e.MMC/UFS automotive/industrial grade when the host can give up raw NAND and take a JEDEC device.
5. Redesign to high-layer TLC SSD only when the interface can become NVMe/SATA and firmware ownership is acceptable.

pSLC is the real “MLC successor” for many write-heavy industrial SKUs: one bit programmed on a multi-level 3D die, endurance far above TLC, cost far below true SLC, supply aligned with factories that still run 176L+ wafers.

---

Micron-Specific Angle

For a designer specifying Micron silicon in 2026:

• Check the MLC catalog and FortisFlash line first, then assume allocation and EOL risk.
• Treat B47R / B58R / G9 markings as TLC or QLC unless the module vendor documents pSLC or a special two-bit mode.
• For new automotive or industrial programs, Micron’s growth path is managed NAND and 3D TLC/QLC, not a new planar MLC node.
• If the socket is raw NAND and must stay two-bit, plan a multi-source last-time-buy and a pSLC fallback in the same schematic revision.

Decision Table

If you need…	Native MLC still rational?	Better 2026 default
Lowest $/GB at 1 TB+	No	QLC / TLC SSD
100k-class P/E, small density	Rarely (use SLC)	SLC
10k-class P/E, already-qualified raw NAND	Yes, until stock ends	LTB + pSLC plan
New industrial 32–256 GB with writes	Weak	3D TLC in pSLC or industrial SSD
Automotive new platform	Weak	Auto UFS/e.MMC TLC or SLC boot
Networking boot / logs	Sometimes	SLC or pSLC

Compact Takeaway

In 2026 Micron MLC matters in installed-base industrial, automotive, and networking designs that cannot change cell type without requalifying the product—and in those sockets it matters more because supply contracted. It does not matter in new client, cloud, or mobile storage. The engineering substitute is no longer “wait for the next MLC node”; it is SLC for small, harsh writes and pSLC on high-layer 3D NAND for everything that still wants two-bit-class endurance on a living process.

---

---