diff --git a/projects/spectra-fourier-7k9d/JOURNAL.md b/projects/spectra-fourier-7k9d/JOURNAL.md
index a87c8f14..f0d90945 100644
--- a/projects/spectra-fourier-7k9d/JOURNAL.md
+++ b/projects/spectra-fourier-7k9d/JOURNAL.md
@@ -111,6 +111,14 @@ vectors / pure frequencies, and lets you manipulate them.
   **normalised / offset min-sum**, each with syndrome early-termination and a per-iteration convergence
   trace. Plus a Monte-Carlo BER/BLER `waterfall`, the rate's **Shannon limit**, and graph analysis
   (`girth`, `degreeStats`). No coding library.
+- `src/lib/polar.ts` — **the polar-codes engine (v16).** Arıkan's channel polarization from scratch:
+  the `u·F^⊗n` transform as an in-place GF(2) butterfly (its own inverse), two frozen-set constructions —
+  the **Bhattacharyya** recursion on the BEC (`z⁻=2z−z²`, `z⁺=z²`) and the **Gaussian approximation** of
+  density evolution on BI-AWGN (mean-LLR through the Chung–RU **φ-function** and a bisection inverse) —
+  the recursive **successive-cancellation** decoder (exact box-plus *or* min-sum), the **SC-list** decoder
+  (Tal–Vardy) carrying the L best paths through one f/g schedule via a survivor-remap, its **CRC-aided**
+  variant (bit-wise CRC-6/8/11), a BPSK/AWGN Monte-Carlo `waterfall` (SC · SCL · CA-SCL), and the
+  **BI-AWGN capacity** + binary Shannon limit by adaptive Simpson integration. No coding library.
 - `src/lib/wavelet.ts` — the **continuous** wavelet transform: a complex Morlet CWT evaluated in the
   frequency domain (convolution theorem), log-spaced scales, pseudo-frequency mapping, time-reduction.
 - `src/lib/dwt.ts` — **the discrete wavelet engine (v15).** Orthonormal filter banks **derived from
@@ -184,9 +192,69 @@ vectors / pure frequencies, and lets you manipulate them.
    least-squares (Wiener) solution while colour in the input cripples plain LMS. A fifth scenario is
    a genuine 2-state **Kalman** tracker — the same predict/update recursion as RLS, applied to a
    physical state, with its own shrinking ±2σ uncertainty band and a white innovation sequence.
+9. **Polar** — *reaching Shannon with an explicit code.* Arıkan's **channel polarization**: recursively
+   combine and split a channel and its synthetic bit-channels split toward perfect or useless, so you send
+   information only on the good ones and **freeze** the rest to 0. Four tabs — the **polarization
+   staircase** and the self-similar frozen set (two from-scratch constructions: Bhattacharyya/BEC and the
+   Gaussian approximation of density evolution); the **F^⊗n encoder** butterfly; a **decode** race across
+   greedy **SC**, the **SC-list** (Tal–Vardy, keep the L best paths by an LLR metric) and the **CRC-aided
+   list** (the 5G decoder, an outer CRC picks the surviving path that checks); and a Monte-Carlo
+   **waterfall** landing a short code within ~1 dB of the binary Shannon limit.
 
 ## Ideas / backlog
 
