# Alpha decay
## Microsim
### Live player
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/TZoPav0Tw" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
</div>
<div class="microsim-fallback">
<img src="Microsims/thumbs/Alpha_decay.png" alt="Alpha_decay microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;">
<p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/TZoPav0Tw">open sketch in the p5.js editor</a></em></p>
</div>
**Editor URL:** https://editor.p5js.org/sciencenibber/sketches/TZoPav0Tw
**Description (100 words):**
A lattice of two hundred parent nuclei (yellow dots) decays under a half-life slider that spans six decades from one second to ten days. Each frame, every survivor flips its alive flag with the exact stochastic probability one minus exp(minus lambda dt) and emits a pale alpha particle that drifts off in a random direction. A side scope traces the surviving fraction N over N0 against time, with a dashed reference line at one half so the eye can verify that the curve crosses on schedule. The activity gauge reports decays per second; readouts show T_half, lambda, and the live count.
```js
// =====================================================================
// Alpha_decay.js — Wikitube microsim (Nuclear room, Pattern E)
//
// Article : Alpha_decay
// Wikitube: en.wikitube.io/wiki/Alpha_decay
// Pattern : E reskin — Decay clocks and half-life
//
// Idea
// ----
// A population of N parent nuclei (heavy, alpha-emitting — think U-238,
// Ra-226, Po-210) sit in a lattice of dots. Each frame, each surviving
// parent has an independent probability of decay equal to
//
// p_frame = 1 - exp(-lambda * dt)
//
// where lambda = ln(2) / T_half is the decay constant. (Using
// p_frame = lambda * dt is the textbook trap for short half-lives:
// the linear form gives probabilities greater than one and the entire
// population vanishes in one frame. The exponential form is exact for
// any dt — see Pitfalls in the Nuclear pattern guide.)
//
// When a parent decays it emits a small "alpha" particle that flies
// off in a random direction (rendered as a moving dot), and the parent
// dot recolours to the daughter species. A side scope shows N(t), the
// surviving-parent count, decaying exponentially toward zero. A bar
// gauge below the scope shows the live activity A(t) = lambda * N(t)
// in decays/second, which is what a Geiger counter measures.
//
// Equations
// ---------
// N(t) = N0 * exp(-lambda * t)
// T_half = ln(2) / lambda
// A(t) = lambda * N(t) (activity)
// log lambda = a - b / sqrt(E_alpha) (Geiger-Nuttall)
//
// Parameters (canonical names exposed on sliders)
// -----------------------------------------------
// T_half — half-life in seconds (log slider, 0.5 s ... 1e6 s)
// N0 — initial parent population (50 ... 600)
// reset — re-seed the lattice
//
// Notes on standards
// ------------------
// - All non-ASCII glyphs (Greek letters, arrows, alpha symbol, the
// subscript zero in N0, etc.) live in COMMENTS only. Anything that
// ends up inside a string literal, a template literal, or a text()
// argument is plain ASCII. The p5.js Web Editor preview wrapper has
// a transform that mishandles non-ASCII inside expressions and emits
// a misleading SyntaxError; comments are stripped before that step
// so they are safe.
// - Single ARTICLE constant. Title and URL line both reference it.
// - p5.disableFriendlyErrors = true. FES is great while authoring,
// noisy in the wild.
// =====================================================================
const ARTICLE = "Alpha_decay";
p5.disableFriendlyErrors = true;
// ---- Nuclear palette (from Articles/P5_JS_EDITOR.md sec.5) ----------
const BG = [ 8, 16, 28]; // deep cloud-chamber blue
const FG = 240;
const PARENT = [180, 200, 80]; // unstable heavy nucleus (fuel-yellow)
const DAUGHTER= [ 80, 200, 140]; // stable-ish daughter
const ALPHA = [240, 240, 255]; // emitted alpha particle (neutron-white)
const DECAY_C = [255, 80, 80]; // decay-event flash colour
const STRUCT = [120, 130, 150]; // chrome / labels / panel borders
const PANEL = [ 20, 30, 40]; // diagnostics panel fill
// ---- Lattice geometry -----------------------------------------------
let nuclei = []; // each: { x, y, alive, flashUntil }
let alphas = []; // each: { x, y, vx, vy, life }
let history = []; // running record of surviving-parent count
let lastDecayCount = 0;
let activity = 0; // decays per simulated second
// ---- Controls -------------------------------------------------------
let halfLifeSlider; // log-mapped: slider 0..6 -> T_half = 10^(slider) seconds
let popSlider; // initial population N0
let resetBtn;
// Layout constants populated in setup() so windowResized() can rebuild
let LATTICE_X, LATTICE_Y, LATTICE_W, LATTICE_H;
let SCOPE_X, SCOPE_Y, SCOPE_W, SCOPE_H;
let CONTROL_Y;
function setup() {
// 720 x 520 is the room baseline; allow growth with the window.
createCanvas(max(720, windowWidth - 40), max(520, windowHeight - 40));
pixelDensity(2);
textFont("system-ui");
layout();
// Half-life slider is log-scale: each unit = 1 decade.
// Slider value 0 -> 1 s, 3 -> 1000 s (~17 min), 6 -> 1e6 s (~12 days).
halfLifeSlider = createSlider(0, 6, 2, 0.01);
halfLifeSlider.position(20, CONTROL_Y);
halfLifeSlider.size(220);
// Population slider — number of parent nuclei in the lattice.
popSlider = createSlider(50, 600, 200, 10);
popSlider.position(280, CONTROL_Y);
popSlider.size(180);
resetBtn = createButton("reset");
resetBtn.position(490, CONTROL_Y);
resetBtn.mousePressed(seed);
seed();
}
// Place initial population in a roughly square grid inside the lattice
// rectangle, with small jitter so the eye sees a population, not a grid.
function seed() {
nuclei = [];
alphas = [];
history = [];
lastDecayCount = 0;
activity = 0;
const N0 = popSlider ? popSlider.value() : 200;
const cols = ceil(sqrt(N0 * (LATTICE_W / LATTICE_H)));
const rows = ceil(N0 / cols);
const dx = LATTICE_W / (cols + 1);
const dy = LATTICE_H / (rows + 1);
let placed = 0;
for (let r = 0; r < rows && placed < N0; r++) {
for (let c = 0; c < cols && placed < N0; c++) {
nuclei.push({
x: LATTICE_X + dx * (c + 1) + random(-dx * 0.15, dx * 0.15),
y: LATTICE_Y + dy * (r + 1) + random(-dy * 0.15, dy * 0.15),
alive: true,
flashUntil: 0
});
placed++;
}
}
}
function layout() {
// Reserve a 200px-tall band at the bottom for sliders and HUD.
CONTROL_Y = height - 80;
// Lattice on the left two-thirds of the canvas.
LATTICE_X = 40;
LATTICE_Y = 60;
LATTICE_W = floor((width - 100) * 0.62);
LATTICE_H = (CONTROL_Y - 30) - LATTICE_Y;
// Scope panel on the right third.
SCOPE_X = LATTICE_X + LATTICE_W + 30;
SCOPE_Y = LATTICE_Y;
SCOPE_W = width - SCOPE_X - 40;
SCOPE_H = LATTICE_H - 70;
}
function draw() {
background(BG[0], BG[1], BG[2]);
// ---- 1. Read parameters into named locals at the top of draw() ----
const tHalf = pow(10, halfLifeSlider.value()); // seconds
const lambda = log(2) / tHalf; // 1/seconds
const dt = min(deltaTime / 1000, 0.05); // seconds, clamped
// If the population slider moved by more than a few atoms, reseed.
// (Cheap enough; avoids weird half-states.)
const targetN = popSlider.value();
if (abs(targetN - nuclei.length) > 5) seed();
// ---- 2. Stochastic decay step ------------------------------------
// Each surviving nucleus has independent probability p_frame this
// tick of decaying. We use the exact 1 - exp(-lambda*dt) form.
const pFrame = 1 - exp(-lambda * dt);
let decayedThisFrame = 0;
for (const nuc of nuclei) {
if (!nuc.alive) continue;
if (random() < pFrame) {
nuc.alive = false;
nuc.flashUntil = millis() + 220; // visual flash for 220 ms
decayedThisFrame++;
// Emit an alpha particle that flies off in a random direction.
const ang = random(TWO_PI);
alphas.push({
x: nuc.x,
y: nuc.y,
vx: cos(ang) * 90,
vy: sin(ang) * 90,
life: 1.6
});
}
}
// ---- 3. Advance and cull alpha particles -------------------------
for (const a of alphas) {
a.x += a.vx * dt;
a.y += a.vy * dt;
a.life -= dt;
}
alphas = alphas.filter(a => a.life > 0);
// ---- 4. Bookkeeping for the scope and activity gauge -------------
const aliveCount = nuclei.reduce((s, n) => s + (n.alive ? 1 : 0), 0);
history.push(aliveCount);
if (history.length > SCOPE_W) history.shift();
// Smooth the activity reading so it doesn't flicker per-frame.
// Activity = decays/second = lambda * N(t) at steady state.
const instantActivity = decayedThisFrame / max(dt, 1e-6);
activity = activity * 0.9 + instantActivity * 0.1;
lastDecayCount = decayedThisFrame;
// ---- 5. Draw the lattice -----------------------------------------
drawLatticeFrame();
noStroke();
for (const nuc of nuclei) {
if (nuc.alive) {
fill(PARENT[0], PARENT[1], PARENT[2], 230);
circle(nuc.x, nuc.y, 7);
} else if (millis() < nuc.flashUntil) {
// brief red-orange flash at the moment of decay
fill(DECAY_C[0], DECAY_C[1], DECAY_C[2], 240);
circle(nuc.x, nuc.y, 10);
} else {
fill(DAUGHTER[0], DAUGHTER[1], DAUGHTER[2], 160);
circle(nuc.x, nuc.y, 5);
}
}
// Alpha trails on top of everything in the lattice.
for (const a of alphas) {
const alpha = constrain(a.life / 1.6, 0, 1) * 230;
fill(ALPHA[0], ALPHA[1], ALPHA[2], alpha);
circle(a.x, a.y, 3);
}
// ---- 6. Draw the side scope (N(t) decay curve) -------------------
drawScope(aliveCount);
// ---- 7. HUD overlay (title, URL, hints, readouts, equation) ------
drawHud(tHalf, lambda, aliveCount);
drawSliderLabels();
}
// ---------- Lattice frame and labels ---------------------------------
function drawLatticeFrame() {
stroke(STRUCT[0], STRUCT[1], STRUCT[2], 90);
noFill();
strokeWeight(1);
rect(LATTICE_X - 6, LATTICE_Y - 6, LATTICE_W + 12, LATTICE_H + 12, 4);
noStroke();
fill(STRUCT[0], STRUCT[1], STRUCT[2]);
textSize(11);
textAlign(LEFT, BOTTOM);
text("parent nuclei (alpha emitters)", LATTICE_X, LATTICE_Y - 10);
}
// ---------- Scope panel: N(t) and activity gauge ---------------------
function drawScope(aliveCount) {
// Panel background.
noStroke();
fill(PANEL[0], PANEL[1], PANEL[2]);
rect(SCOPE_X, SCOPE_Y, SCOPE_W, SCOPE_H, 4);
// Frame lines.
stroke(STRUCT[0], STRUCT[1], STRUCT[2], 110);
strokeWeight(1);
noFill();
rect(SCOPE_X, SCOPE_Y, SCOPE_W, SCOPE_H, 4);
// Decay curve: history[i] vs. i, mapped to the scope rect.
const N0 = popSlider.value();
if (history.length >= 2) {
stroke(PARENT[0], PARENT[1], PARENT[2], 230);
strokeWeight(1.5);
noFill();
beginShape();
for (let i = 0; i < history.length; i++) {
const x = SCOPE_X + (i / SCOPE_W) * SCOPE_W;
const y = SCOPE_Y + SCOPE_H - (history[i] / N0) * SCOPE_H;
vertex(x, y);
}
endShape();
}
// Halfway reference line at N0/2 — when the curve crosses it, one
// half-life has elapsed.
stroke(STRUCT[0], STRUCT[1], STRUCT[2], 70);
strokeWeight(1);
drawingContext.setLineDash([4, 4]);
line(SCOPE_X, SCOPE_Y + SCOPE_H / 2, SCOPE_X + SCOPE_W, SCOPE_Y + SCOPE_H / 2);
drawingContext.setLineDash([]);
// Scope labels.
noStroke();
fill(STRUCT[0], STRUCT[1], STRUCT[2]);
textSize(11);
textAlign(LEFT, TOP);
text("N(t) / N0", SCOPE_X + 8, SCOPE_Y + 6);
textAlign(LEFT, BOTTOM);
text("0", SCOPE_X + 8, SCOPE_Y + SCOPE_H - 4);
textAlign(LEFT, TOP);
text("1", SCOPE_X + 8, SCOPE_Y + 18);
textAlign(RIGHT, BOTTOM);
text("time -->", SCOPE_X + SCOPE_W - 8, SCOPE_Y + SCOPE_H - 4);
// Activity gauge directly below the scope.
const gaugeY = SCOPE_Y + SCOPE_H + 16;
const gaugeH = 18;
fill(PANEL[0], PANEL[1], PANEL[2]);
noStroke();
rect(SCOPE_X, gaugeY, SCOPE_W, gaugeH, 3);
// Map activity onto the gauge with a soft asymptotic squash so high
// count rates don't peg the bar.
const aShown = 1 - exp(-activity / max(N0 * 0.05, 1));
fill(DECAY_C[0], DECAY_C[1], DECAY_C[2], 220);
rect(SCOPE_X, gaugeY, SCOPE_W * aShown, gaugeH, 3);
fill(STRUCT[0], STRUCT[1], STRUCT[2]);
textSize(11);
textAlign(LEFT, TOP);
text("activity (decays / sec)", SCOPE_X, gaugeY + gaugeH + 4);
textAlign(RIGHT, TOP);
text(nf(activity, 1, 1) + " /s", SCOPE_X + SCOPE_W, gaugeY + gaugeH + 4);
}
// ---------- HUD: title, URL, hints, readouts, equation ---------------
function drawHud(tHalf, lambda, aliveCount) {
// 2a. Top-left title block.
noStroke();
textAlign(LEFT, TOP);
fill(20);
textSize(20);
text("Alpha decay", 20, 20);
fill(110);
textSize(12);
text("Wikitube microsim - en.wikitube.io/wiki/" + ARTICLE, 20, 46);
// 2b. Top-right control hints.
textAlign(RIGHT, TOP);
fill(110);
textSize(11);
text("slider 1: T_half (log seconds)", width - 20, 20);
text("slider 2: N0 (initial parent count)", width - 20, 36);
text("button: reset click lattice: ignored", width - 20, 52);
// 2c. Bottom-left live readouts (canonical parameter symbols).
textAlign(LEFT, BOTTOM);
textSize(12);
fill(PARENT[0], PARENT[1], PARENT[2]);
text("T_half = " + formatTime(tHalf), 20, height - 20);
fill(STRUCT[0], STRUCT[1], STRUCT[2]);
text("lambda = " + nf(lambda, 1, 4) + " /s", 220, height - 20);
fill(DAUGHTER[0], DAUGHTER[1], DAUGHTER[2]);
text("N(t) = " + aliveCount + " / " + popSlider.value(), 420, height - 20);
// 2d. Bottom-right canonical equation footer (ASCII only).
textAlign(RIGHT, BOTTOM);
textSize(11);
fill(80);
text("N(t) = N0 * exp(-lambda * t), T_half = ln(2) / lambda", width - 20, height - 20);
}
// Slider labels are drawn in draw() rather than as DOM text so the
// HUD layout owns them.
function drawSliderLabels() {
noStroke();
textAlign(LEFT, BOTTOM);
textSize(11);
fill(STRUCT[0], STRUCT[1], STRUCT[2]);
text("T_half", 20, CONTROL_Y - 4);
text("N0", 280, CONTROL_Y - 4);
}
// Format a duration into the most readable unit. All output ASCII.
function formatTime(seconds) {
if (seconds < 1) return nf(seconds * 1000, 1, 1) + " ms";
if (seconds < 60) return nf(seconds, 1, 2) + " s";
if (seconds < 3600) return nf(seconds / 60, 1, 2) + " min";
if (seconds < 86400) return nf(seconds / 3600, 1, 2) + " hr";
if (seconds < 31557600) return nf(seconds / 86400, 1, 2) + " day";
return nf(seconds / 31557600, 1, 2) + " yr";
}
function windowResized() {
resizeCanvas(max(720, windowWidth - 40), max(520, windowHeight - 40));
layout();
// Reposition controls into the new layout band.
halfLifeSlider.position(20, CONTROL_Y);
popSlider.position(280, CONTROL_Y);
resetBtn.position(490, CONTROL_Y);
}
```
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Alpha_decay.json (2026-07-30T02:09:12Z) -->
`(n-p)_reaction` · `Aage_Bohr` · `Ab_initio_methods_(nuclear_physics)` · `Alexander_Litvinenko` · `Alexandru_Proca` · `Alpha-particle_spectroscopy` · [[Alpha_particle]] · `Alpha_process` · `Angstrom` · [[Antimony]] · `Aplastic_anemia` · `Atom` · `Atomic_nucleus` · `Atomic_number` · `Atomic_recoil` · `Beryllium-8` · `Beta-decay_stable_isobars` · [[Beta_decay]] · `Big_Bang_nucleosynthesis` · [[Binding_energy]] · `Bismuth-209` · `Bone_metastasis` · `Borromean_nucleus` · `CNO_cycle` · `Cancer` · `Carbon-burning_process` · `Chromosome` · `Clinton_Davisson` · `Cluster_decay` · `Cosmic_ray_spallation` · `Cosmogenic_nuclide` · `Dalton_(unit)` · [[Decay_chain]] · `Decay_energy` · [[Decay_product]] · `Deuterium_fusion` · `Double_beta_decay` · `Double_electron_capture` · [[Earth]] · `Edward_Condon` · `Edward_Mills_Purcell` · `Edward_Teller` · `Electric_charge` · [[Electric_current]] · `Electron_capture` · `Enrico_Fermi` · `Epidermis` · `Ernest_Lawrence` · `Ernest_Rutherford` · `Ernest_Walton` · `Eugene_Wigner` · `Even_and_odd_atomic_nuclei` · `Frederick_Soddy` · `Fritz_Strassmann` · `Frédéric_Joliot-Curie` · `Gamma_ray` · `Geiger–Nuttall_law` · `George_Gamow` · [[Half-life]] · `Halo_nucleus` · `Hans_Bethe` · [[Helium]] · [[Helium-4]] · `Henri_Becquerel` · `High-energy_nuclear_physics` · `Interacting_boson_model` · `Internal_conversion` · `Ionizing_radiation` · `Irène_Joliot-Curie` · `Island_of_stability` · `Isobar_(nuclide)` · `Isotone` · `Isotope` · `Isotopes_of_antimony` · `J._Hans_D._Jensen` · `J._J._Thomson` · `J._Robert_Oppenheimer` · `James_Chadwick` · `John_Cockcroft` · `Kinetic_energy` · `Large_Hadron_Collider` · `Linear_energy_transfer` · `Lise_Meitner` · `List_of_alpha-emitting_nuclides` · `Lithium_burning` · `Luis_Walter_Alvarez` · `Magic_number_(physics)` · `Marie_Curie` · `Mark_Oliphant` · `Mass_number` · `Mass–energy_equivalence` · `Mean_free_path` · `Mineral` · `Mirror_nuclei` · `NASA` · [[Natural_gas]] · `Nature_(journal)` · `Necrosis` · `Neon-burning_process` · `Neutrinoless_double_beta_decay` · [[Neutron]] · `Neutron_capture` · `Neutron_emission` · `Neutron_number` · [[Nickel]] · `Niels_Bohr` · `Nuclear_astrophysics` · `Nuclear_binding_energy` · `Nuclear_drip_line` · `Nuclear_fission` · `Nuclear_fission_product` · `Nuclear_force` · [[Nuclear_fusion]] · `Nuclear_isomer` · `Nuclear_matter` · `Nuclear_physics` · `Nuclear_reaction` · `Nuclear_shell_model` · `Nuclear_structure` · `Nucleon` · `Nucleon_pair_breaking_in_fission` · [[Nucleosynthesis]] · `Nuclide` · `Otto_Hahn` · `Oxygen-burning_process` · `P-process` · `Patrick_Blackett` · `Photodisintegration` · `Photofission` · `Pierre_Curie` · `Polonium-210` · [[Positron_emission]] · `Potential_well` · `Primordial_nuclide` · [[Proton]] · `Proton_capture` · `Proton_emission` · `Proton–proton_chain` · [[Quantum_mechanics]] · `Quark–gluon_plasma` · `R-process` · [[Radioactive_decay]] · `Radiogenic_nuclide` · `Radioisotope_thermoelectric_generator` · `Radium-223` · [[Radon]] · `Relative_biological_effectiveness` · `Relativistic_Heavy_Ion_Collider` · `Rp-process` · `S-process` · `Semi-empirical_mass_formula` · `Silicon-burning_process` · `Smoke_detector` · `Space_probe` · `Spallation` · `Speed_of_light` · [[Spontaneous_fission]] · `Stable_nuclide` · `Stellar_nucleosynthesis` · `Supernova_nucleosynthesis` · `Synthetic_element` · [[Thorium]] · `Triple-alpha_process` · [[Uranium]] · `Uranium-232` · `Uranium-238` · `Valley_of_stability` · [[Wayback_Machine]] · `Władysław_Świątecki_(physicist)` · `Zeitschrift_für_Physik`
## From the Real GENERATIVE library
*Alpha decay — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Nuclear room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Alpha_Decay.svg).*
> Alpha decay or α-decay is a type of radioactive decay in which an atomic nucleus emits an alpha particle (helium nucleus) and thereby transforms or "decays" into a different atomic nucleus, with a mass number that is reduced by four and an atomic number that is reduced by two. An alpha particle is identical to the nucleus of a helium-4 atom, which consists o ([Wikipedia](https://en.wikipedia.org/wiki/Alpha_decay))
<!-- REAL-GENERATIVE-MEDIA:END -->
<!-- LOCAL-MEDIA-PASS:START -->
## From the vault media library
!Alpha decay thumb.png
*Alpha Decay — from the vault's own media holdings, placed 2026-07-09. MTN / Wikitube.io original · CC BY-SA 4.0.*
<!-- LOCAL-MEDIA-PASS:END -->
> **Room:** Nuclear · **Status:** ✅ shipped
## Overview
Alpha decay is a form of radioactive transformation in which an unstable atomic nucleus emits an [[Alpha_particle|alpha particle]] — a tightly bound cluster of two protons and two neutrons, identical to a [[Helium|helium]]-4 nucleus. The parent nucleus loses two units of atomic number Z and four units of mass number A, producing a daughter nuclide that sits two squares to the left and two squares down on the chart of the nuclides. Alpha emission is the dominant decay mode for heavy nuclei (typically A greater than about 200) where the strong nuclear force can no longer overcome the long-range Coulomb repulsion of the protons.
The process is governed by quantum tunneling: classically the alpha particle does not have enough [[Energy|energy]] to escape the nuclear potential well, but the [[Wave|wave]]-mechanical [[Leak|leak]] through the Coulomb barrier produces a small but nonzero escape rate. Gamow's 1928 calculation tied the [[Half-life|half-life]] to the barrier penetration probability and reproduced the empirical Geiger-Nuttall rule, which links the decay constant lambda to the alpha kinetic energy through log lambda = a - b/sqrt(E_alpha). Half-lives span thirty orders of magnitude across the chart of the nuclides, from microseconds for [[Proton|proton]]-rich isotopes to billions of years for [[Thorium|thorium]]-232 and uranium-238.
## See also
- Room hub: Nuclear
- p5.js Editor conventions: P5 JS EDITOR
- Wiki root: MAIN
---
*Scaffolded by `generative-microsim` from row 0 of the Nuclear sheet on 2026-04-30T07:39:16Z.*
Letters: lattice · exponential · probability · energy · stability · transformation · wave · clock_time
<!-- REAL-GENERATIVE-MEDIA:START -->
<!-- CRAFT-LINK:START g12 -->
*Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*
<!-- CRAFT-LINK:END -->
## Wikipedia : Wikitube
**Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Alpha_decay) : [Wikitube](https://en.wikitube.io/wiki/Alpha_decay)
## Previous hub tags
Tree parents: [[Helium]] · [[Helium-3]].
Legacy hubs: `GENERATIVE`.
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*