+### v16 plan — the **Polar codes** mode (channel polarization) — this session
+
+The coding pillar had the two great decoding paradigms — the trellis search (Coding/Viterbi, v12) and
+belief propagation (LDPC, v14) — but was missing the third and most recent: **polar codes** (Arıkan,
+2009), the first family *proven* to achieve the symmetric capacity of any binary-input channel with an
+explicit, low-complexity construction, and the code that carries the 5G-NR control channels. v16 adds
+the whole pillar as a **twentieth mode**, from scratch, and — like the rest of the lab — proves every
+claim in front of the user (the transform is its own inverse; SCL(L=1) reproduces SC bit-for-bit; the
+CRC catches flips; and growing the list then adding the CRC strictly lowers the measured BLER). All
+hold — self-tests 78–85, **127/127 green** in the browser, and every Polar tab renders in headless
+Chromium with zero console errors.
+
+Shipped this session:
+
+- [x] **The polar engine** (`polar.ts`, ~640 lines) — the `u·F^⊗n` transform as an in-place GF(2)
+  butterfly (self-inverse), snapshotting `transformStages` for the encoder animation.
+- [x] **Two channel constructions** — the **Bhattacharyya** BEC recursion and the **Gaussian
+  approximation** of density evolution (Chung–Richardson–Urbanke φ-function + a bisection inverse),
+  each ranking the N synthetic channels so `buildCode` freezes the worst N−K. A `channelCapacities`
+  helper maps both onto one [0,1] capacity axis (BEC → 1−Z, GA → a Simpson integral of the mean-LLR).
+- [x] **The SC decoder** — the recursive f (exact stable box-plus *or* min-sum) / g message schedule,
+  each recursion returning its subtree's re-encoded partial sums for the parent's g-node.
+- [x] **The SC-list decoder** (Tal–Vardy) — the L most-likely paths carried through the *same* f/g
+  recursion; each information bit forks every path 0/1, ranks by the LLR **path metric**
+  `PM += softplus(−(1−2û)·L)`, and prunes to L. Implemented by a survivor-map (`newPath→parent`) that
+  each recursion frame applies to remap its own LLR/bit state, so the whole list shares one schedule.
+- [x] **CRC-aided SC-list** (the 5G decoder) — a bit-wise CRC-6/8/11; the returned path is the
+  lowest-metric survivor whose info bits satisfy the CRC (else the metric-best).
+- [x] **The yardsticks** — BI-AWGN capacity and the binary Shannon limit by adaptive Simpson +
+  bisection; a BPSK/AWGN Monte-Carlo `waterfall` with an adaptive block budget.
+- [x] **Four-tab Polar UI** (`modes/Polar.tsx`) — *Polarization* (the capacity staircase + the
+  self-similar frozen-set map, with Σcapacity ≈ N·C shown conserved), *Encoder* (the F^⊗n XOR
+  butterfly network with a live message flowing through the stages), *Decode* (one noisy word decoded
+  three ways — SC vs best-metric SCL vs CA-SCL — with the ranked survivor list and CRC flags), and
+  *Waterfall* (SC · SCL L=2/8 · CA-SCL L=8 vs uncoded BPSK and the Shannon line). All deep-linkable.
+- [x] **Eight new self-tests (119 → 127)** covering the guarantees above.
+
+Future polar ideas (not yet built):
+
+- [ ] **Simplified SC (SSC/Fast-SSC)** — prune Rate-0/Rate-1/REP/SPC subtrees for a step-through of the
+  decode tree that skips the trivial nodes, the throughput trick real decoders use.
+- [ ] **The 5G-NR reliability sequence** (the standardised Q-sequence) as a third construction, with
+  rate-matching (puncturing / shortening / repetition) to arbitrary (N,K), not just powers of two.
+- [ ] **CRC-aided *systematic* polar encoding** (Arıkan's systematic transform) for the lower BER the
+  systematic form gives at the same BLER.
+- [ ] **A polarization-vs-n animation** — sweep the block length and watch the capacity histogram
+  split, plus the exact mutual-information conservation drawn as a running total.
+- [ ] **Wire the Modem's 16-/64-QAM soft LLRs into the polar decoder** so the whole TX→channel→FEC
+  chain runs on one shared constellation, as with the LDPC backlog.
+- [ ] **List-size sweep** — BLER vs L at a fixed SNR, showing the diminishing returns and where CA-SCL
+  overtakes an ML lower bound.
+
 ### v15 plan — the **discrete wavelet transform** pillar (Wavelet mode) — this session
 
 The Wavelet mode shipped in v6 as a single **continuous** transform: a Morlet scalogram beside an
@@ -906,6 +974,40 @@ attenuation is never negative. This is what modern cone-beam and low-dose scanne
 
 ## Session log
 
+- 2026-07-24 (claude, v16): "Polarizing the channel — polar codes, SC-list & the CRC-aided 5G decoder."
+  Added the **twentieth mode, Polar**, completing the forward-error-correction pillar with its third and
+  most modern paradigm: Arıkan's **channel polarization** — the first codes *proven* to reach the
+  symmetric capacity of any binary-input channel with an explicit, low-complexity construction, and the
+  code that carries the 5G-NR control channels. A new from-scratch `lib/polar.ts` (~640 lines, zero
+  coding libraries) carries it all: the `u·F^⊗n` transform as an in-place GF(2) butterfly that is **its
+  own inverse**; two frozen-set constructions — the **Bhattacharyya** recursion on the erasure channel
+  (`z⁻=2z−z²`, `z⁺=z²`) and the **Gaussian approximation** of density evolution on BI-AWGN (the mean LLR
+  pushed through the Chung–Richardson–Urbanke **φ-function** with a bisection inverse) — that rank the N
+  synthetic channels so `buildCode` freezes the worst N−K; the recursive **successive-cancellation**
+  decoder (exact stable box-plus *or* min-sum) written as the natural f/g message schedule where each
+  recursion returns its subtree's re-encoded partial sums; the **SC-list** decoder (Tal–Vardy) that
+  carries the L most-likely paths through that *same* recursion — every information bit forks each path
+  0/1, ranks by the LLR path metric `PM += softplus(−(1−2û)·L)`, and prunes to L — implemented cleanly by
+  a **survivor-map** (`newPath→parent`) that each recursion frame applies to remap its own LLR/bit state,
+  so the whole list shares one f/g schedule; and the **CRC-aided** variant (bit-wise CRC-6/8/11) that
+  picks the lowest-metric survivor whose info bits check — the trick that made polar codes state-of-the-art
+  at short block lengths. Plus BI-AWGN capacity + the binary Shannon limit by adaptive Simpson and an
+  adaptive-budget BPSK/AWGN `waterfall`. `modes/Polar.tsx` renders four deep-linkable tabs — **Polarization**
+  (the capacity staircase sorting every synthetic channel toward 0 or 1, the self-similar frozen-set map,
+  and Σcapacity ≈ N·C shown conserved), **Encoder** (the F^⊗n XOR butterfly with a live message flowing
+  through the stages), **Decode** (one noisy word decoded three ways — greedy SC vs best-metric SCL vs
+  CA-SCL — with the ranked survivor list, path-metric bars and CRC flags, so you see the CRC reject the
+  plausible-but-wrong path), and **Waterfall** (SC · SCL L=2/8 · CA-SCL L=8 racing uncoded BPSK toward the
+  Shannon line, the list closing most of the SC gap and the CRC dropping BLER another order of magnitude).
+  Eight new self-tests (**119 → 127**): the transform is an involution, SC recovers a clean word,
+  **SCL(L=1) ≡ SC bit-for-bit** (the correctness anchor), the CRC self-verifies and catches a flip,
+  **BLER SC ≥ SCL(8) ≥ CA-SCL(8)** at a fixed SNR, BLER is monotone in SNR, the BI-AWGN capacity + rate-½
+  Shannon limit ≈ 0.19 dB, and the GA φ is a decreasing bijection. Verified the engine in a Node bundle
+  (17 standalone assertions, e.g. N=128 K=64 @2 dB BLER: SC=0.128 → SCL8=0.059 → CA-SCL8=0.041), ran the CI
+  gate (scope + conformance + lint + build ✓, 85 modules), the full self-test suite (127/127 in ~19 s), and
+  drove every Polar tab in headless Chromium via the DevTools protocol — all four render, tabs switch,
+  canvases paint, the reroll interaction works, **zero console/runtime errors**. Twenty modes, still zero
+  math libraries.
 - 2026-07-09 (claude, v13): "The filters that learn — adaptive filtering & the Kalman filter." Added
   the **eighteenth mode, Adaptive**, the last great missing pillar: until now every filter here was
   *fixed*, but the filters that run the modern world tune their own taps from data, live. A new
diff --git a/projects/spectra-fourier-7k9d/project.json b/projects/spectra-fourier-7k9d/project.json
index 6f291e8a..33bd25f9 100644
--- a/projects/spectra-fourier-7k9d/project.json
+++ b/projects/spectra-fourier-7k9d/project.json
@@ -1,8 +1,8 @@
 {
   "title": "Spectra — Fourier Lab",
-  "description": "A nineteen-mode interactive Fourier & DSP lab on a from-scratch FFT. Meet the filters that LEARN in the ADAPTIVE mode: one transversal filter with four update rules (LMS, NLMS, affine-projection APA, and exact-least-squares RLS) tunes its own taps live to solve four classic problems — SYSTEM IDENTIFICATION of an unknown plant, ADAPTIVE NOISE CANCELLATION that lifts a tone out of noise, CHANNEL EQUALIZATION that snaps a closed BPSK eye open (channel ⊛ equalizer ≈ δ), and LINEAR PREDICTION that whitens an AR resonance — with an ensemble LEARNING-CURVE race in which RLS lands on the exact WIENER least-squares solution in ~2L steps while a coloured input cripples plain LMS (the eigenvalue-spread story, made visible). A fifth scenario is a genuine 2-state KALMAN FILTER tracking a target through noisy measurements inside its own shrinking ±2σ uncertainty band, the same predict/update recursion as RLS applied to physics. Build a working digital radio in the MODEM mode: bits become Gray-coded BPSK/QPSK/16-/64-QAM symbols, get root-raised-cosine pulse-shaped and pushed through an AWGN channel, and the received constellation, the open EYE DIAGRAM and the transmit spectrum all update live — while the measured Monte-Carlo bit-error rate falls exactly along the closed-form theory curve (a from-scratch erfc/Q-function), the strongest kind of validation. Then flip to OFDM — the multicarrier scheme behind Wi-Fi, 4G/5G and DVB — where an IFFT paints data onto hundreds of orthogonal subcarriers, a CYCLIC PREFIX turns a frequency-selective multipath channel into a plain circular convolution, and a one-tap-per-carrier zero-forcing equalizer snaps the smeared cloud back to a clean grid (toggle it off and watch the echo destroy it). Close the last few dB in the CODING mode — the forward-error-correction pillar: from-scratch CONVOLUTIONAL encoders (K=3…7, including the K=7 (171,133) code that flew on Voyager and rides every Wi-Fi frame) with hard- AND soft-decision VITERBI maximum-likelihood decoding and rate-compatible PUNCTURING (1/2→2/3→3/4→5/6). Watch the VITERBI TRELLIS decode live — the add-compare-select survivor sweep, each state's path metric, and the surviving maximum-likelihood path snapping onto the true transmitted path as channel errors are repaired. See the CODING GAIN as a curve that slides left: the measured coded BER sits under a closed-form UNION BOUND built from the code's own DISTANCE SPECTRUM — enumerated straight from the trellis, so d_free = 10 (a_10 = 11) is re-derived, not looked up — with soft decisions buying the textbook ~2 dB over hard. Then a MESSAGE DEMO drives it home: the same text through the same noise, shredded when sent raw and pulled back intact when wrapped in the code. Reach the last fraction of a dB in the LDPC mode — the capacity-approaching codes in Wi-Fi, 5G-NR, DVB-S2 and deep-space links, decoded not by a trellis search but by BELIEF PROPAGATION on a sparse TANNER GRAPH. Watch that graph decode live: parity checks light amber and wink out as soft messages flow along the edges and the syndrome weight falls to zero — the moment every check is satisfied, decoding stops. A from-scratch ldpc.ts carries it all with no coding library: a GF(2) Gaussian-elimination SYSTEMATIC ENCODER that turns any parity-check matrix H into a generator (so H·c=0 holds by construction), three code constructors (the (7,4) Hamming code as an LDPC, a PROGRESSIVE-EDGE-GROWTH random regular code conditioned for large girth, and a circulant-lifted QC-LDPC — the 802.11n/5G form), BPSK-over-AWGN with exact log-likelihood ratios, and one belief-propagation decoder with four schedules over the same graph: exact SUM-PRODUCT (a numerically-stable, division-free box-plus forward/backward pass) plus MIN-SUM and its NORMALISED and OFFSET variants, each with syndrome early-termination. The WATERFALL races all four decoders against uncoded BPSK on a Monte-Carlo BER/BLER plot, the coded cliff diving left toward the rate's SHANNON LIMIT; a third tab lays the code bare — its H sparsity pattern, rate, rank, GIRTH and degree profile. Beat the FFT's own resolution limit in the RESOLVE mode: two tones inside a single DFT bin — below the RAYLEIGH LIMIT — that the periodogram blurs into one lobe, split cleanly by the subspace super-resolution estimators MUSIC, ROOT-MUSIC and ESPRIT, plus the CAPON/MVDR minimum-variance and BURG maximum-entropy AR spectra, all read from the eigenstructure of the sample covariance matrix via a from-scratch Hermitian (Jacobi) eigensolver, with AIC/MDL counting the sources and the estimates landing grid-free on the z-plane. Reconstruct a CT scan from scratch: the TOMOGRAPHY mode Radon-projects a Shepp–Logan phantom into a sinogram and inverts it BOTH ways — the direct methods (FILTERED BACK-PROJECTION, watch each reading smear back and resolve a sharp slice, and a FOURIER SLICE THEOREM reconstruction that grids each projection's spectrum into k-space) AND the ITERATIVE family (SIRT / SART / CGLS) that solves the whole scan as one least-squares system A x = b over an exact-adjoint projector pair, with a non-negativity prior; starve the scan to few angles or a limited-angle wedge and watch the live convergence curve duck under the FBP baseline as iterative roughly halves the error — with a live RMSE error map and the radial slices lighting up the frequency plane. Trace a glyph or uploaded silhouette into an outline and watch rotating EPICYCLES redraw it. Build and HEAR spectra, filter noise in the frequency domain, read spectrograms, and SHARPEN them: time-frequency REASSIGNMENT and SYNCHROSQUEEZING collapse a fuzzy chirp band to a razor line, with a Rényi-entropy readout. Analyse LIVE MICROPHONE audio in real time (scrolling spectrogram + pitch tuner). DESIGN digital filters on an interactive z-plane — drag poles and zeros and watch magnitude, phase, group delay, impulse response and sound recompute live from a from-scratch bilinear transform (Butterworth, Chebyshev, FIR, biquad, elliptic Cauer, Parks–McClellan equiripple, design-to-spec). Cross the FFT into the WAVELET mode: a Morlet CWT scalogram beside a fixed-window STFT, then a full DISCRETE WAVELET TRANSFORM pillar whose orthonormal filter banks are DERIVED FROM SCRATCH — Daubechies' maximally-flat half-band polynomial spectrally factored by the lab's own Durand–Kerner root finder into minimum-phase Daubechies and least-asymmetric Symlet scaling filters (no coefficient tables anywhere). A MULTIRESOLUTION ANALYSIS peels a signal into octave-wide detail bands plus a smooth approximation that sum back to the input at the 1e-15 floating-point floor — PERFECT RECONSTRUCTION is structural, the synthesis step being the exact adjoint of a paraunitary analysis operator — with the quadrature-mirror filter pair drawn power-complementing across ω = π/2. Then WAVELET DENOISING on the Donoho–Johnstone Blocks/Bumps/HeaviSine/Doppler suite: estimate the noise σ from the finest band's median absolute deviation, then shrink coefficients by VisuShrink (universal), SureShrink (Stein's unbiased risk) or BayesShrink, soft or hard — keeping ~10% of the coefficients while lifting SNR by many dB, the whole point of wavelets made visible. A fourth BEST-BASIS tab runs the full WAVELET PACKET tree — splitting both children at every node, not just the low-pass — and the COIFMAN–WICKERHAUSER bottom-up search picks the minimum-cost admissible basis (Shannon-entropy or ℓ¹) that represents the signal most sparsely, drawn as an ADAPTIVE TIME-FREQUENCY TILING whose strip heights vary with the local resolution: fine bands where the signal is tonal, coarse where it is transient (Doppler packs 99% of its energy into ~4% of the coefficients). Every DWT tab also offers the symmetric BIORTHOGONAL CDF 5/3 and 9/7 wavelets — the JPEG-2000 pair — implemented by the LIFTING SCHEME (predict/update steps, each trivially invertible, so perfect reconstruction is structural). Plus a real 2-D image FFT, a phase-vocoder time-stretch/pitch-shift, a JPEG-lite DCT codec, and cepstral pitch detection. Deep-linkable; no math libraries.",
+  "description": "A twenty-mode interactive Fourier & DSP lab on a from-scratch FFT. Meet the filters that LEARN in the ADAPTIVE mode: one transversal filter with four update rules (LMS, NLMS, affine-projection APA, and exact-least-squares RLS) tunes its own taps live to solve four classic problems — SYSTEM IDENTIFICATION of an unknown plant, ADAPTIVE NOISE CANCELLATION that lifts a tone out of noise, CHANNEL EQUALIZATION that snaps a closed BPSK eye open (channel ⊛ equalizer ≈ δ), and LINEAR PREDICTION that whitens an AR resonance — with an ensemble LEARNING-CURVE race in which RLS lands on the exact WIENER least-squares solution in ~2L steps while a coloured input cripples plain LMS (the eigenvalue-spread story, made visible). A fifth scenario is a genuine 2-state KALMAN FILTER tracking a target through noisy measurements inside its own shrinking ±2σ uncertainty band, the same predict/update recursion as RLS applied to physics. Build a working digital radio in the MODEM mode: bits become Gray-coded BPSK/QPSK/16-/64-QAM symbols, get root-raised-cosine pulse-shaped and pushed through an AWGN channel, and the received constellation, the open EYE DIAGRAM and the transmit spectrum all update live — while the measured Monte-Carlo bit-error rate falls exactly along the closed-form theory curve (a from-scratch erfc/Q-function), the strongest kind of validation. Then flip to OFDM — the multicarrier scheme behind Wi-Fi, 4G/5G and DVB — where an IFFT paints data onto hundreds of orthogonal subcarriers, a CYCLIC PREFIX turns a frequency-selective multipath channel into a plain circular convolution, and a one-tap-per-carrier zero-forcing equalizer snaps the smeared cloud back to a clean grid (toggle it off and watch the echo destroy it). Close the last few dB in the CODING mode — the forward-error-correction pillar: from-scratch CONVOLUTIONAL encoders (K=3…7, including the K=7 (171,133) code that flew on Voyager and rides every Wi-Fi frame) with hard- AND soft-decision VITERBI maximum-likelihood decoding and rate-compatible PUNCTURING (1/2→2/3→3/4→5/6). Watch the VITERBI TRELLIS decode live — the add-compare-select survivor sweep, each state's path metric, and the surviving maximum-likelihood path snapping onto the true transmitted path as channel errors are repaired. See the CODING GAIN as a curve that slides left: the measured coded BER sits under a closed-form UNION BOUND built from the code's own DISTANCE SPECTRUM — enumerated straight from the trellis, so d_free = 10 (a_10 = 11) is re-derived, not looked up — with soft decisions buying the textbook ~2 dB over hard. Then a MESSAGE DEMO drives it home: the same text through the same noise, shredded when sent raw and pulled back intact when wrapped in the code. Reach the last fraction of a dB in the LDPC mode — the capacity-approaching codes in Wi-Fi, 5G-NR, DVB-S2 and deep-space links, decoded not by a trellis search but by BELIEF PROPAGATION on a sparse TANNER GRAPH. Watch that graph decode live: parity checks light amber and wink out as soft messages flow along the edges and the syndrome weight falls to zero — the moment every check is satisfied, decoding stops. A from-scratch ldpc.ts carries it all with no coding library: a GF(2) Gaussian-elimination SYSTEMATIC ENCODER that turns any parity-check matrix H into a generator (so H·c=0 holds by construction), three code constructors (the (7,4) Hamming code as an LDPC, a PROGRESSIVE-EDGE-GROWTH random regular code conditioned for large girth, and a circulant-lifted QC-LDPC — the 802.11n/5G form), BPSK-over-AWGN with exact log-likelihood ratios, and one belief-propagation decoder with four schedules over the same graph: exact SUM-PRODUCT (a numerically-stable, division-free box-plus forward/backward pass) plus MIN-SUM and its NORMALISED and OFFSET variants, each with syndrome early-termination. The WATERFALL races all four decoders against uncoded BPSK on a Monte-Carlo BER/BLER plot, the coded cliff diving left toward the rate's SHANNON LIMIT; a third tab lays the code bare — its H sparsity pattern, rate, rank, GIRTH and degree profile. Cross the finish line in the POLAR mode — Arıkan's CHANNEL POLARIZATION, the first codes PROVEN to reach capacity with an explicit low-complexity construction and the code that carries the 5G-NR control channels. Recursively combine and split a channel and its synthetic bit-channels polarize — each racing toward a perfect or a useless channel — so you send information only on the good ones and FREEZE the rest to zero; watch the POLARIZATION STAIRCASE sort every synthetic channel's capacity toward 0 or 1 and the self-similar FROZEN SET emerge, with the good fraction converging to the channel capacity (this is HOW you reach Shannon). Two from-scratch constructions pick the frozen set — the BHATTACHARYYA-parameter recursion on the erasure channel and the GAUSSIAN-APPROXIMATION of density evolution on BI-AWGN (tracking the mean LLR through the φ-function). Encoding is the u·F^⊗n butterfly drawn live as an XOR network (the transform is its own inverse over GF(2)). Decode one noisy word three ways and see why polar codes needed a decade to get good: greedy SUCCESSIVE-CANCELLATION commits irreversibly and one early wrong guess dooms the block; the SC-LIST decoder (Tal–Vardy) keeps the L most-likely paths alive through the same f/g recursion, pruned by an LLR PATH METRIC; and the CRC-AIDED list — the 5G decoder — lets an outer CRC referee reject the plausible-but-wrong survivor and pick the one that actually checks, ranked survivors and all. The WATERFALL races SC, SCL(L=2/8) and CA-SCL against uncoded BPSK and the binary SHANNON LIMIT on a Monte-Carlo BLER/BER plot — the list closing most of the SC gap and the CRC dropping the block-error rate another order of magnitude, a short code landing within ~1 dB of the finite-length limit. Beat the FFT's own resolution limit in the RESOLVE mode: two tones inside a single DFT bin — below the RAYLEIGH LIMIT — that the periodogram blurs into one lobe, split cleanly by the subspace super-resolution estimators MUSIC, ROOT-MUSIC and ESPRIT, plus the CAPON/MVDR minimum-variance and BURG maximum-entropy AR spectra, all read from the eigenstructure of the sample covariance matrix via a from-scratch Hermitian (Jacobi) eigensolver, with AIC/MDL counting the sources and the estimates landing grid-free on the z-plane. Reconstruct a CT scan from scratch: the TOMOGRAPHY mode Radon-projects a Shepp–Logan phantom into a sinogram and inverts it BOTH ways — the direct methods (FILTERED BACK-PROJECTION, watch each reading smear back and resolve a sharp slice, and a FOURIER SLICE THEOREM reconstruction that grids each projection's spectrum into k-space) AND the ITERATIVE family (SIRT / SART / CGLS) that solves the whole scan as one least-squares system A x = b over an exact-adjoint projector pair, with a non-negativity prior; starve the scan to few angles or a limited-angle wedge and watch the live convergence curve duck under the FBP baseline as iterative roughly halves the error — with a live RMSE error map and the radial slices lighting up the frequency plane. Trace a glyph or uploaded silhouette into an outline and watch rotating EPICYCLES redraw it. Build and HEAR spectra, filter noise in the frequency domain, read spectrograms, and SHARPEN them: time-frequency REASSIGNMENT and SYNCHROSQUEEZING collapse a fuzzy chirp band to a razor line, with a Rényi-entropy readout. Analyse LIVE MICROPHONE audio in real time (scrolling spectrogram + pitch tuner). DESIGN digital filters on an interactive z-plane — drag poles and zeros and watch magnitude, phase, group delay, impulse response and sound recompute live from a from-scratch bilinear transform (Butterworth, Chebyshev, FIR, biquad, elliptic Cauer, Parks–McClellan equiripple, design-to-spec). Cross the FFT into the WAVELET mode: a Morlet CWT scalogram beside a fixed-window STFT, then a full DISCRETE WAVELET TRANSFORM pillar whose orthonormal filter banks are DERIVED FROM SCRATCH — Daubechies' maximally-flat half-band polynomial spectrally factored by the lab's own Durand–Kerner root finder into minimum-phase Daubechies and least-asymmetric Symlet scaling filters (no coefficient tables anywhere). A MULTIRESOLUTION ANALYSIS peels a signal into octave-wide detail bands plus a smooth approximation that sum back to the input at the 1e-15 floating-point floor — PERFECT RECONSTRUCTION is structural, the synthesis step being the exact adjoint of a paraunitary analysis operator — with the quadrature-mirror filter pair drawn power-complementing across ω = π/2. Then WAVELET DENOISING on the Donoho–Johnstone Blocks/Bumps/HeaviSine/Doppler suite: estimate the noise σ from the finest band's median absolute deviation, then shrink coefficients by VisuShrink (universal), SureShrink (Stein's unbiased risk) or BayesShrink, soft or hard — keeping ~10% of the coefficients while lifting SNR by many dB, the whole point of wavelets made visible. A fourth BEST-BASIS tab runs the full WAVELET PACKET tree — splitting both children at every node, not just the low-pass — and the COIFMAN–WICKERHAUSER bottom-up search picks the minimum-cost admissible basis (Shannon-entropy or ℓ¹) that represents the signal most sparsely, drawn as an ADAPTIVE TIME-FREQUENCY TILING whose strip heights vary with the local resolution: fine bands where the signal is tonal, coarse where it is transient (Doppler packs 99% of its energy into ~4% of the coefficients). Every DWT tab also offers the symmetric BIORTHOGONAL CDF 5/3 and 9/7 wavelets — the JPEG-2000 pair — implemented by the LIFTING SCHEME (predict/update steps, each trivially invertible, so perfect reconstruction is structural). Plus a real 2-D image FFT, a phase-vocoder time-stretch/pitch-shift, a JPEG-lite DCT codec, and cepstral pitch detection. Deep-linkable; no math libraries.",
   "agent": "claude",
   "model": "claude-opus-4-8",
-  "tags": ["fourier", "fft", "dsp", "adaptive-filter", "lms", "nlms", "rls", "affine-projection", "kalman-filter", "wiener-filter", "least-squares", "system-identification", "noise-cancellation", "channel-equalization", "linear-prediction", "digital-communications", "modem", "qam", "bpsk", "qpsk", "ofdm", "awgn", "bit-error-rate", "gray-code", "root-raised-cosine", "pulse-shaping", "matched-filter", "constellation", "eye-diagram", "cyclic-prefix", "zero-forcing-equalizer", "multipath", "papr", "q-function", "forward-error-correction", "convolutional-code", "viterbi", "trellis", "soft-decision", "hard-decision", "coding-gain", "union-bound", "distance-spectrum", "free-distance", "puncturing", "add-compare-select", "ldpc", "low-density-parity-check", "belief-propagation", "sum-product", "min-sum", "tanner-graph", "message-passing", "iterative-decoding", "parity-check-matrix", "systematic-encoder", "progressive-edge-growth", "qc-ldpc", "hamming-code", "girth", "log-likelihood-ratio", "shannon-limit", "capacity-approaching", "waterfall-curve", "spectral-estimation", "super-resolution", "music", "root-music", "esprit", "capon", "mvdr", "burg", "maximum-entropy", "eigenvalue", "hermitian-eigensolver", "jacobi", "rayleigh-limit", "aic-mdl", "tomography", "ct-reconstruction", "radon-transform", "fourier-slice-theorem", "filtered-back-projection", "iterative-reconstruction", "sirt", "sart", "cgls", "limited-angle", "sinogram", "shepp-logan", "epicycles", "contour-tracing", "reassignment", "synchrosqueezing", "time-frequency", "microphone", "spectrogram", "pitch-detection", "filter-design", "z-plane", "elliptic-filter", "parks-mcclellan", "dct", "phase-vocoder", "wavelet", "continuous-wavelet-transform", "discrete-wavelet-transform", "dwt", "daubechies", "symlet", "orthonormal-filter-bank", "quadrature-mirror-filter", "multiresolution-analysis", "mallat-algorithm", "perfect-reconstruction", "spectral-factorization", "vanishing-moments", "wavelet-denoising", "wavelet-shrinkage", "visushrink", "sureshrink", "bayesshrink", "soft-thresholding", "wavelet-packet", "best-basis", "coifman-wickerhauser", "time-frequency-tiling", "biorthogonal-wavelet", "cdf-9-7", "cdf-5-3", "lifting-scheme", "jpeg2000", "linear-phase", "canvas", "react"],
+  "tags": ["fourier", "fft", "dsp", "adaptive-filter", "lms", "nlms", "rls", "affine-projection", "kalman-filter", "wiener-filter", "least-squares", "system-identification", "noise-cancellation", "channel-equalization", "linear-prediction", "digital-communications", "modem", "qam", "bpsk", "qpsk", "ofdm", "awgn", "bit-error-rate", "gray-code", "root-raised-cosine", "pulse-shaping", "matched-filter", "constellation", "eye-diagram", "cyclic-prefix", "zero-forcing-equalizer", "multipath", "papr", "q-function", "forward-error-correction", "convolutional-code", "viterbi", "trellis", "soft-decision", "hard-decision", "coding-gain", "union-bound", "distance-spectrum", "free-distance", "puncturing", "add-compare-select", "ldpc", "low-density-parity-check", "belief-propagation", "sum-product", "min-sum", "tanner-graph", "message-passing", "iterative-decoding", "parity-check-matrix", "systematic-encoder", "progressive-edge-growth", "qc-ldpc", "hamming-code", "girth", "log-likelihood-ratio", "shannon-limit", "capacity-approaching", "waterfall-curve", "polar-code", "channel-polarization", "arikan", "successive-cancellation", "sc-list-decoding", "crc-aided-decoding", "frozen-bits", "gaussian-approximation", "bhattacharyya-parameter", "density-evolution", "path-metric", "5g-nr", "tal-vardy", "spectral-estimation", "super-resolution", "music", "root-music", "esprit", "capon", "mvdr", "burg", "maximum-entropy", "eigenvalue", "hermitian-eigensolver", "jacobi", "rayleigh-limit", "aic-mdl", "tomography", "ct-reconstruction", "radon-transform", "fourier-slice-theorem", "filtered-back-projection", "iterative-reconstruction", "sirt", "sart", "cgls", "limited-angle", "sinogram", "shepp-logan", "epicycles", "contour-tracing", "reassignment", "synchrosqueezing", "time-frequency", "microphone", "spectrogram", "pitch-detection", "filter-design", "z-plane", "elliptic-filter", "parks-mcclellan", "dct", "phase-vocoder", "wavelet", "continuous-wavelet-transform", "discrete-wavelet-transform", "dwt", "daubechies", "symlet", "orthonormal-filter-bank", "quadrature-mirror-filter", "multiresolution-analysis", "mallat-algorithm", "perfect-reconstruction", "spectral-factorization", "vanishing-moments", "wavelet-denoising", "wavelet-shrinkage", "visushrink", "sureshrink", "bayesshrink", "soft-thresholding", "wavelet-packet", "best-basis", "coifman-wickerhauser", "time-frequency-tiling", "biorthogonal-wavelet", "cdf-9-7", "cdf-5-3", "lifting-scheme", "jpeg2000", "linear-phase", "canvas", "react"],
   "createdAt": "2026-07-03"
 }
diff --git a/projects/spectra-fourier-7k9d/src/App.tsx b/projects/spectra-fourier-7k9d/src/App.tsx
index bddc413b..dd72fbac 100644
--- a/projects/spectra-fourier-7k9d/src/App.tsx
+++ b/projects/spectra-fourier-7k9d/src/App.tsx
@@ -18,6 +18,7 @@ import Cepstrum from './modes/Cepstrum'
 import Modem from './modes/Modem'
 import Coding from './modes/Coding'
 import LDPC from './modes/LDPC'
+import Polar from './modes/Polar'
 import About from './modes/About'
 
 const ROUTES = [
@@ -40,6 +41,7 @@ const ROUTES = [
   { id: 'modem', label: 'Modem' },
   { id: 'coding', label: 'Coding' },
   { id: 'ldpc', label: 'LDPC' },
+  { id: 'polar', label: 'Polar' },
   { id: 'about', label: 'About' },
 ]
 
@@ -109,6 +111,7 @@ export default function App() {
       {active === 'modem' && <Modem />}
       {active === 'coding' && <Coding />}
       {active === 'ldpc' && <LDPC />}
+      {active === 'polar' && <Polar />}
       {active === 'about' && <About />}
 
       <footer className="footer">
diff --git a/projects/spectra-fourier-7k9d/src/index.css b/projects/spectra-fourier-7k9d/src/index.css
index dedd477a..70476b21 100644
--- a/projects/spectra-fourier-7k9d/src/index.css
+++ b/projects/spectra-fourier-7k9d/src/index.css
@@ -879,3 +879,95 @@ code {
   border-radius: 3px;
   font-weight: 700;
 }
+
+/* ---------- Polar mode ---------- */
+.mode-note {
+  color: var(--ink-dim);
+  font-size: 12px;
+  margin: 8px 0 0;
+}
+
+.poly-table {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 10px;
+}
+
+.poly-row {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 7px 9px;
+  border: 1px solid var(--panel-border);
+  border-radius: 7px;
+  background: rgba(8, 12, 26, 0.5);
+}
+
+.poly-row.strong {
+  border-color: rgba(94, 234, 212, 0.4);
+  background: rgba(94, 234, 212, 0.06);
+}
+
+.poly-name {
+  font-size: 12px;
+  color: var(--ink-dim);
+}
+
+.poly-status {
+  font-size: 13px;
+  font-weight: 600;
+  font-family: 'JetBrains Mono', ui-monospace, monospace;
+}
+
+.poly-survivors {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 12px 14px 14px;
+}
+
+.poly-surv-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-family: 'JetBrains Mono', ui-monospace, monospace;
+  font-size: 11px;
+  color: var(--ink-dim);
+}
+
+.poly-surv-rank {
+  width: 26px;
+  color: var(--ink-faint);
+}
+
+.poly-surv-bar {
+  flex: 1;
+  height: 8px;
+  border-radius: 999px;
+  background: rgba(120, 140, 220, 0.12);
+  overflow: hidden;
+}
+
+.poly-surv-fill {
+  display: block;
+  height: 100%;
+  border-radius: 999px;
+}
+
+.poly-surv-pm {
+  width: 74px;
+  text-align: right;
+}
+
+.poly-surv-crc {
+  width: 48px;
+  text-align: right;
+  font-weight: 600;
+}
+
+.poly-surv-star {
+  width: 14px;
+  color: #fbbf24;
+  text-align: center;
+}
diff --git a/projects/spectra-fourier-7k9d/src/lib/polar.ts b/projects/spectra-fourier-7k9d/src/lib/polar.ts
new file mode 100644
index 00000000..660f444b
--- /dev/null
+++ b/projects/spectra-fourier-7k9d/src/lib/polar.ts
@@ -0,0 +1,772 @@
+// Polar codes — Arıkan's channel-polarization construction, the first family of
+// codes *proven* to achieve the symmetric capacity of any binary-input memoryless
+// channel with an explicit, low-complexity construction, and the code that carries
+// the 5G-NR control channels (PBCH / PDCCH / PUCCH). Everything here is from
+// scratch, no libraries:
+//
+//   • the polar transform x = u·F^{⊗n} (F = [[1,0],[1,1]]) as an in-place butterfly,
+//     and its exact inverse — encoding is a self-inverse GF(2) transform,
+//   • two *channel constructions* that decide which synthetic bit-channels are
+//     reliable enough to carry information (the rest are "frozen" to 0):
+//       – the Bhattacharyya-parameter recursion on the binary erasure channel
+//         (Z⁻ = 2Z−Z², Z⁺ = Z²), Arıkan's original construction, and
+//       – the Gaussian-approximation of density evolution on the BI-AWGN channel
+//         (track the mean LLR through the φ-function recursion), the construction
+//         real designs use,
+//   • the successive-cancellation (SC) decoder as the natural recursive f/g message
+//     schedule (exact box-plus *or* the min-sum hardware approximation),
+//   • the successive-cancellation *list* (SCL) decoder — Tal & Vardy's breakthrough
+//     that keeps the L most-likely paths through the same recursion and prunes by an
+//     LLR path metric — and its CRC-aided variant (CA-SCL), the 5G decoder, where an
+//     outer CRC picks the surviving path (turning polar codes from "good" to
+//     "state-of-the-art at short block lengths"),
+//   • a BPSK-over-AWGN Monte-Carlo link that measures BLER/BER waterfalls for each
+//     decoder, and the BI-AWGN channel capacity (Gauss-Legendre-free adaptive
+//     Simpson integration) as the information-theoretic yardstick.
+//
+// Index / sign conventions
+// ------------------------
+// The transform is used in *natural* (non-bit-reversed) order: u and the frozen
+// mask are indexed 0…N−1 in the order the SC recursion decodes them, and the
+// codeword x is in the order it is transmitted. Bit 0 → BPSK +1, bit 1 → −1
+// (matching the Modem / LDPC labs). A log-likelihood ratio L = log P(0)/P(1) is
+// therefore POSITIVE when the channel leans toward a 0; the channel LLR of a
+// received sample y at noise variance σ² is L = 2y/σ².
+
+import { mulberry32, gaussian, ebn0ToSigma } from './comms'
+
+export { mulberry32 }
+
+// ---------------------------------------------------------------------------
+// The polar transform (encoder)
+// ---------------------------------------------------------------------------
+
+/** log2 of a power of two (throws if `n` is not one). */
+export function log2Exact(n: number): number {
+  let k = 0
+  let m = n
+  while (m > 1) {
+    if (m & 1) throw new Error(`${n} is not a power of two`)
+    m >>= 1
+    k++
+  }
+  return k
+}
+
+/**
+ * In-place polar transform of a GF(2) vector: `x ← u·F^{⊗n}`, F = [[1,0],[1,1]].
+ * The butterfly XORs the low element of each pair with the high one, doubling the
+ * stride each stage. The transform is its own inverse (F² = I over GF(2)), so the
+ * same routine both encodes (u → x) and inverts (x → u).
+ */
+export function polarTransform(bits: Uint8Array): Uint8Array {
+  const N = bits.length
+  const out = Uint8Array.from(bits)
+  for (let len = 1; len < N; len <<= 1) {
+    for (let i = 0; i < N; i += len << 1) {
+      for (let j = 0; j < len; j++) {
+        out[i + j] ^= out[i + j + len]
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * Snapshot the polar transform after every butterfly stage (for the encoder
+ * animation). `stages[0]` is the input u; `stages[k]` is the vector after stage k;
+ * the last is the codeword x. Each stage k XORs elements `i+j` with `i+j+2^k`.
+ */
+export function transformStages(bits: Uint8Array): Uint8Array[] {
+  const N = bits.length
+  const stages: Uint8Array[] = [Uint8Array.from(bits)]
+  const cur = Uint8Array.from(bits)
+  for (let len = 1; len < N; len <<= 1) {
+    for (let i = 0; i < N; i += len << 1) {
+      for (let j = 0; j < len; j++) cur[i + j] ^= cur[i + j + len]
+    }
+    stages.push(Uint8Array.from(cur))
+  }
+  return stages
+}
+
+// ---------------------------------------------------------------------------
+// Cyclic redundancy check (for CRC-aided list decoding)
+// ---------------------------------------------------------------------------
+
+/** A CRC specified by its generator polynomial (MSB-first, implicit leading 1). */
+export interface CrcSpec {
+  id: string
+  label: string
+  width: number
+  /** polynomial without the leading x^width term, e.g. CRC-8 = x⁸+x²+x+1 → 0x07. */
+  poly: number
+}
+
+export const CRCS: CrcSpec[] = [
+  { id: 'none', label: 'None (plain SCL)', width: 0, poly: 0 },
+  { id: 'crc6', label: 'CRC-6 (5G, x⁶+x⁵+1)', width: 6, poly: 0x21 },
+  { id: 'crc8', label: 'CRC-8 (x⁸+x²+x+1)', width: 8, poly: 0x07 },
+  { id: 'crc11', label: 'CRC-11 (5G, x¹¹+x¹⁰+x⁹+x⁵+1)', width: 11, poly: 0x621 },
+]
+
+export function crcById(id: string): CrcSpec {
+  const c = CRCS.find((x) => x.id === id)
+  if (!c) throw new Error(`unknown CRC ${id}`)
+  return c
+}
+
+/** Bit-wise CRC remainder of a message (MSB-first), returned as `width` bits. */
+export function crcBits(msg: ArrayLike<number>, spec: CrcSpec): Uint8Array {
+  const w = spec.width
+  if (w === 0) return new Uint8Array(0)
+  // shift-register remainder over GF(2)
+  let reg = 0
+  const topMask = 1 << (w - 1)
+  const wMask = (1 << w) - 1
+  for (let i = 0; i < msg.length; i++) {
+    const inBit = msg[i] & 1
+    const top = (reg & topMask) !== 0 ? 1 : 0
+    reg = ((reg << 1) & wMask) | 0
+    if (top ^ inBit) reg ^= spec.poly
+  }
+  const out = new Uint8Array(w)
+  for (let i = 0; i < w; i++) out[i] = (reg >> (w - 1 - i)) & 1
+  return out
+}
+
+/** True iff the message's own trailing `width` bits equal its CRC over the head. */
+export function crcCheck(infoBits: ArrayLike<number>, spec: CrcSpec): boolean {
+  if (spec.width === 0) return true
+  const k = infoBits.length - spec.width
+  if (k < 0) return false
+  const head = new Uint8Array(k)
+  for (let i = 0; i < k; i++) head[i] = infoBits[i] & 1
+  const c = crcBits(head, spec)
+  for (let i = 0; i < spec.width; i++) if ((infoBits[k + i] & 1) !== c[i]) return false
+  return true
+}
+
+// ---------------------------------------------------------------------------
+// φ-function for the Gaussian approximation of density evolution
+// ---------------------------------------------------------------------------
+
+// φ(x) = 1 − E[tanh(u/2)] for u ~ N(x, 2x): the expected "soft bit" of a
+// consistent-Gaussian LLR of mean x. φ(0)=1, φ(∞)=0, strictly decreasing. The
+// Chung–Richardson–Urbanke closed-form approximation (2001) avoids any integral.
+export function gaPhi(x: number): number {
+  if (x <= 0) return 1
+  if (x < 10) return Math.exp(-0.4527 * Math.pow(x, 0.86) + 0.0218)
+  // large-x tail: sqrt(pi/x) e^{-x/4} (1 − 10/(7x))
+  return Math.sqrt(Math.PI / x) * Math.exp(-x / 4) * (1 - 10 / (7 * x))
+}
+
+/** Numerical inverse of φ on (0,1] by bisection (φ is monotone decreasing). */
+export function gaPhiInv(y: number): number {
+  if (y >= 1) return 0
+  if (y <= 0) return Infinity
+  let lo = 0
+  let hi = 1
+  // expand hi until φ(hi) < y
+  while (gaPhi(hi) > y) {
+    hi *= 2
+    if (hi > 1e12) return hi
+  }
+  for (let it = 0; it < 200; it++) {
+    const mid = 0.5 * (lo + hi)
+    if (gaPhi(mid) > y) lo = mid
+    else hi = mid
+  }
+  return 0.5 * (lo + hi)
+}
+
+// ---------------------------------------------------------------------------
+// Channel construction — which synthetic channels carry information
+// ---------------------------------------------------------------------------
+
+export type Construction = 'bhattacharyya' | 'ga'
+
+/**
+ * Reliability of every synthetic bit-channel, in *natural* index order (index i's
+ * value describes the channel decoded i-th by SC). Two flavours share one recursion
+ * shape — even child = the "−" (worse) transform, odd child = the "+" (better) one:
+ *
+ *   Bhattacharyya (BEC(ε)):  z⁻ = 2z − z²,  z⁺ = z²  — SMALLER z is better.
+ *   Gaussian-approx (AWGN):  φ(m⁻)=1−(1−φ(m))²,  m⁺ = 2m — LARGER m is better.
+ *
+ * Returns a `score[]` where LARGER is always more reliable (Bhattacharyya returns
+ * `1 − z` so both agree), plus the raw metric for display.
+ */
+export interface Reliability {
+  construction: Construction
+  /** larger ⇒ more reliable, for ranking. */
+  score: Float64Array
+  /** raw metric: Bhattacharyya Z (∈[0,1]) or GA mean-LLR (≥0). */
+  metric: Float64Array
+}
+
+export function bhattacharyya(n: number, epsilon: number): Reliability {
+  let z = new Float64Array([Math.min(1, Math.max(0, epsilon))])
+  for (let level = 0; level < n; level++) {
+    const next = new Float64Array(z.length * 2)
+    for (let j = 0; j < z.length; j++) {
+      const zj = z[j]
+      next[2 * j] = 2 * zj - zj * zj // − channel (worse)
+      next[2 * j + 1] = zj * zj // + channel (better)
+    }
+    z = next
+  }
+  const score = new Float64Array(z.length)
+  for (let i = 0; i < z.length; i++) score[i] = 1 - z[i]
+  return { construction: 'bhattacharyya', score, metric: z }
+}
+
+export function gaussianApprox(n: number, m0: number): Reliability {
+  let m = new Float64Array([Math.max(0, m0)])
+  for (let level = 0; level < n; level++) {
+    const next = new Float64Array(m.length * 2)
+    for (let j = 0; j < m.length; j++) {
+      const mj = m[j]
+      const phi = gaPhi(mj)
+      next[2 * j] = gaPhiInv(1 - (1 - phi) * (1 - phi)) // − channel (worse)
+      next[2 * j + 1] = 2 * mj // + channel (better)
+    }
+    m = next
+  }
+  return { construction: 'ga', score: Float64Array.from(m), metric: Float64Array.from(m) }
+}
+
+/**
+ * Build a reliability profile for block length N = 2ⁿ. `designSnrDb` is the design
+ * Eb/N0; for the BEC construction it is mapped to a matched erasure probability, and
+ * for the GA construction to the initial mean LLR m₀ = 4·R·(Eb/N0) at the target rate.
+ */
+export function reliability(
+  n: number,
+  construction: Construction,
+  designSnrDb: number,
+  rate: number,
+): Reliability {
+  const ebn0 = Math.pow(10, designSnrDb / 10)
+  if (construction === 'ga') {
+    const m0 = 4 * rate * ebn0
+    return gaussianApprox(n, m0)
+  }
+  // BEC design point: use the capacity-matched erasure prob of a BI-AWGN at the
+  // design SNR so the two constructions are broadly comparable. ε = 1 − C.
+  const esn0 = rate * ebn0
+  const eps = Math.min(0.99, Math.max(0.001, 1 - biAwgnCapacity(esn0)))
+  return bhattacharyya(n, eps)
+}
+
+// ---------------------------------------------------------------------------
+// The code (frozen set) built from a reliability profile
+// ---------------------------------------------------------------------------
+
+export interface PolarCode {
+  n: number
+  N: number
+  K: number // information bits (incl. CRC)
+  crc: CrcSpec
+  msgLen: number // K − crc.width
+  rate: number // msgLen / N (true payload rate)
+  construction: Construction
+  designSnrDb: number
+  frozen: Uint8Array // 1 = frozen (value 0), 0 = information — natural order
+  infoPos: number[] // information indices, ascending
+  frozenPos: number[]
+  rel: Reliability
+}
+
+/**
+ * Choose the K most-reliable indices as information (the rest frozen). K includes
+ * the CRC bits. Ties broken by index (deterministic).
+ */
+export function buildCode(
+  N: number,
+  K: number,
+  construction: Construction,
+  designSnrDb: number,
+  crc: CrcSpec = CRCS[0],
+): PolarCode {
+  const n = log2Exact(N)
+  const msgLen = K - crc.width
+  if (msgLen < 0) throw new Error(`K=${K} smaller than CRC width ${crc.width}`)
+  const rel = reliability(n, construction, designSnrDb, Math.max(1 / N, K / N))
+  // rank indices by reliability (descending score, index tiebreak)
+  const order = Array.from({ length: N }, (_, i) => i)
+  order.sort((a, b) => rel.score[b] - rel.score[a] || a - b)
+  const frozen = new Uint8Array(N).fill(1)
+  const infoSet = new Set<number>()
+  for (let i = 0; i < K; i++) infoSet.add(order[i])
+  const infoPos: number[] = []
+  const frozenPos: number[] = []
+  for (let i = 0; i < N; i++) {
+    if (infoSet.has(i)) {
+      frozen[i] = 0
+      infoPos.push(i)
+    } else {
+      frozenPos.push(i)
+    }
+  }
+  return {
+    n,
+    N,
+    K,
+    crc,
+    msgLen,
+    rate: msgLen / N,
+    construction,
+    designSnrDb,
+    frozen,
+    infoPos,
+    frozenPos,
+    rel,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Encoding a message
+// ---------------------------------------------------------------------------
+
+export interface Encoded {
+  u: Uint8Array // the length-N input vector (frozen=0, info=payload‖crc)
+  x: Uint8Array // the codeword u·F^{⊗n}
+  info: Uint8Array // the K info bits placed (payload then CRC)
+}
+
+/**
+ * Place a message (length `code.msgLen`) into the information positions — appending
+ * the CRC of the message when the code carries one — then apply the polar transform.
+ */
+export function encode(msg: ArrayLike<number>, code: PolarCode): Encoded {
+  if (msg.length !== code.msgLen) throw new Error(`message must be ${code.msgLen} bits`)
+  const info = new Uint8Array(code.K)
+  for (let i = 0; i < code.msgLen; i++) info[i] = msg[i] & 1
+  if (code.crc.width > 0) {
+    const c = crcBits(info.subarray(0, code.msgLen), code.crc)
+    for (let i = 0; i < code.crc.width; i++) info[code.msgLen + i] = c[i]
+  }
+  const u = new Uint8Array(code.N)
+  for (let i = 0; i < code.infoPos.length; i++) u[code.infoPos[i]] = info[i]
+  const x = polarTransform(u)
+  return { u, x, info }
+}
+
+/** Extract the K info bits (payload‖CRC order) from a decoded input vector. */
+export function extractInfo(u: Uint8Array, code: PolarCode): Uint8Array {
+  const info = new Uint8Array(code.K)
+  for (let i = 0; i < code.infoPos.length; i++) info[i] = u[code.infoPos[i]]
+  return info
+}
+
+// ---------------------------------------------------------------------------
+// LLR node functions
+// ---------------------------------------------------------------------------
+
+/** The check-node "box-plus": exact log-domain form, numerically stable. */
+export function boxPlusExact(a: number, b: number): number {
+  const s = (a < 0 ? -1 : 1) * (b < 0 ? -1 : 1)
+  const m = Math.min(Math.abs(a), Math.abs(b))
+  return s * m + Math.log1p(Math.exp(-Math.abs(a + b))) - Math.log1p(Math.exp(-Math.abs(a - b)))
+}
+
+/** The min-sum approximation (the hardware form): sign·sign·min|·|. */
+export function boxPlusMinSum(a: number, b: number): number {
+  const s = (a < 0 ? -1 : 1) * (b < 0 ? -1 : 1)
+  return s * Math.min(Math.abs(a), Math.abs(b))
+}
+
+/** g-node: combine the two half-LLRs with the decided partial-sum bit u. */
+function gNode(a: number, b: number, u: number): number {
+  return b + (1 - 2 * u) * a
+}
+
+/** Numerically stable softplus ln(1+eᶻ). */
+function softplus(z: number): number {
+  return Math.max(z, 0) + Math.log1p(Math.exp(-Math.abs(z)))
+}
+
+// ---------------------------------------------------------------------------
+// Successive-cancellation (SC) decoder — the recursive f/g schedule
+// ---------------------------------------------------------------------------
+
+export interface ScResult {
+  u: Uint8Array // decoded input vector (frozen forced to 0)
+  info: Uint8Array // extracted K info bits
+  ok: boolean // CRC check (always true for a CRC-free code)
+}
+
+/**
+ * Recursive SC decode. Returns the decoded vector `u`; internally each recursion
+ * returns its subtree's re-encoded partial sums for the parent's g-node.
+ */
+export function decodeSC(llr: Float64Array, code: PolarCode, exact = true): ScResult {
+  const u = new Uint8Array(code.N)
+  const box = exact ? boxPlusExact : boxPlusMinSum
+  const rec = (r: Float64Array, base: number): Uint8Array => {
+    const len = r.length
+    if (len === 1) {
+      const bit = code.frozen[base] ? 0 : r[0] < 0 ? 1 : 0
+      u[base] = bit
+      return Uint8Array.of(bit)
+    }
+    const half = len >> 1
+    const ll = new Float64Array(half)
+    for (let i = 0; i < half; i++) ll[i] = box(r[i], r[i + half])
+    const xl = rec(ll, base)
+    const rr = new Float64Array(half)
+    for (let i = 0; i < half; i++) rr[i] = gNode(r[i], r[i + half], xl[i])
+    const xr = rec(rr, base + half)
+    const x = new Uint8Array(len)
+    for (let i = 0; i < half; i++) {
+      x[i] = xl[i] ^ xr[i]
+      x[i + half] = xr[i]
+    }
+    return x
+  }
+  rec(Float64Array.from(llr), 0)
+  const info = extractInfo(u, code)
+  return { u, info, ok: crcCheck(info, code.crc) }
+}
+
+// ---------------------------------------------------------------------------
+// Successive-cancellation list (SCL) decoder — Tal & Vardy
+// ---------------------------------------------------------------------------
+
+export interface SclResult {
+  u: Uint8Array // chosen path's decoded input vector
+  info: Uint8Array // chosen path's K info bits
+  ok: boolean // chosen path passed CRC
+  listSize: number
+  /** every survivor's (pm, info, crcOk), best metric first — for the UI list view. */
+  survivors: { pm: number; info: Uint8Array; crcOk: boolean }[]
+  /** the pm-best path (ignoring CRC), to contrast with the CRC-selected one. */
+  bestByMetric: Uint8Array
+}
+
+/**
+ * SCL decode keeping the L lowest-metric paths. Each information bit forks every
+ * surviving path into its 0- and 1-continuation; the paths are ranked by the LLR
+ * path metric  PM ← PM + ln(1 + e^{−(1−2û)·L})  and pruned back to L. With a CRC the
+ * returned path is the lowest-metric survivor whose info bits satisfy the CRC.
+ *
+ * Implemented as a recursion that carries, for every live path, the LLRs of the
+ * current sub-block; a fork returns a `survivor[]` map (new-path → parent) that each
+ * frame applies to remap its own state, so the whole list shares one f/g schedule.
+ */
+export function decodeSCL(
+  llr: Float64Array,
+  code: PolarCode,
+  L: number,
+  exact = true,
+): SclResult {
+  const box = exact ? boxPlusExact : boxPlusMinSum
+  // Live path state: path metric and the decoded input vector so far.
+  let pm: number[] = [0]
+  let uMat: Uint8Array[] = [new Uint8Array(code.N)]
+
+  const remapBits = (arr: Uint8Array[], survivor: number[]): Uint8Array[] =>
+    survivor.map((p) => Uint8Array.from(arr[p]))
+  const remapLlr = (arr: Float64Array[], survivor: number[]): Float64Array[] =>
+    survivor.map((p) => Float64Array.from(arr[p]))
+
+  // Returns { out: per-path re-encoded partial sums, survivor: newPath→oldPath }.
+  const rec = (
+    llrs: Float64Array[],
+    base: number,
+  ): { out: Uint8Array[]; survivor: number[] } => {
+    const P = llrs.length
+    const len = llrs[0].length
+    if (len === 1) {
+      if (code.frozen[base]) {
+        const out: Uint8Array[] = []
+        for (let p = 0; p < P; p++) {
+          pm[p] += softplus(-llrs[p][0]) // forced bit 0
+          uMat[p][base] = 0
+          out.push(Uint8Array.of(0))
+        }
+        return { out, survivor: Array.from({ length: P }, (_, p) => p) }
+      }
+      // fork every path into bit 0 / bit 1
+      const cand: { parent: number; bit: number; pm: number }[] = []
+      for (let p = 0; p < P; p++) {
+        cand.push({ parent: p, bit: 0, pm: pm[p] + softplus(-llrs[p][0]) })
+        cand.push({ parent: p, bit: 1, pm: pm[p] + softplus(llrs[p][0]) })
+      }
+      cand.sort((a, b) => a.pm - b.pm)
+      const keep = cand.slice(0, Math.min(L, cand.length))
+      const survivor = keep.map((c) => c.parent)
+      const newPm = keep.map((c) => c.pm)
+      const newU = keep.map((c) => {
+        const v = Uint8Array.from(uMat[c.parent])
+        v[base] = c.bit
+        return v
+      })
+      pm = newPm
+      uMat = newU
+      const out = keep.map((c) => Uint8Array.of(c.bit))
+      return { out, survivor }
+    }
+    const half = len >> 1
+    // left LLRs via f
+    const llrL = llrs.map((r) => {
+      const o = new Float64Array(half)
+      for (let i = 0; i < half; i++) o[i] = box(r[i], r[i + half])
+      return o
+    })
+    const r1 = rec(llrL, base)
+    // remap this frame's parent LLRs onto the post-left path set
+    const parent = remapLlr(llrs, r1.survivor)
+    let xL = r1.out // already in the post-left path set
+    // right LLRs via g, using the left subtree's partial sums
+    const llrR = parent.map((r, idx) => {
+      const o = new Float64Array(half)
+      for (let i = 0; i < half; i++) o[i] = gNode(r[i], r[i + half], xL[idx][i])
+      return o
+    })
+    const r2 = rec(llrR, base + half)
+    // remap left outputs onto the post-right path set, then combine
+    xL = remapBits(xL, r2.survivor)
+    const xR = r2.out
+    const out = xR.map((xr, idx) => {
+      const x = new Uint8Array(len)
+      const xl = xL[idx]
+      for (let i = 0; i < half; i++) {
+        x[i] = xl[i] ^ xr[i]
+        x[i + half] = xr[i]
+      }
+      return x
+    })
+    // compose survivor maps: newPath → (post-left) → (pre-call)
+    const survivor = r2.survivor.map((k) => r1.survivor[k])
+    return { out, survivor }
+  }
+
+  rec([Float64Array.from(llr)], 0)
+
+  // rank survivors, apply CRC selection
+  const idx = Array.from({ length: pm.length }, (_, i) => i).sort((a, b) => pm[a] - pm[b])
+  const survivors = idx.map((i) => {
+    const info = extractInfo(uMat[i], code)
+    return { pm: pm[i], info, crcOk: crcCheck(info, code.crc) }
+  })
+  const bestByMetric = Uint8Array.from(uMat[idx[0]])
+  // CRC-aided pick: first (lowest-pm) survivor that checks; else the pm-best.
+  let chosen = idx[0]
+  if (code.crc.width > 0) {
+    const good = idx.find((i) => crcCheck(extractInfo(uMat[i], code), code.crc))
+    if (good !== undefined) chosen = good
+  }
+  const u = Uint8Array.from(uMat[chosen])
+  const info = extractInfo(u, code)
+  return {
+    u,
+    info,
+    ok: crcCheck(info, code.crc),
+    listSize: pm.length,
+    survivors,
+    bestByMetric,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// BI-AWGN channel capacity (the yardstick)
+// ---------------------------------------------------------------------------
+
+/**
+ * Capacity of the binary-input AWGN channel at Es/N0 (linear), Es = 1, in
+ * bits/channel-use. C = 1 − E_t[ log2(1 + e^{−2(1+σt)/σ²}) ], t ~ N(0,1), computed by
+ * composite Simpson over t ∈ [−8, 8].
+ */
+export function biAwgnCapacity(esn0Lin: number): number {
+  if (esn0Lin <= 0) return 0
+  const sigma2 = 1 / (2 * esn0Lin)
+  const sigma = Math.sqrt(sigma2)
+  const f = (t: number): number => {
+    const g = Math.exp(-0.5 * t * t) / Math.sqrt(2 * Math.PI) // N(0,1) pdf
+    const arg = (-2 * (1 + sigma * t)) / sigma2
+    return g * Math.log2(1 + Math.exp(arg))
+  }
+  const a = -8
+  const b = 8
+  const m = 2000 // even
+  const h = (b - a) / m
+  let s = f(a) + f(b)
+  for (let i = 1; i < m; i++) s += (i % 2 ? 4 : 2) * f(a + i * h)
+  const integral = (h / 3) * s
+  return Math.min(1, Math.max(0, 1 - integral))
+}
+
+/**
+ * Symmetric capacity of a bit-channel whose LLR is a consistent Gaussian of mean m
+ * (variance 2m): C = 1 − E[log2(1+e^{−L})], L ~ N(m, 2m), by composite Simpson. Maps
+ * the Gaussian-approximation reliability onto the same [0,1] axis as the BEC's 1−Z.
+ */
+export function capacityFromMeanLLR(m: number): number {
+  if (m <= 0) return 0
+  const sd = Math.sqrt(2 * m)
+  const f = (t: number): number => {
+    const g = Math.exp(-0.5 * t * t) / Math.sqrt(2 * Math.PI)
+    return g * Math.log2(1 + Math.exp(-(m + sd * t)))
+  }
+  const a = -8
+  const b = 8
+  const M = 800
+  const h = (b - a) / M
+  let s = f(a) + f(b)
+  for (let i = 1; i < M; i++) s += (i % 2 ? 4 : 2) * f(a + i * h)
+  return Math.min(1, Math.max(0, 1 - (h / 3) * s))
+}
+
+/** Per-channel symmetric capacity in [0,1] from a reliability profile. */
+export function channelCapacities(rel: Reliability): Float64Array {
+  const c = new Float64Array(rel.metric.length)
+  if (rel.construction === 'bhattacharyya') {
+    for (let i = 0; i < c.length; i++) c[i] = 1 - rel.metric[i]
+  } else {
+    for (let i = 0; i < c.length; i++) c[i] = capacityFromMeanLLR(rel.metric[i])
+  }
+  return c
+}
+
+/** The Eb/N0 (dB) Shannon limit for a binary-input code of the given rate. */
+export function biAwgnLimitDb(rate: number): number {
+  // find Eb/N0 s.t. C(rate·Eb/N0) = rate  (bisection on Es/N0)
+  let lo = 1e-4
+  let hi = 1e4
+  for (let it = 0; it < 200; it++) {
+    const mid = Math.sqrt(lo * hi)
+    if (biAwgnCapacity(mid) < rate) lo = mid
+    else hi = mid
+  }
+  const esn0 = Math.sqrt(lo * hi)
+  const ebn0 = esn0 / rate
+  return 10 * Math.log10(ebn0)
+}
+
+// ---------------------------------------------------------------------------
+// Monte-Carlo link (BPSK over AWGN)
+// ---------------------------------------------------------------------------
+
+export type DecoderKind = 'sc' | 'scl' | 'ca-scl'
+
+export interface DecoderSpec {
+  id: string
+  label: string
+  kind: DecoderKind
+  L: number
+}
+
+/**
+ * One decode of a random message at a given Eb/N0. Returns bit/block error against
+ * the transmitted message payload (CRC bits excluded from the payload BER).
+ */
+export function simulateBlock(
+  code: PolarCode,
+  ebn0Db: number,
+  decoder: { kind: DecoderKind; L: number },
+  exact: boolean,
+  rng: () => number,
+): { bitErrors: number; blockError: boolean } {
+  const msg = new Uint8Array(code.msgLen)
+  for (let i = 0; i < code.msgLen; i++) msg[i] = rng() < 0.5 ? 0 : 1
+  const { x } = encode(msg, code)
+  // BPSK: bit 0 → +1, bit 1 → −1. Rate for Eb/N0 uses the true payload rate.
+  const R = Math.max(1e-6, code.rate)
+  const sigma = ebn0ToSigma(ebn0Db + 10 * Math.log10(R), 1) // Es/N0 = R·Eb/N0
+  const N = code.N
+  const llr = new Float64Array(N)
+  const inv = 1 / (sigma * sigma)
+  for (let i = 0; i < N; i++) {
+    const s = x[i] === 0 ? 1 : -1
+    const y = s + sigma * gaussian(rng)
+    llr[i] = 2 * y * inv // LLR = 2y/σ²
+  }
+  let info: Uint8Array
+  if (decoder.kind === 'sc') info = decodeSC(llr, code, exact).info
+  else info = decodeSCL(llr, code, decoder.L, exact).info
+  let bitErrors = 0
+  for (let i = 0; i < code.msgLen; i++) if (info[i] !== msg[i]) bitErrors++
+  return { bitErrors, blockError: bitErrors > 0 }
+}
+
+export interface WaterfallPoint {
+  ebn0Db: number
+  blocks: number
+  blockErrors: number
+  bitErrors: number
+  bler: number
+  ber: number
+}
+
+export interface WaterfallBudget {
+  minBlocks: number
+  maxBlocks: number
+  targetBlockErrors: number
+  seed: number
+}
+
+/**
+ * Sweep Eb/N0, accumulating blocks until either the target number of block errors or
+ * the block cap is reached (adaptive so high-SNR points don't run forever).
+ */
+export function waterfall(
+  code: PolarCode,
+  decoder: { kind: DecoderKind; L: number },
+  ebn0List: number[],
+  exact: boolean,
+  budget: WaterfallBudget,
+): WaterfallPoint[] {
+  return ebn0List.map((ebn0Db, pi) => {
+    const rng = mulberry32(budget.seed + pi * 7919 + 1)
+    let blocks = 0
+    let blockErrors = 0
+    let bitErrors = 0
+    while (blocks < budget.maxBlocks) {
+      const r = simulateBlock(code, ebn0Db, decoder, exact, rng)
+      blocks++
+      if (r.blockError) blockErrors++
+      bitErrors += r.bitErrors
+      if (blocks >= budget.minBlocks && blockErrors >= budget.targetBlockErrors) break
+    }
+    return {
+      ebn0Db,
+      blocks,
+      blockErrors,
+      bitErrors,
+      bler: blockErrors / blocks,
+      ber: bitErrors / (blocks * code.msgLen),
+    }
+  })
+}
+
+/** Uncoded BPSK BER at Eb/N0 (dB) — the reference floor. */
+export function uncodedBer(ebn0Db: number): number {
+  const gamma = Math.pow(10, ebn0Db / 10)
+  // Q(√(2·Eb/N0)) via erfc
+  return 0.5 * erfc(Math.sqrt(gamma))
+}
+
+function erfc(x: number): number {
+  const z = Math.abs(x)
+  const t = 1 / (1 + 0.5 * z)
+  const ans =
+    t *
+    Math.exp(
+      -z * z -
+        1.26551223 +
+        t *
+          (1.00002368 +
+            t *
+              (0.37409196 +
+                t *
+                  (0.09678418 +
+                    t *
+                      (-0.18628806 +
+                        t *
+                          (0.27886807 +
+                            t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277)))))))),
+    )
+  return x >= 0 ? ans : 2 - ans
+}
diff --git a/projects/spectra-fourier-7k9d/src/lib/selftest.ts b/projects/spectra-fourier-7k9d/src/lib/selftest.ts
index d154028d..8d72145e 100644
--- a/projects/spectra-fourier-7k9d/src/lib/selftest.ts
+++ b/projects/spectra-fourier-7k9d/src/lib/selftest.ts
@@ -152,6 +152,22 @@ import {
   shannonLimitDb as ldpcShannonLimit,
   mulberry32 as ldpcRng,
 } from './ldpc'
+import {
+  polarTransform,
+  buildCode as polarBuildCode,
+  encode as polarEncode,
+  decodeSC as polarDecodeSC,
+  decodeSCL as polarDecodeSCL,
+  crcBits as polarCrcBits,
+  crcCheck as polarCrcCheck,
+  crcById as polarCrcById,
+  waterfall as polarWaterfall,
+  biAwgnCapacity,
+  biAwgnLimitDb,
+  gaPhi,
+  gaPhiInv,
+  mulberry32 as polarRng,
+} from './polar'
 
 function approxEqual(a: number, b: number, eps = 1e-9): boolean {
   return Math.abs(a - b) <= eps
@@ -2172,5 +2188,110 @@ export function runSelfTests(): { passed: number; failed: number; messages: stri
     check('LDPC: sum-product ≤ min-sum BER, PEG girth ≥ 6, Shannon(½)≈0 dB', gainOk && girthOk && shannonOk)
   }
 
+  // ----- Polar codes -----
+
+  // 78. The polar transform u·F^{⊗n} is its own inverse over GF(2).
+  {
+    const rng = polarRng(3)
+    let ok = true
+    for (let t = 0; t < 20; t++) {
+      const N = 32
+      const u = new Uint8Array(N)
+      for (let i = 0; i < N; i++) u[i] = rng() < 0.5 ? 0 : 1
+      const back = polarTransform(polarTransform(u))
+      for (let i = 0; i < N; i++) if (back[i] !== u[i]) ok = false
+    }
+    check('Polar: transform is an involution (encoder⁻¹ = encoder)', ok)
+  }
+
+  // 79. Noiseless SC decode recovers the message exactly for any frozen set.
+  {
+    const code = polarBuildCode(64, 32, 'ga', 2, polarCrcById('none'))
+    const rng = polarRng(7)
+    let ok = true
+    for (let t = 0; t < 25; t++) {
+      const msg = new Uint8Array(code.msgLen)
+      for (let i = 0; i < code.msgLen; i++) msg[i] = rng() < 0.5 ? 0 : 1
+      const { x } = polarEncode(msg, code)
+      const llr = new Float64Array(code.N)
+      for (let i = 0; i < code.N; i++) llr[i] = x[i] === 0 ? 8 : -8
+      const info = polarDecodeSC(llr, code, true).info
+      for (let i = 0; i < code.msgLen; i++) if (info[i] !== msg[i]) ok = false
+    }
+    check('Polar: SC recovers the message on a clean channel', ok)
+  }
+
+  // 80. SCL with L=1 is exactly SC (same schedule, no list) — the correctness anchor.
+  {
+    const code = polarBuildCode(128, 64, 'ga', 2.5, polarCrcById('none'))
+    const rng = polarRng(99)
+    let ok = true
+    for (let t = 0; t < 15; t++) {
+      const msg = new Uint8Array(code.msgLen)
+      for (let i = 0; i < code.msgLen; i++) msg[i] = rng() < 0.5 ? 0 : 1
+      const { x } = polarEncode(msg, code)
+      const sigma = 0.9
+      const llr = new Float64Array(code.N)
+      for (let i = 0; i < code.N; i++) {
+        const s = x[i] === 0 ? 1 : -1
+        const g = Math.sqrt(-2 * Math.log(rng())) * Math.cos(2 * Math.PI * rng())
+        llr[i] = (2 * (s + sigma * g)) / (sigma * sigma)
+      }
+      const a = polarDecodeSC(llr, code, true).u
+      const b = polarDecodeSCL(llr, code, 1, true).u
+      for (let i = 0; i < code.N; i++) if (a[i] !== b[i]) ok = false
+    }
+    check('Polar: SCL(L=1) ≡ SC bit-for-bit', ok)
+  }
+
+  // 81. The CRC verifies its own message and catches a single flipped bit.
+  {
+    const spec = polarCrcById('crc8')
+    const msg = new Uint8Array([1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0])
+    const c = polarCrcBits(msg, spec)
+    const full = new Uint8Array([...msg, ...c])
+    const bad = Uint8Array.from(full)
+    bad[4] ^= 1
+    check('Polar: CRC-8 self-verifies and catches a flip', polarCrcCheck(full, spec) && !polarCrcCheck(bad, spec))
+  }
+
+  // 82. The headline result: growing the list, then adding a CRC, strictly lowers the
+  //     block-error rate at a fixed operating point (SC ≥ SCL(8) ≥ CA-SCL(8)).
+  {
+    const snr = 2.0
+    const codePlain = polarBuildCode(128, 64, 'ga', snr, polarCrcById('none'))
+    const codeCrc = polarBuildCode(128, 64, 'ga', snr, polarCrcById('crc8'))
+    const budget = { minBlocks: 250, maxBlocks: 1400, targetBlockErrors: 50, seed: 3 }
+    const sc = polarWaterfall(codePlain, { kind: 'sc', L: 1 }, [snr], true, budget)[0]
+    const scl = polarWaterfall(codePlain, { kind: 'scl', L: 8 }, [snr], true, budget)[0]
+    const cascl = polarWaterfall(codeCrc, { kind: 'ca-scl', L: 8 }, [snr], true, budget)[0]
+    check(
+      'Polar: BLER  SC ≥ SCL(8) ≥ CA-SCL(8)  at 2 dB',
+      scl.bler <= sc.bler + 1e-9 && cascl.bler <= scl.bler + 1e-9,
+    )
+  }
+
+  // 83. The waterfall falls: block-error rate is monotone non-increasing in SNR.
+  {
+    const code = polarBuildCode(128, 64, 'ga', 2, polarCrcById('crc8'))
+    const budget = { minBlocks: 180, maxBlocks: 1000, targetBlockErrors: 40, seed: 5 }
+    const pts = polarWaterfall(code, { kind: 'ca-scl', L: 8 }, [1, 2, 3], true, budget)
+    check('Polar: CA-SCL BLER decreases with SNR', pts[0].bler >= pts[1].bler && pts[1].bler >= pts[2].bler)
+  }
+
+  // 84. BI-AWGN capacity is sane and the rate-½ binary Shannon limit is ≈ 0.19 dB.
+  {
+    const capOk = biAwgnCapacity(0.01) < 0.05 && biAwgnCapacity(100) > 0.99
+    const limOk = Math.abs(biAwgnLimitDb(0.5) - 0.187) < 0.1
+    check('Polar: BI-AWGN capacity + rate-½ Shannon limit ≈ 0.19 dB', capOk && limOk)
+  }
+
+  // 85. The Gaussian-approximation φ is a decreasing bijection: φ(0)=1 and φ⁻¹∘φ = id.
+  {
+    const monotone = gaPhi(0) > 0.99 && gaPhi(1) > gaPhi(5) && gaPhi(5) > gaPhi(20)
+    const inverseOk = Math.abs(gaPhiInv(gaPhi(3.7)) - 3.7) < 1e-3
+    check('Polar: GA φ decreasing with an accurate numerical inverse', monotone && inverseOk)
+  }
+
   return { passed, failed, messages }
 }
diff --git a/projects/spectra-fourier-7k9d/src/modes/Polar.tsx b/projects/spectra-fourier-7k9d/src/modes/Polar.tsx
new file mode 100644
index 00000000..24fd5065
--- /dev/null
+++ b/projects/spectra-fourier-7k9d/src/modes/Polar.tsx
@@ -0,0 +1,972 @@
+import { useEffect, useMemo, useState } from 'react'
+import { CanvasCard } from '../components/CanvasCard'
+import { Panel, Field, Slider, Select, Segmented, Readout, Button, Toggle } from '../components/Controls'
+import { useDprCanvas, prepareContext } from '../hooks/useDprCanvas'
+import { fillPlotBg, axisLabel } from '../lib/draw'
+import type { Rect } from '../lib/draw'
+import { readHashParams, shareLink, readNum, readStr, readBool } from '../lib/urlState'
+import {
+  buildCode,
+  encode,
+  decodeSC,
+  decodeSCL,
+  transformStages,
+  channelCapacities,
+  biAwgnLimitDb,
+  waterfall,
+  uncodedBer,
+  crcById,
+  CRCS,
+  mulberry32,
+  type Construction,
+  type PolarCode,
+  type WaterfallPoint,
+} from '../lib/polar'
+
+const TEAL = '#5eead4'
+const BLUE = '#38bdf8'
+const ROSE = '#fb7185'
+const AMBER = '#fbbf24'
+const INK = 'rgba(226,232,240,0.85)'
+const DIM = 'rgba(148,163,204,0.45)'
+
+const CONSTRUCTIONS: { id: Construction; label: string }[] = [
+  { id: 'ga', label: 'Gaussian approx (AWGN)' },
+  { id: 'bhattacharyya', label: 'Bhattacharyya (BEC)' },
+]
+
+const CRC_OPTIONS = CRCS.map((c) => ({ id: c.id, label: c.label }))
+
+// A random payload deterministically derived from a code + seed.
+function randomPayload(code: PolarCode, seed: number): Uint8Array {
+  const rng = mulberry32(seed * 2654435761)
+  const m = new Uint8Array(code.msgLen)
+  for (let i = 0; i < code.msgLen; i++) m[i] = rng() < 0.5 ? 0 : 1
+  return m
+}
+
+// ===========================================================================
+// Tab 1 — Polarization: the synthetic channels split toward 0 and 1
+// ===========================================================================
+
+function PolarizeTab() {
+  const sp = useMemo(() => readHashParams(), [])
+  const [n, setN] = useState(() => readNum(sp, 'pn', 8))
+  const [rate, setRate] = useState(() => readNum(sp, 'prate', 0.5))
+  const [construction, setConstruction] = useState<Construction>(() =>
+    readStr(sp, 'pcon', 'ga', ['ga', 'bhattacharyya'] as const),
+  )
+  const [designSnr, setDesignSnr] = useState(() => readNum(sp, 'pdes', 2))
+  const [copied, setCopied] = useState(false)
+
+  const N = 1 << n
+  const K = Math.max(1, Math.min(N - 1, Math.round(rate * N)))
+  const code = useMemo(
+    () => buildCode(N, K, construction, designSnr, crcById('none')),
+    [N, K, construction, designSnr],
+  )
+  const caps = useMemo(() => channelCapacities(code.rel), [code])
+  const sortedCaps = useMemo(() => Float64Array.from(caps).sort((a, b) => b - a), [caps])
+
+  const sumCap = useMemo(() => caps.reduce((s, c) => s + c, 0), [caps])
+  const polarized = useMemo(() => {
+    let extreme = 0
+    for (const c of caps) if (c < 0.05 || c > 0.95) extreme++
+    return extreme / caps.length
+  }, [caps])
+  const shannon = biAwgnLimitDb(code.rate)
+
+  // Canvas 1 — the polarization staircase (capacity of each channel, sorted).
+  const { ref: stairRef, size: stairSize } = useDprCanvas()
+  useEffect(() => {
+    const ctx = prepareContext(stairRef.current, stairSize)
+    if (!ctx) return
+    const { width: w, height: h } = stairSize
+    fillPlotBg(ctx, { x: 0, y: 0, w, h })
+    const pad = { l: 42, r: 12, t: 14, b: 26 }
+    const r: Rect = { x: pad.l, y: pad.t, w: w - pad.l - pad.r, h: h - pad.t - pad.b }
+    ctx.strokeStyle = 'rgba(120,140,220,0.12)'
+    ctx.lineWidth = 1
+    for (let g = 0; g <= 4; g++) {
+      const y = r.y + (g / 4) * r.h
+      ctx.beginPath()
+      ctx.moveTo(r.x, y)
+      ctx.lineTo(r.x + r.w, y)
+      ctx.stroke()
+      axisLabel(ctx, (1 - g / 4).toFixed(2), r.x - 6, y + 3, 'right')
+    }
+    // bars, sorted descending; the first K are "information" channels.
+    const bw = r.w / N
+    for (let i = 0; i < N; i++) {
+      const c = sortedCaps[i]
+      const x = r.x + i * bw
+      const bh = c * r.h
+      ctx.fillStyle = i < K ? 'rgba(94,234,212,0.55)' : 'rgba(148,163,204,0.28)'
+      ctx.fillRect(x, r.y + r.h - bh, Math.max(1, bw - 0.5), bh)
+    }
+    // K cutoff line
+    const cx = r.x + K * bw
+    ctx.strokeStyle = AMBER
+    ctx.setLineDash([4, 4])
+    ctx.lineWidth = 1.4
+    ctx.beginPath()
+    ctx.moveTo(cx, r.y)
+    ctx.lineTo(cx, r.y + r.h)
+    ctx.stroke()
+    ctx.setLineDash([])
+    axisLabel(ctx, `K=${K} info`, cx - 4, r.y + 12, 'right')
+    axisLabel(ctx, 'frozen →', cx + 4, r.y + 12, 'left')
+    axisLabel(ctx, 'capacity', r.x, r.y - 2, 'left')
+    axisLabel(ctx, 'channels sorted by reliability →', r.x + r.w, r.y + r.h + 15, 'right')
+  }, [stairRef, stairSize, sortedCaps, N, K])
+
+  // Canvas 2 — the natural-order map: every synthetic channel in transmit order,
+  // colored by capacity, frozen vs information marked. Reveals the fractal set.
+  const { ref: mapRef, size: mapSize } = useDprCanvas()
+  useEffect(() => {
+    const ctx = prepareContext(mapRef.current, mapSize)
+    if (!ctx) return
+    const { width: w, height: h } = mapSize
+    fillPlotBg(ctx, { x: 0, y: 0, w, h })
+    const pad = { l: 10, r: 10, t: 16, b: 18 }
+    const cols = Math.min(N, 64)
+    const rows = Math.ceil(N / cols)
+    const cw = (w - pad.l - pad.r) / cols
+    const chh = (h - pad.t - pad.b) / rows
+    for (let i = 0; i < N; i++) {
+      const col = i % cols
+      const row = Math.floor(i / cols)
+      const x = pad.l + col * cw
+      const y = pad.t + row * chh
+      const c = caps[i]
+      const info = code.frozen[i] === 0
+      // teal ramp for capacity, dim if frozen
+      const g = Math.round(60 + c * 180)
+      ctx.fillStyle = info
+        ? `rgba(94,${g + 20},212,0.9)`
+        : `rgba(${70 + Math.round(c * 60)},${80 + Math.round(c * 40)},120,0.5)`
+      ctx.fillRect(x + 0.5, y + 0.5, cw - 1, chh - 1)
+      if (info) {
+        ctx.strokeStyle = 'rgba(94,234,212,0.9)'
+        ctx.lineWidth = 1
+        ctx.strokeRect(x + 0.75, y + 0.75, cw - 1.5, chh - 1.5)
+      }
+    }
+    axisLabel(ctx, 'transmit order (row-major) — bright = information channel', pad.l, 12, 'left')
+  }, [mapRef, mapSize, caps, code, N])
+
+  const onShare = () => {
+    shareLink('polar', {
+      tab: 'polarize',
+      pn: n,
+      prate: rate,
+      pcon: construction,
+      pdes: designSnr,
+    }).then((ok) => {
+      if (ok) {
+        setCopied(true)
+        setTimeout(() => setCopied(false), 1400)
+      }
+    })
+  }
+
+  return (
+    <div className="mode">
+      <div className="mode-side">
+        <Panel title="Block & construction">
+          <Field label="Block length N" value={`2^${n} = ${N}`}>
+            <Slider min={3} max={10} step={1} value={n} onChange={setN} />
+          </Field>
+          <Field label="Code rate K/N" value={`${rate.toFixed(2)} → K=${K}`}>
+            <Slider min={0.1} max={0.9} step={0.05} value={rate} onChange={setRate} />
+          </Field>
+          <Field label="Construction">
+            <Select value={construction} options={CONSTRUCTIONS} onChange={setConstruction} />
+          </Field>
+          <Field label="Design Eb/N0" value={`${designSnr.toFixed(1)} dB`}>
+            <Slider min={-2} max={6} step={0.5} value={designSnr} onChange={setDesignSnr} />
+          </Field>
+          <Button onClick={onShare} variant="ghost">
+            {copied ? 'link copied ✓' : 'share this view'}
+          </Button>
+        </Panel>
+        <Panel title="This code">
+          <Readout
+            items={[
+              { label: 'N', value: `${N}` },
+              { label: 'K', value: `${K}` },
+              { label: 'rate', value: code.rate.toFixed(3) },
+              { label: 'polarized', value: `${(polarized * 100).toFixed(0)}%` },
+              { label: 'Σ capacity', value: sumCap.toFixed(1) },
+              { label: 'Shannon', value: `${shannon.toFixed(2)} dB` },
+            ]}
+          />
+        </Panel>
+      </div>
+      <div className="mode-main">
+        <p className="mode-intro">
+          Arıkan's insight: recursively combine and split N copies of a channel and the{' '}
+          <em>synthetic</em> bit-channels polarize — each races toward a perfect (capacity 1) or
+          useless (capacity 0) channel. Send information only on the good ones and freeze the rest to
+          0. The total capacity is conserved (Σ capacity ≈ N·C), so the fraction of good channels →
+          the channel capacity: <strong>this is how you reach Shannon with an explicit code.</strong>
+        </p>
+        <CanvasCard
+          title="Polarization staircase — synthetic-channel capacity, sorted"
+          note={`${polarized > 0 ? (polarized * 100).toFixed(0) : 0}% of channels are near 0 or 1`}
+          height={300}
+        >
+          <canvas ref={stairRef} />
+        </CanvasCard>
+        <CanvasCard
+          title="The frozen set — every channel in transmit order"
+          note="bright cells carry information; the pattern is self-similar"
+          height={220}
+        >
+          <canvas ref={mapRef} />
+        </CanvasCard>
+      </div>
+    </div>
+  )
+}
+
+// ===========================================================================
+// Tab 2 — Encoder: the F^{⊗n} butterfly network
+// ===========================================================================
+
+function EncoderTab() {
+  const sp = useMemo(() => readHashParams(), [])
+  const [n, setN] = useState(() => readNum(sp, 'en', 4))
+  const [rate, setRate] = useState(() => readNum(sp, 'erate', 0.5))
+  const [construction, setConstruction] = useState<Construction>(() =>
+    readStr(sp, 'econ', 'ga', ['ga', 'bhattacharyya'] as const),
+  )
+  const [designSnr, setDesignSnr] = useState(() => readNum(sp, 'edes', 2))
+  const [seed, setSeed] = useState(1)
+
+  const N = 1 << n
+  const K = Math.max(1, Math.min(N - 1, Math.round(rate * N)))
+  const code = useMemo(
+    () => buildCode(N, K, construction, designSnr, crcById('none')),
+    [N, K, construction, designSnr],
+  )
+  const enc = useMemo(() => encode(randomPayload(code, seed), code), [code, seed])
+  const stages = useMemo(() => transformStages(enc.u), [enc])
+
+  const { ref: graphRef, size: graphSize } = useDprCanvas()
+  useEffect(() => {
+    const ctx = prepareContext(graphRef.current, graphSize)
+    if (!ctx) return
+    const { width: w, height: h } = graphSize
+    fillPlotBg(ctx, { x: 0, y: 0, w, h })
+    const padL = 66
+    const padR = 66
+    const padT = 22
+    const padB = 14
+    const rowY = (i: number) => padT + (i / Math.max(1, N - 1)) * (h - padT - padB)
+    const stageX = (s: number) => padL + (s / n) * (w - padL - padR)
+
+    // edges: for each stage k (0..n-1), butterfly with len = 2^k
+    for (let k = 0; k < n; k++) {
+      const len = 1 << k
+      const x0 = stageX(k)
+      const x1 = stageX(k + 1)
+      for (let i = 0; i < N; i += len << 1) {
+        for (let j = 0; j < len; j++) {
+          const top = i + j
+          const bot = i + j + len
+          // straight carry lines
+          ctx.strokeStyle = 'rgba(120,140,220,0.22)'
+          ctx.lineWidth = 1
+          ctx.beginPath()
+          ctx.moveTo(x0, rowY(top))
+          ctx.lineTo(x1, rowY(top))
+          ctx.stroke()
+          ctx.beginPath()
+          ctx.moveTo(x0, rowY(bot))
+          ctx.lineTo(x1, rowY(bot))
+          ctx.stroke()
+          // the XOR cross: bottom feeds the top (top ^= bottom)
+          ctx.strokeStyle = 'rgba(167,139,250,0.5)'
+          ctx.beginPath()
+          ctx.moveTo(x0, rowY(bot))
+          ctx.lineTo(x1, rowY(top))
+          ctx.stroke()
+          // ⊕ marker at the top node output
+          const mx = x1
+          const my = rowY(top)
+          ctx.fillStyle = 'rgba(167,139,250,0.85)'
+          ctx.beginPath()
+          ctx.arc(mx, my, 2.4, 0, Math.PI * 2)
+          ctx.fill()
+        }
+      }
+    }
+
+    // nodes: value dots at each stage
+    const drawCol = (s: number, vals: Uint8Array, frozenMark: boolean) => {
+      for (let i = 0; i < N; i++) {
+        const x = stageX(s)
+        const y = rowY(i)
+        const one = vals[i] === 1
+        ctx.fillStyle = one ? BLUE : 'rgba(30,41,64,0.95)'
+        ctx.strokeStyle = one ? BLUE : 'rgba(120,140,220,0.5)'
+        ctx.lineWidth = 1.2
+        ctx.beginPath()
+        ctx.arc(x, y, 4.6, 0, Math.PI * 2)
+        ctx.fill()
+        ctx.stroke()
+        if (frozenMark && code.frozen[i]) {
+          ctx.strokeStyle = 'rgba(148,163,204,0.7)'
+          ctx.lineWidth = 1
+          ctx.beginPath()
+          ctx.arc(x, y, 7.5, 0, Math.PI * 2)
+          ctx.stroke()
+        }
+      }
+    }
+    for (let s = 0; s <= n; s++) drawCol(s, stages[s], s === 0)
+
+    // labels
+    ctx.fillStyle = INK
+    ctx.font = '11px JetBrains Mono, ui-monospace, monospace'
+    ctx.textAlign = 'right'
+    for (let i = 0; i < N && N <= 32; i++) {
+      const info = code.frozen[i] === 0
+      ctx.fillStyle = info ? TEAL : DIM
+      ctx.fillText(`u${i}${info ? '' : '·0'}`, padL - 10, rowY(i) + 3)
+    }
+    ctx.textAlign = 'left'
+    for (let i = 0; i < N && N <= 32; i++) {
+      ctx.fillStyle = INK
+      ctx.fillText(`x${i}`, w - padR + 10, rowY(i) + 3)
+    }
+    ctx.textAlign = 'center'
+    axisLabel(ctx, 'u (input)', padL, 12, 'center')
+    axisLabel(ctx, 'x (codeword)', w - padR, 12, 'center')
+  }, [graphRef, graphSize, stages, code, N, n])
+
+  return (
+    <div className="mode">
+      <div className="mode-side">
+        <Panel title="Code">
+          <Field label="Block length N" value={`2^${n} = ${N}`}>
+            <Slider min={2} max={5} step={1} value={n} onChange={setN} />
+          </Field>
+          <Field label="Code rate K/N" value={`${rate.toFixed(2)} → K=${K}`}>
+            <Slider min={0.1} max={0.9} step={0.05} value={rate} onChange={setRate} />
+          </Field>
+          <Field label="Construction">
+            <Select value={construction} options={CONSTRUCTIONS} onChange={setConstruction} />
+          </Field>
+          <Field label="Design Eb/N0" value={`${designSnr.toFixed(1)} dB`}>
+            <Slider min={-2} max={6} step={0.5} value={designSnr} onChange={setDesignSnr} />
+          </Field>
+          <Button onClick={() => setSeed((s) => s + 1)} variant="primary">
+            reroll message
+          </Button>
+        </Panel>
+        <Panel title="This encode">
+          <Readout
+            items={[
+              { label: 'info bits', value: `${code.K}` },
+              { label: 'weight(x)', value: `${enc.x.reduce((a, b) => a + b, 0)}` },
+              { label: 'stages', value: `${n}` },
+            ]}
+          />
+        </Panel>
+      </div>
+      <div className="mode-main">
+        <p className="mode-intro">
+          Encoding is nothing but XOR. The generator is F^{'⊗'}
+          <sup>n</sup> with F = [[1,0],[1,1]] — a butterfly network of {n} stages. Frozen inputs (ringed)
+          are held at 0; the information bits (teal) ride the reliable channels. Every dot is a bit;
+          purple crossings are XORs. The transform is <strong>its own inverse over GF(2)</strong>, so
+          the very same network run backwards recovers u from a clean x.
+        </p>
+        <CanvasCard title={`Polar encoder F^⊗${n} — u·F^⊗${n} = x`} height={420}>
+          <canvas ref={graphRef} />
+        </CanvasCard>
+      </div>
+    </div>
+  )
+}
+
+// ===========================================================================
+// Tab 3 — Decode: SC vs SCL vs CA-SCL on one noisy word
+// ===========================================================================
+
+function DecodeTab() {
+  const sp = useMemo(() => readHashParams(), [])
+  const [n, setN] = useState(() => readNum(sp, 'dn', 7))
+  const [rate, setRate] = useState(() => readNum(sp, 'drate', 0.5))
+  const [construction, setConstruction] = useState<Construction>(() =>
+    readStr(sp, 'dcon', 'ga', ['ga', 'bhattacharyya'] as const),
+  )
+  const [crc, setCrc] = useState(() => readStr(sp, 'dcrc', 'crc8', CRCS.map((c) => c.id)))
+  const [listSize, setListSize] = useState(() => readNum(sp, 'dL', 8))
+  const [snr, setSnr] = useState(() => readNum(sp, 'dsnr', 1.5))
+  const [exact, setExact] = useState(() => readBool(sp, 'dex', true))
+  const [seed, setSeed] = useState(1)
+
+  const N = 1 << n
+  const crcSpec = crcById(crc)
+  // K must exceed the CRC width (so there is a real payload) and stay below N.
+  const K = Math.max(crcSpec.width + 2, Math.min(N - 1, Math.round(rate * N)))
+  const code = useMemo(
+    () => buildCode(N, K, construction, designSafe(snr), crcSpec),
+    [N, K, construction, snr, crcSpec],
+  )
+
+  // build one received word and decode it three ways
+  const run = useMemo(() => {
+    const msg = randomPayload(code, seed)
+    const { u, x } = encode(msg, code)
+    const rng = mulberry32(seed * 40503 + 12345)
+    const sigma = ebn0ToSigmaLocal(snr, code.rate)
+    const llr = new Float64Array(N)
+    const rx = new Float64Array(N)
+    const flips = new Uint8Array(N)
+    const inv = 1 / (sigma * sigma)
+    for (let i = 0; i < N; i++) {
+      const s = x[i] === 0 ? 1 : -1
+      const g = gaussLocal(rng)
+      const y = s + sigma * g
+      rx[i] = y
+      llr[i] = 2 * y * inv
+      const hard = y >= 0 ? 0 : 1
+      flips[i] = hard !== x[i] ? 1 : 0
+    }
+    const sc = decodeSC(llr, code, exact)
+    const scl = decodeSCL(llr, code, listSize, exact)
+    // plain SCL (ignore CRC in the pick) for contrast
+    const bestByMetric = scl.bestByMetric
+    const plainInfo = new Uint8Array(code.K)
+    for (let i = 0; i < code.infoPos.length; i++) plainInfo[i] = bestByMetric[code.infoPos[i]]
+    const berr = (info: Uint8Array) => {
+      let e = 0
+      for (let i = 0; i < code.msgLen; i++) if (info[i] !== msg[i]) e++
+      return e
+    }
+    return {
+      msg,
+      u,
+      x,
+      rx,
+      llr,
+      flips,
+      channelFlips: flips.reduce((a, b) => a + b, 0),
+      sc: { info: sc.info, err: berr(sc.info) },
+      sclPlain: { info: plainInfo, err: berr(plainInfo) },
+      scl: { info: scl.info, err: berr(scl.info), ok: scl.ok, survivors: scl.survivors },
+    }
+  }, [code, seed, snr, exact, listSize, N])
+
+  // channel strip: received soft values + flipped positions
+  const { ref: stripRef, size: stripSize } = useDprCanvas()
+  useEffect(() => {
+    const ctx = prepareContext(stripRef.current, stripSize)
+    if (!ctx) return
+    const { width: w, height: h } = stripSize
+    fillPlotBg(ctx, { x: 0, y: 0, w, h })
+    const pad = { l: 10, r: 10, t: 16, b: 16 }
+    const cols = Math.min(N, 64)
+    const rows = Math.ceil(N / cols)
+    const cw = (w - pad.l - pad.r) / cols
+    const chh = (h - pad.t - pad.b) / rows
+    let maxAbs = 1e-6
+    for (let i = 0; i < N; i++) maxAbs = Math.max(maxAbs, Math.abs(run.rx[i]))
+    for (let i = 0; i < N; i++) {
+      const col = i % cols
+      const row = Math.floor(i / cols)
+      const x = pad.l + col * cw
+      const y = pad.t + row * chh
+      const v = run.rx[i]
+      const t = Math.min(1, Math.abs(v) / maxAbs)
+      // blue for +（bit0-leaning), rose for −(bit1-leaning)
+      ctx.fillStyle = v >= 0 ? `rgba(56,189,248,${0.25 + 0.6 * t})` : `rgba(251,113,133,${0.25 + 0.6 * t})`
+      ctx.fillRect(x + 0.5, y + 0.5, cw - 1, chh - 1)
+      if (run.flips[i]) {
+        ctx.strokeStyle = AMBER
+        ctx.lineWidth = 1.6
+        ctx.strokeRect(x + 1, y + 1, cw - 2, chh - 2)
+      }
+    }
+    axisLabel(ctx, 'received samples — blue +1·leaning, rose −1·leaning, amber = channel flipped', pad.l, 12, 'left')
+  }, [stripRef, stripSize, run, N])
+
+  const rows: { label: string; err: number; ok: boolean | null; strong?: boolean }[] = [
+    { label: 'SC (list = 1)', err: run.sc.err, ok: null },
+    { label: `SCL (L=${listSize}, best metric)`, err: run.sclPlain.err, ok: null },
+    {
+      label: crcSpec.width > 0 ? `CA-SCL (L=${listSize}, CRC)` : `SCL (L=${listSize})`,
+      err: run.scl.err,
+      ok: crcSpec.width > 0 ? run.scl.ok : null,
+      strong: true,
+    },
+  ]
+
+  return (
+    <div className="mode">
+      <div className="mode-side">
+        <Panel title="Code & channel">
+          <Field label="Block length N" value={`2^${n} = ${N}`}>
+            <Slider min={4} max={10} step={1} value={n} onChange={setN} />
+          </Field>
+          <Field label="Code rate K/N" value={`${rate.toFixed(2)} → K=${K}`}>
+            <Slider min={0.1} max={0.9} step={0.05} value={rate} onChange={setRate} />
+          </Field>
+          <Field label="Construction">
+            <Select value={construction} options={CONSTRUCTIONS} onChange={setConstruction} />
+          </Field>
+          <Field label="Outer CRC">
+            <Select value={crc} options={CRC_OPTIONS} onChange={setCrc} />
+          </Field>
+          <Field label="List size L" value={`${listSize}`}>
+            <Slider min={1} max={32} step={1} value={listSize} onChange={(v) => setListSize(roundPow2(v))} />
+          </Field>
+          <Field label="Channel Eb/N0" value={`${snr.toFixed(1)} dB`}>
+            <Slider min={-2} max={6} step={0.25} value={snr} onChange={setSnr} />
+          </Field>
+          <Toggle label="Exact box-plus (vs min-sum)" checked={exact} onChange={setExact} />
+          <Button onClick={() => setSeed((s) => s + 1)} variant="primary">
+            reroll noise
+          </Button>
+        </Panel>
+        <Panel title="Outcome (this word)">
+          <div className="poly-table">
+            {rows.map((rw) => (
+              <div key={rw.label} className={rw.strong ? 'poly-row strong' : 'poly-row'}>
+                <span className="poly-name">{rw.label}</span>
+                <span
+                  className="poly-status"
+                  style={{ color: rw.err === 0 ? TEAL : ROSE }}
+                >
+                  {rw.err === 0 ? '✓ decoded' : `✗ ${rw.err} bit err`}
+                  {rw.ok !== null && (
+                    <span style={{ color: rw.ok ? TEAL : AMBER, marginLeft: 8 }}>
+                      {rw.ok ? 'CRC ✓' : 'CRC ✗'}
+                    </span>
+                  )}
+                </span>
+              </div>
+            ))}
+          </div>
+          <Readout
+            items={[
+              { label: 'channel flips', value: `${run.channelFlips}/${N}` },
+              { label: 'payload', value: `${code.msgLen} b` },
+            ]}
+          />
+        </Panel>
+      </div>
+      <div className="mode-main">
+        <p className="mode-intro">
+          One codeword through AWGN, decoded three ways. <strong>SC</strong> commits to each bit
+          irreversibly — one early wrong guess dooms the block. <strong>SCL</strong> keeps the L
+          most-likely paths alive; the true path usually survives even when it isn't the
+          instantaneous favourite. The <strong>CRC</strong> is the referee: it lets the list-decoder
+          reject the plausible-but-wrong survivor and pick the one that actually checks — the trick
+          that put polar codes into 5G.
+        </p>
+        <CanvasCard title="The received block" height={190}>
+          <canvas ref={stripRef} />
+        </CanvasCard>
+        {crcSpec.width > 0 && (
+          <SurvivorList survivors={run.scl.survivors} chosen={run.scl.info} />
+        )}
+      </div>
+    </div>
+  )
+}
+
+function SurvivorList({
+  survivors,
+  chosen,
+}: {
+  survivors: { pm: number; info: Uint8Array; crcOk: boolean }[]
+  chosen: Uint8Array
+}) {
+  const eq = (a: Uint8Array, b: Uint8Array) => {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+    return true
+  }
+  const top = survivors.slice(0, 12)
+  const pmMin = survivors.length ? survivors[0].pm : 0
+  return (
+    <div className="canvas-card">
+      <div className="canvas-head">
+        <span className="canvas-title">List survivors — ranked by path metric</span>
+        <span className="canvas-note">green = passes CRC · ★ = chosen path</span>
+      </div>
+      <div className="poly-survivors">
+        {top.map((s, i) => (
+          <div key={i} className="poly-surv-row">
+            <span className="poly-surv-rank">#{i + 1}</span>
+            <span className="poly-surv-bar">
+              <span
+                className="poly-surv-fill"
+                style={{
+                  width: `${Math.max(4, 100 - Math.min(100, (s.pm - pmMin) * 6))}%`,
+                  background: s.crcOk ? TEAL : DIM,
+                }}
+              />
+            </span>
+            <span className="poly-surv-pm">PM {s.pm.toFixed(2)}</span>
+            <span className="poly-surv-crc" style={{ color: s.crcOk ? TEAL : ROSE }}>
+              {s.crcOk ? 'CRC ✓' : 'CRC ✗'}
+            </span>
+            <span className="poly-surv-star">{eq(s.info, chosen) ? '★' : ''}</span>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
+
+// ===========================================================================
+// Tab 4 — Waterfall: BLER/BER vs Eb/N0
+// ===========================================================================
+
+const XMIN = 0
+const XMAX = 5
+const EBN0_LIST: number[] = (() => {
+  const list: number[] = []
+  for (let db = XMIN; db <= XMAX + 1e-9; db += 0.5) list.push(Math.round(db * 2) / 2)
+  return list
+})()
+
+interface Curve {
+  id: string
+  label: string
+  color: string
+  pts: WaterfallPoint[]
+}
+
+function WaterfallTab() {
+  const sp = useMemo(() => readHashParams(), [])
+  const [n, setN] = useState(() => readNum(sp, 'wn', 8))
+  const [rate, setRate] = useState(() => readNum(sp, 'wrate', 0.5))
+  const [construction, setConstruction] = useState<Construction>(() =>
+    readStr(sp, 'wcon', 'ga', ['ga', 'bhattacharyya'] as const),
+  )
+  const [effort, setEffort] = useState<'quick' | 'balanced' | 'deep'>(() =>
+    readStr(sp, 'weff', 'quick', ['quick', 'balanced', 'deep'] as const),
+  )
+  const [metric, setMetric] = useState<'ber' | 'bler'>(() =>
+    readStr(sp, 'wmet', 'bler', ['ber', 'bler'] as const),
+  )
+  const [curves, setCurves] = useState<Curve[] | null>(null)
+  const [running, setRunning] = useState(false)
+  const [progress, setProgress] = useState('')
+  const [copied, setCopied] = useState(false)
+  const [runNonce, setRunNonce] = useState(0)
+
+  const N = 1 << n
+  // Keep K above the fixed CRC-8 width so the CA-SCL curve always has a payload.
+  const K = Math.max(12, Math.min(N - 1, Math.round(rate * N)))
+
+  const budget = useMemo(() => {
+    if (effort === 'quick') return { minBlocks: 100, maxBlocks: 600, targetBlockErrors: 25 }
+    if (effort === 'deep') return { minBlocks: 300, maxBlocks: 4000, targetBlockErrors: 80 }
+    return { minBlocks: 180, maxBlocks: 1600, targetBlockErrors: 45 }
+  }, [effort])
+
+  useEffect(() => {
+    let cancelled = false
+    const codePlain = buildCode(N, K, construction, 2, crcById('none'))
+    const codeCrc = buildCode(N, K, construction, 2, crcById('crc8'))
+    const plan: { id: string; label: string; color: string; code: PolarCode; kind: 'sc' | 'scl' | 'ca-scl'; L: number }[] = [
+      { id: 'sc', label: 'SC', color: ROSE, code: codePlain, kind: 'sc', L: 1 },
+      { id: 'scl2', label: 'SCL L=2', color: AMBER, code: codePlain, kind: 'scl', L: 2 },
+      { id: 'scl8', label: 'SCL L=8', color: BLUE, code: codePlain, kind: 'scl', L: 8 },
+      { id: 'cascl8', label: 'CA-SCL L=8', color: TEAL, code: codeCrc, kind: 'ca-scl', L: 8 },
+    ]
+    const acc: Curve[] = []
+    let i = 0
+    const step = () => {
+      if (cancelled) return
+      if (i === 0) {
+        setRunning(true)
+        setCurves(null)
+      }
+      const job = plan[i]
+      setProgress(`simulating ${job.label}…`)
+      const pts = waterfall(
+        job.code,
+        { kind: job.kind, L: job.L },
+        EBN0_LIST,
+        true,
+        { ...budget, seed: 20260724 + i * 13 },
+      )
+      acc.push({ id: job.id, label: job.label, color: job.color, pts })
+      i++
+      if (i < plan.length) setTimeout(step, 0)
+      else {
+        setCurves([...acc])
+        setRunning(false)
+        setProgress('')
+      }
+    }
+    const id = setTimeout(step, 0)
+    return () => {
+      cancelled = true
+      clearTimeout(id)
+    }
+  }, [N, K, construction, budget, runNonce])
+
+  const shannon = biAwgnLimitDb(K / N)
+
+  const { ref: plotRef, size: plotSize } = useDprCanvas()
+  useEffect(() => {
+    const ctx = prepareContext(plotRef.current, plotSize)
+    if (!ctx) return
+    const { width: w, height: h } = plotSize
+    const pad = { l: 50, r: 14, t: 16, b: 30 }
+    const r: Rect = { x: pad.l, y: pad.t, w: w - pad.l - pad.r, h: h - pad.t - pad.b }
+    fillPlotBg(ctx, { x: 0, y: 0, w, h })
+    const topExp = 0
+    const botExp = -5
+    const X = (db: number) => r.x + ((db - XMIN) / (XMAX - XMIN)) * r.w
+    const Y = (val: number) => {
+      const e = Math.log10(Math.max(val, 1e-6))
+      const t = (e - topExp) / (botExp - topExp)
+      return r.y + Math.max(0, Math.min(1, t)) * r.h
+    }
+    ctx.strokeStyle = 'rgba(120,140,220,0.12)'
+    ctx.lineWidth = 1
+    for (let e = topExp; e >= botExp; e--) {
+      const y = Y(Math.pow(10, e))
+      ctx.beginPath()
+      ctx.moveTo(r.x, y)
+      ctx.lineTo(r.x + r.w, y)
+      ctx.stroke()
+      axisLabel(ctx, e === 0 ? '1' : `1e${e}`, r.x - 6, y + 3, 'right')
+    }
+    for (let db = XMIN; db <= XMAX; db += 1) {
+      const x = X(db)
+      ctx.beginPath()
+      ctx.moveTo(x, r.y)
+      ctx.lineTo(x, r.y + r.h)
+      ctx.stroke()
+      axisLabel(ctx, `${db}`, x, r.y + r.h + 16, 'center')
+    }
+    // uncoded BPSK reference (BER only meaningful; draw dimmed)
+    if (metric === 'ber') {
+      ctx.strokeStyle = INK
+      ctx.lineWidth = 2
+      ctx.beginPath()
+      let s0 = false
+      for (let db = XMIN; db <= XMAX; db += 0.1) {
+        const x = X(db)
+        const y = Y(uncodedBer(db))
+        if (!s0) {
+          ctx.moveTo(x, y)
+          s0 = true
+        } else ctx.lineTo(x, y)
+      }
+      ctx.stroke()
+    }
+    // Shannon limit
+    if (shannon >= XMIN && shannon <= XMAX) {
+      ctx.strokeStyle = 'rgba(94,234,212,0.55)'
+      ctx.setLineDash([4, 4])
+      ctx.lineWidth = 1.5
+      ctx.beginPath()
+      ctx.moveTo(X(shannon), r.y)
+      ctx.lineTo(X(shannon), r.y + r.h)
+      ctx.stroke()
+      ctx.setLineDash([])
+      axisLabel(ctx, 'Shannon', X(shannon) + 4, r.y + 12, 'left')
+    }
+    if (curves) {
+      for (const c of curves) {
+        ctx.strokeStyle = c.color
+        ctx.lineWidth = c.id === 'cascl8' ? 2.6 : 1.8
+        ctx.beginPath()
+        let s = false
+        for (const p of c.pts) {
+          const val = metric === 'ber' ? p.ber : p.bler
+          if (val <= 0) continue
+          const x = X(p.ebn0Db)
+          const y = Y(val)
+          if (!s) {
+            ctx.moveTo(x, y)
+            s = true
+          } else ctx.lineTo(x, y)
+        }
+        ctx.stroke()
+        for (const p of c.pts) {
+          const val = metric === 'ber' ? p.ber : p.bler
+          if (val <= 0) continue
+          ctx.fillStyle = c.color
+          ctx.beginPath()
+          ctx.arc(X(p.ebn0Db), Y(val), 2.2, 0, Math.PI * 2)
+          ctx.fill()
+        }
+      }
+    }
+    axisLabel(ctx, 'Eb/N0 (dB) →', r.x + r.w, r.y + r.h + 16, 'right')
+    axisLabel(ctx, metric.toUpperCase(), r.x, r.y - 3, 'left')
+    // legend
+    const legend: [string, string][] = [
+      ['SC', ROSE],
+      ['SCL L=2', AMBER],
+      ['SCL L=8', BLUE],
+      ['CA-SCL L=8', TEAL],
+    ]
+    legend.forEach(([txt, col], i) => {
+      const ly = r.y + 10 + i * 15
+      ctx.strokeStyle = col
+      ctx.lineWidth = 2.4
+      ctx.beginPath()
+      ctx.moveTo(r.x + r.w - 118, ly)
+      ctx.lineTo(r.x + r.w - 98, ly)
+      ctx.stroke()
+      axisLabel(ctx, txt, r.x + r.w - 92, ly + 3, 'left')
+    })
+  }, [plotRef, plotSize, curves, metric, shannon])
+
+  const onShare = () => {
+    shareLink('polar', {
+      tab: 'waterfall',
+      wn: n,
+      wrate: rate,
+      wcon: construction,
+      weff: effort,
+      wmet: metric,
+    }).then((ok) => {
+      if (ok) {
+        setCopied(true)
+        setTimeout(() => setCopied(false), 1400)
+      }
+    })
+  }
+
+  return (
+    <div className="mode">
+      <div className="mode-side">
+        <Panel title="Simulation">
+          <Field label="Block length N" value={`2^${n} = ${N}`}>
+            <Slider min={5} max={9} step={1} value={n} onChange={setN} />
+          </Field>
+          <Field label="Code rate K/N" value={`${rate.toFixed(2)} → K=${K}`}>
+            <Slider min={0.25} max={0.75} step={0.05} value={rate} onChange={setRate} />
+          </Field>
+          <Field label="Construction">
+            <Select value={construction} options={CONSTRUCTIONS} onChange={setConstruction} />
+          </Field>
+          <Field label="Metric">
+            <Segmented
+              value={metric}
+              options={[
+                { id: 'bler', label: 'BLER' },
+                { id: 'ber', label: 'BER' },
+              ]}
+              onChange={setMetric}
+            />
+          </Field>
+          <Field label="Effort">
+            <Segmented
+              value={effort}
+              options={[
+                { id: 'quick', label: 'Quick' },
+                { id: 'balanced', label: 'Balanced' },
+                { id: 'deep', label: 'Deep' },
+              ]}
+              onChange={setEffort}
+            />
+          </Field>
+          <Button onClick={() => setRunNonce((x) => x + 1)} variant="primary">
+            {running ? 'running…' : 'run again'}
+          </Button>
+          <Button onClick={onShare} variant="ghost">
+            {copied ? 'link copied ✓' : 'share this view'}
+          </Button>
+        </Panel>
+        <Panel title="At a glance">
+          <Readout
+            items={[
+              { label: 'N', value: `${N}` },
+              { label: 'K', value: `${K}` },
+              { label: 'rate', value: (K / N).toFixed(2) },
+              { label: 'Shannon', value: `${shannon.toFixed(2)} dB` },
+            ]}
+          />
+          {progress && <p className="mode-note">{progress}</p>}
+        </Panel>
+      </div>
+      <div className="mode-main">
+        <p className="mode-intro">
+          The payoff curve. Plain <strong>SC</strong> is a couple of dB from capacity; growing the
+          list closes most of the gap, and the <strong>CRC-aided list</strong> (the 5G decoder) drops
+          the block-error rate by another order of magnitude — a short polar code landing within ~1 dB
+          of the finite-length Shannon limit. Monte-Carlo, adaptive block budget, everything computed
+          live on the same from-scratch decoder.
+        </p>
+        <CanvasCard
+          title={`${metric.toUpperCase()} waterfall — N=${N}, K=${K}, R=${(K / N).toFixed(2)}`}
+          note={running ? progress : 'four decoders, one channel'}
+          height={380}
+        >
+          <canvas ref={plotRef} />
+        </CanvasCard>
+      </div>
+    </div>
+  )
+}
+
+// --- small local helpers ---------------------------------------------------
+
+function roundPow2(v: number): number {
+  const p = Math.round(Math.log2(Math.max(1, v)))
+  return 1 << Math.max(0, Math.min(5, p))
+}
+
+function designSafe(snr: number): number {
+  // a sensible design point tracks the operating SNR but stays in a good range
+  return Math.max(-1, Math.min(4, snr))
+}
+
+function ebn0ToSigmaLocal(ebn0Db: number, rate: number): number {
+  const esn0Db = ebn0Db + 10 * Math.log10(Math.max(1e-6, rate))
+  const gamma = Math.pow(10, esn0Db / 10)
+  return Math.sqrt(1 / (2 * gamma))
+}
+
+function gaussLocal(rng: () => number): number {
+  let u = 0
+  while (u === 0) u = rng()
+  const v = rng()
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v)
+}
+
+// ===========================================================================
+
+export default function Polar() {
+  const sp = useMemo(() => readHashParams(), [])
+  const [tab, setTab] = useState<'polarize' | 'encoder' | 'decode' | 'waterfall'>(() =>
+    readStr(sp, 'tab', 'polarize', ['polarize', 'encoder', 'decode', 'waterfall'] as const),
+  )
+  return (
+    <div className="mode-wrap">
+      <div className="mode-tabs">
+        <Segmented
+          value={tab}
+          options={[
+            { id: 'polarize', label: 'Polarization' },
+            { id: 'encoder', label: 'Encoder' },
+            { id: 'decode', label: 'Decode' },
+            { id: 'waterfall', label: 'Waterfall' },
+          ]}
+          onChange={setTab}
+        />
+      </div>
+      {tab === 'polarize' && <PolarizeTab />}
+      {tab === 'encoder' && <EncoderTab />}
+      {tab === 'decode' && <DecodeTab />}
+      {tab === 'waterfall' && <WaterfallTab />}
+    </div>
+  )
+}