# Damping
## Microsim
### Live player
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/fZGuoWUHS" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
</div>
<div class="microsim-fallback">
<img src="Microsims/thumbs/Damping.png" alt="Damping 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/fZGuoWUHS">open sketch in the p5.js editor</a></em></p>
</div>
**Editor URL:** https://editor.p5js.org/sciencenibber/sketches/fZGuoWUHS
**Description (100 words):**
A live single-degree-of-freedom mass-spring-damper integrated by [[Velocity|velocity]]-Verlet under `m x'' + c x' + k x = 0`. Five sliders set mass, stiffness, damping, and the initial state `(x0, v0)`; four buttons jump the reader straight to the textbook regimes — under, critical, over — by writing the right `c` into the slider. Four panels share the canvas: the rig (wall, spring, mass, dashpot, live `F = -k x` arrow), the `(x, v)` phase portrait, an `x(t)` scope with the analytic envelope `+/- A0 exp(-zeta omega_0 t)` overlaid in dashes, and the energy decay `E(t) = KE + PE` bleeding to zero.
```js
// =====================================================================
// Wikitube microsim - Damping
// Slug: Damping
// URL: en.wikitube.io/wiki/Damping
// Pattern: A reskin - Classical mechanics constructions (Energy room)
//
// What it shows
// The free (unforced) single-degree-of-freedom mass-spring-damper
//
// m x'' + c x' + k x = 0
//
// integrated by velocity-Verlet, with the dimensionless damping
// ratio zeta = c / (2 sqrt(m k)) driving the entire qualitative
// character of the response. The three classical regimes are made
// visible side by side:
//
// - underdamped (zeta < 1) oscillates inside an exponential
// envelope at the damped natural
// frequency omega_d = omega_0
// sqrt(1 - zeta^2)
// - critically damped (zeta = 1) returns to equilibrium in the
// shortest possible time without
// overshoot
// - overdamped (zeta > 1) returns slowly via two real
// exponential modes, no oscillation
//
// Panels
// - top-left the rig: wall, hatching, spring, mass body,
// and a dashpot whose piston offset tracks v
// - top-right phase portrait in (x, v), spiraling (or sliding)
// into the origin under the chosen damping
// - bottom-left x(t) scope with the analytic exponential envelope
// A0 * exp(-zeta omega_0 t) overlaid in dashes
// - bottom-right energy decay E(t) = KE + PE drawn linearly,
// bleeding to zero when zeta > 0
//
// Live readouts (bottom-left, before the slider band)
// omega_0 = sqrt(k/m) undamped natural frequency
// zeta = c / (2 sqrt(m k)) damping ratio
// omega_d = omega_0 sqrt(1 - z^2) damped natural frequency
// T_d = 2 pi / omega_d damped period
// delta = 2 pi zeta / sqrt(1 - z^2) logarithmic decrement
// regime underdamped / critical / overdamped label
//
// Pattern A reskin (Energy room)
// The mass is rendered as a labelled rectangular body; the spring
// force and dashpot drag arrows draw as live vectors; gauges show
// energies; in the underdamped case the phase orbit visibly spirals
// inward, in the critical case it slides smoothly to the origin,
// and in the overdamped case the trajectory is two real exponentials
// sliding to zero from above (or below).
//
// Pitfall guards (Skills/P5js Microsim Standards/pitfalls.md)
// - p5.disableFriendlyErrors = true (no FES noise)
// - all canvas-side strings ASCII; Unicode lives only in comments
// - sliders sit in a dedicated bottom band so the slider thumb does
// not float over readout text (cf. Menelaus's_theorem layout)
// - buttons given enough x-spacing that label text never overlaps
// - "critical" preset button avoids a slider hunt for c = 2 sqrt(m k)
// =====================================================================
const ARTICLE = "Damping";
p5.disableFriendlyErrors = true;
// ---------- Energy palette (Articles/P5_JS_EDITOR.md, section 4) -----
const BG = 18;
const FG = 240;
const HOT = [220, 110, 60]; // spring restoring force arrow
const COLD = [ 60, 130, 220]; // x(t) trace, phase orbit
const STRUCT = [120, 130, 150]; // wall, axes, structural lines
const TRAJ = [240, 220, 80]; // mass body, current-state dot
const GAUGE = [120, 220, 140]; // velocity, total energy bar
const ENVL = [200, 200, 200]; // exponential envelope dashes
// ---------- Controls (created in setup) ------------------------------
let mSlider, kSlider, cSlider, x0Slider, v0Slider;
let resetBtn, critBtn, overBtn, underBtn;
// ---------- State ----------------------------------------------------
let x = 1.0; // displacement (m)
let v = 0.0; // velocity (m/s)
let t = 0; // simulation time (s)
let A0 = 1.0; // initial-amplitude estimate for the envelope
const buf = []; // ring buffer of {t, x, v, E} for scope and phase
function setup() {
createCanvas(windowWidth, windowHeight);
pixelDensity(2);
// physics-parameter band along the left edge of the bottom strip
mSlider = createSlider(0.2, 5.0, 1.0, 0.05).position(20, height - 130).size(180);
kSlider = createSlider(0.5, 24.0, 4.0, 0.10).position(20, height - 105).size(180);
cSlider = createSlider(0.0, 8.0, 0.6, 0.02).position(20, height - 80).size(180);
x0Slider = createSlider(-2.0, 2.0, 1.0, 0.05).position(20, height - 55).size(180);
v0Slider = createSlider(-4.0, 4.0, 0.0, 0.05).position(20, height - 30).size(180);
// input row of buttons. Each preset writes a c value into cSlider so
// the reader can step instantly to the textbook regime.
resetBtn = createButton("reset").position(220, height - 30);
resetBtn.mousePressed(reseed);
underBtn = createButton("under").position(280, height - 30);
underBtn.mousePressed(() => {
const m = mSlider.value(), k = kSlider.value();
cSlider.value(0.3 * 2 * sqrt(m * k)); // zeta ~ 0.3
reseed();
});
critBtn = createButton("critical").position(345, height - 30);
critBtn.mousePressed(() => {
const m = mSlider.value(), k = kSlider.value();
cSlider.value(2 * sqrt(m * k)); // zeta = 1
reseed();
});
overBtn = createButton("over").position(425, height - 30);
overBtn.mousePressed(() => {
const m = mSlider.value(), k = kSlider.value();
cSlider.value(2.0 * 2 * sqrt(m * k)); // zeta = 2
reseed();
});
reseed();
}
function reseed() {
x = x0Slider ? x0Slider.value() : 1.0;
v = v0Slider ? v0Slider.value() : 0.0;
t = 0;
buf.length = 0;
// amplitude proxy for the analytic envelope. Total energy at t=0 maps
// to an effective initial amplitude A0 = sqrt(x0^2 + (v0/omega_0)^2)
// which is exact for the undamped oscillator.
const m = mSlider ? mSlider.value() : 1;
const k = kSlider ? kSlider.value() : 4;
const omega0 = sqrt(k / m);
A0 = sqrt(x * x + (omega0 > 0 ? (v / omega0) * (v / omega0) : 0));
if (A0 < 0.05) A0 = 0.05;
}
function draw() {
background(BG);
// Read every control once into named locals so the integrator below
// reads as physics, not as UI plumbing.
const m = mSlider.value();
const k = kSlider.value();
const c = cSlider.value();
// Velocity-Verlet integration of m x'' + c x' + k x = 0.
// For pure linear damping this is symplectic-ish on the conservative
// term and stable on the dissipation term; under critical and over-
// damping the trajectory is monotone and forgiving of dt.
const dt = min(deltaTime / 1000, 0.05);
const a1 = (-k * x - c * v) / m;
v += a1 * dt * 0.5;
x += v * dt;
t += dt;
const a2 = (-k * x - c * v) / m;
v += a2 * dt * 0.5;
const KE = 0.5 * m * v * v;
const PE = 0.5 * k * x * x;
const E = KE + PE;
buf.push({ t, x, v, E });
if (buf.length > 900) buf.shift();
// ---------- panel layout -------------------------------------------
const padL = 240; // left band reserved for sliders+labels
const padR = 20, padT = 80, padB = 170;
const W = max(40, width - padL - padR);
const H = max(40, height - padT - padB);
const halfW = W / 2 - 10;
const halfH = H / 2 - 10;
drawRig (padL, padT, halfW, halfH, x, v, k);
drawPhase(padL + halfW + 20, padT, halfW, halfH);
drawScope(padL, padT + halfH + 20, halfW, halfH, m, k, c);
drawEnergy(padL + halfW + 20, padT + halfH + 20, halfW, halfH);
drawSliderLabels();
drawReadouts(m, k, c);
drawHud();
}
// =====================================================================
// drawRig - wall + spring + mass + dashpot + restoring force arrow
// =====================================================================
function drawRig(x0, y0, w, h, dx, dv, k) {
push();
translate(x0, y0);
// panel border
noFill(); stroke(...STRUCT, 70); strokeWeight(1);
rect(0, 0, w, h);
const cy = h * 0.55;
const wallX = 30;
// map physical x in [-2, 2] m into pixel offset
const massX = constrain(w * 0.55 + dx * 70, wallX + 60, w - 30);
// wall (with hatching)
stroke(...STRUCT); strokeWeight(3); noFill();
line(wallX, cy - 60, wallX, cy + 60);
for (let i = 0; i < 6; i++) {
line(wallX - 8, cy - 60 + i * 24, wallX, cy - 48 + i * 24);
}
// spring as a 16-segment zigzag connecting the wall to the mass
const N = 16;
beginShape();
for (let i = 0; i <= N; i++) {
const px = lerp(wallX, massX - 26, i / N);
const py = cy - 14 + ((i > 0 && i < N) ? (i % 2 ? 10 : -10) : 0);
vertex(px, py);
}
endShape();
// dashpot underneath: barrel + piston rod whose offset tracks v.
// The fill bar visually encodes the dissipative-force magnitude.
push();
stroke(...STRUCT); strokeWeight(2); noFill();
const dy = cy + 24;
rect(wallX + 30, dy - 8, 70, 16);
line(wallX + 100, dy, massX - 26, dy);
fill(GAUGE[0], GAUGE[1], GAUGE[2], 110); noStroke();
rect(wallX + 30, dy - 6, constrain(map(dv, -3, 3, 0, 70), 0, 70), 12);
pop();
// mass body
fill(...TRAJ); noStroke();
rectMode(CENTER);
rect(massX, cy, 40, 40, 4);
rectMode(CORNER);
// restoring-force arrow (= -k x) drawn out of the top of the mass.
// The arrow flips sign with x and shrinks as x heads to zero, which
// is the whole story of free-decay made visible.
const Frest = -k * dx;
const arrowLen = constrain(Frest * 2.5, -80, 80);
if (abs(arrowLen) > 2) {
stroke(...HOT); strokeWeight(3); noFill();
line(massX, cy - 26, massX + arrowLen, cy - 26);
const sgn = arrowLen > 0 ? 1 : -1;
line(massX + arrowLen, cy - 26, massX + arrowLen - 8 * sgn, cy - 31);
line(massX + arrowLen, cy - 26, massX + arrowLen - 8 * sgn, cy - 21);
}
// labels inside the panel
noStroke(); fill(...STRUCT); textSize(11); textAlign(LEFT, TOP);
text("rig", 8, 6);
textAlign(LEFT, BOTTOM);
text("F = -k x", massX - 26, cy - 30);
text("m", massX - 4, cy + 4);
text("dashpot c", wallX + 32, dy + 22);
textAlign(LEFT, TOP);
pop();
}
// =====================================================================
// drawPhase - phase portrait in (x, v)
// =====================================================================
function drawPhase(x0, y0, w, h) {
push();
translate(x0, y0);
noFill(); stroke(...STRUCT, 70); strokeWeight(1);
rect(0, 0, w, h);
stroke(...STRUCT, 60);
line(0, h / 2, w, h / 2);
line(w / 2, 0, w / 2, h);
if (buf.length >= 2) {
stroke(...COLD); strokeWeight(1.2); noFill();
beginShape();
for (const s of buf) {
vertex(map(s.x, -3, 3, 0, w), map(s.v, -6, 6, h, 0));
}
endShape();
}
// current-state dot
noStroke(); fill(...TRAJ);
ellipse(map(x, -3, 3, 0, w), map(v, -6, 6, h, 0), 7);
noStroke(); fill(...STRUCT); textSize(11); textAlign(LEFT, TOP);
text("phase (x, v)", 8, 6);
textAlign(RIGHT, BOTTOM);
text("x", w - 8, h / 2 - 4);
textAlign(LEFT, TOP);
text("v", w / 2 + 6, 8);
pop();
}
// =====================================================================
// drawScope - x(t) with the analytic exponential envelope overlaid
// under-damping: envelope = +/- A0 * exp(-zeta * omega_0 * t)
// critical: envelope = +/- A0 * exp(-omega_0 * t) * (1 + omega_0 t)
// over-damping: envelope is the slower exponential of the two roots
// =====================================================================
function drawScope(x0, y0, w, h, m, k, c) {
push();
translate(x0, y0);
noFill(); stroke(...STRUCT, 70); strokeWeight(1);
rect(0, 0, w, h);
stroke(...STRUCT, 60);
line(0, h / 2, w, h / 2);
if (buf.length >= 2) {
const tMin = buf[0].t, tMax = buf[buf.length - 1].t;
const omega0 = sqrt(k / max(0.0001, m));
const zeta = c / max(0.0001, 2 * sqrt(m * k));
// x(t) trace
stroke(...COLD); strokeWeight(1.6); noFill();
beginShape();
for (const s of buf) {
vertex(map(s.t, tMin, tMax, 0, w), map(s.x, -3, 3, h, 0));
}
endShape();
// analytic envelope. For any zeta we draw the slower of the two
// exponentials so the curve always bounds the actual response.
let envFn;
if (zeta < 1) {
const lam = zeta * omega0;
envFn = (tt) => A0 * exp(-lam * tt);
} else if (abs(zeta - 1) < 1e-3) {
envFn = (tt) => A0 * exp(-omega0 * tt) * (1 + omega0 * tt);
} else {
// overdamped: roots r = -zeta omega_0 +/- omega_0 sqrt(z^2 - 1)
const root1 = -zeta * omega0 + omega0 * sqrt(zeta * zeta - 1);
// root1 is the less negative (slower) root; use it as the envelope
envFn = (tt) => A0 * exp(root1 * tt);
}
drawDashedEnvelope(envFn, tMin, tMax, w, h, +1);
drawDashedEnvelope(envFn, tMin, tMax, w, h, -1);
}
noStroke(); fill(...STRUCT); textSize(11); textAlign(LEFT, TOP);
text("scope x(t) blue envelope grey dashes", 8, 6);
pop();
}
// Helper: a dashed exponential envelope drawn point-by-point.
// `sign` is +/- 1 to mirror the upper and lower bounds.
function drawDashedEnvelope(envFn, tMin, tMax, w, h, sign) {
stroke(...ENVL, 180); strokeWeight(1);
noFill();
const steps = 80;
for (let i = 0; i < steps; i += 2) { // every other segment -> dashes
const a = i / steps, b = (i + 1) / steps;
const tA = lerp(tMin, tMax, a), tB = lerp(tMin, tMax, b);
const yA = sign * envFn(tA - tMin);
const yB = sign * envFn(tB - tMin);
line(map(tA, tMin, tMax, 0, w), map(yA, -3, 3, h, 0),
map(tB, tMin, tMax, 0, w), map(yB, -3, 3, h, 0));
}
}
// =====================================================================
// drawEnergy - total mechanical energy E(t) = KE + PE bleeding to zero
// =====================================================================
function drawEnergy(x0, y0, w, h) {
push();
translate(x0, y0);
noFill(); stroke(...STRUCT, 70); strokeWeight(1);
rect(0, 0, w, h);
if (buf.length >= 2) {
const tMin = buf[0].t, tMax = buf[buf.length - 1].t;
let Emax = 1e-6;
for (const s of buf) Emax = max(Emax, s.E);
// grid: a faint horizontal at half-energy
stroke(...STRUCT, 50);
line(0, h / 2, w, h / 2);
// energy curve
stroke(...GAUGE); strokeWeight(1.6); noFill();
beginShape();
for (const s of buf) {
vertex(map(s.t, tMin, tMax, 0, w),
map(s.E, 0, Emax, h - 14, 12));
}
endShape();
// axes hints
noStroke(); fill(...STRUCT); textSize(10); textAlign(LEFT, BOTTOM);
text("E_max = " + nf(Emax, 1, 2), 8, h - 4);
}
noStroke(); fill(...STRUCT); textSize(11); textAlign(LEFT, TOP);
text("energy E(t) = KE + PE", 8, 6);
pop();
}
// =====================================================================
// drawSliderLabels - labels for the left-band slider strip
// =====================================================================
function drawSliderLabels() {
noStroke(); fill(...STRUCT); textSize(12); textAlign(LEFT, CENTER);
text("m (kg)", 210, height - 130 + 10);
text("k (N/m)", 210, height - 105 + 10);
text("c (N s/m)", 210, height - 80 + 10);
text("x0 (m)", 210, height - 55 + 10);
text("v0 (m/s)", 210, height - 30 + 10);
textAlign(LEFT, TOP);
}
// =====================================================================
// drawReadouts - bottom-left numeric readouts in canonical symbols
// =====================================================================
function drawReadouts(m, k, c) {
const omega0 = sqrt(k / max(0.0001, m));
const zeta = c / max(0.0001, 2 * sqrt(m * k));
const omegaD = zeta < 1 ? omega0 * sqrt(1 - zeta * zeta) : 0;
const Td = omegaD > 0 ? (2 * PI) / omegaD : 0;
const delta = zeta < 1 ? (2 * PI * zeta) / sqrt(1 - zeta * zeta) : 0;
const KE = 0.5 * m * v * v;
const PE = 0.5 * k * x * x;
const E = KE + PE;
let regime = "underdamped";
if (abs(zeta - 1) < 0.02) regime = "critical";
else if (zeta > 1) regime = "overdamped";
noStroke(); fill(FG); textSize(12); textAlign(LEFT, BOTTOM);
const yTop = height - 152;
text("omega_0 = " + nf(omega0, 1, 2)
+ " zeta = " + nf(zeta, 1, 3)
+ " " + regime, 20, yTop);
text("omega_d = " + nf(omegaD, 1, 2)
+ " T_d = " + (Td > 0 ? nf(Td, 1, 2) + " s" : "n/a"),
20, yTop + 16);
text("delta = " + (delta > 0 ? nf(delta, 1, 3) : "n/a")
+ " x = " + nf(x, 1, 2)
+ " v = " + nf(v, 1, 2), 20, yTop + 32);
text("KE = " + nf(KE, 1, 2)
+ " PE = " + nf(PE, 1, 2)
+ " E = " + nf(E, 1, 2), 20, yTop + 48);
textAlign(LEFT, TOP);
}
// =====================================================================
// drawHud - the four-corner Wikitube watermark
// =====================================================================
function drawHud() {
// top-left title block
noStroke(); fill(0, 180); rect(8, 8, 380, 38);
fill(255); textSize(14); textAlign(LEFT, TOP);
text("Damping", 16, 12);
fill(180); textSize(11);
text("Wikitube microsim - en.wikitube.io/wiki/" + ARTICLE, 16, 30);
// top-right control hints
fill(180); textSize(11); textAlign(RIGHT, TOP);
text("sliders: m, k, c, x0, v0", width - 16, 12);
text("buttons: reset, under, critical, over", width - 16, 26);
text("envelope = +/- A0 exp(-zeta omega_0 t)", width - 16, 40);
// bottom-right equation footer
textAlign(RIGHT, BOTTOM); fill(200); textSize(11);
text("m x'' + c x' + k x = 0 zeta = c / (2 sqrt(m k)) omega_d = omega_0 sqrt(1 - z^2)",
width - 16, height - 8);
textAlign(LEFT, TOP);
}
// =====================================================================
// windowResized - keep slider band glued to the bottom of the viewport
// =====================================================================
function windowResized() {
resizeCanvas(windowWidth, windowHeight);
if (mSlider) {
mSlider .position(20, height - 130);
kSlider .position(20, height - 105);
cSlider .position(20, height - 80);
x0Slider.position(20, height - 55);
v0Slider.position(20, height - 30);
resetBtn.position(220, height - 30);
underBtn.position(280, height - 30);
critBtn .position(345, height - 30);
overBtn .position(425, height - 30);
}
}
```
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Damping.json (2026-07-30T02:09:12Z) -->
`Acceleration` · `Alexis_Clairaut` · [[Alternating_current]] · `Analytical_mechanics` · `Angular_acceleration` · `Angular_displacement` · [[Angular_frequency]] · `Angular_momentum` · `Angular_velocity` · `Appell's_equation_of_motion` · `Applied_mechanics` · `Attenuation` · `Augustin-Louis_Cauchy` · `Bernard_Koopman` · `Bicycle_and_motorcycle_dynamics` · `Carl_Gustav_Jacob_Jacobi` · `Celestial_mechanics` · `Centrifugal_force` · `Centripetal_force` · [[Chemical_engineering]] · [[Christiaan_Huygens]] · `Circular_motion` · `Classical_field_theory` · `Classical_mechanics` · `Complex_conjugate` · `Complex_number` · `Continuum_mechanics` · [[Control_engineering]] · [[Control_theory]] · `Coriolis_force` · `Couple_(mechanics)` · `D'Alembert's_principle` · `Damped_wave_(radio_transmission)` · `Damping_(disambiguation)` · `Damping_capacity` · `Daniel_Bernoulli` · `Dashpot` · [[Differential_equation]] · `Displacement_(geometry)` · `Dissipation` · `Drag_(physics)` · [[Dynamics_(mechanics)]] · `E_(mathematical_constant)` · [[Ecology]] · `Eddy_current` · `Eddy_current_brake` · `Edmond_Halley` · `Edward_Routh` · [[Electric_motor]] · [[Electrical_engineering]] · `Electrical_resistance_and_conductance` · `Electromagnetic_induction` · [[Energy]] · [[Engineering]] · `Equations_of_motion` · `Euler's_equations_(rigid_body_dynamics)` · `Euler's_laws_of_motion` · `Exponential_decay` · `Fictitious_force` · [[Force]] · `Frame_of_reference` · `Frequency` · `Friction` · `Galileo_Galilei` · [[Half-life]] · `Hamiltonian_mechanics` · `Hamilton–Jacobi_equation` · `Harmonic_oscillator` · `Hertz` · `History_of_classical_mechanics` · `Impulse_(physics)` · `Inertia` · `Inertial_frame_of_reference` · [[Isaac_Newton]] · `Jeremiah_Horrocks` · `Johann_Bernoulli` · [[Johannes_Kepler]] · [[John_von_Neumann]] · `Joseph-Louis_Lagrange` · `Joseph_Liouville` · [[Josiah_Willard_Gibbs]] · `Kinematics` · `Kinetic_energy` · `Kinetics_(physics)` · `Koopman–von_Neumann_classical_mechanics` · `Lagrangian_mechanics` · `Leonhard_Euler` · `Linear_motion` · `List_of_textbooks_on_classical_mechanics_and_quantum_mechanics` · `Logarithmic_decrement` · `Magnetic_damping` · `Magnetic_flux` · `Magnetorheological_damper` · `Magnetorheological_fluid` · `Mass` · `Mass-spring-damper_model` · [[Mechanical_engineering]] · `Moment_(physics)` · `Moment_of_inertia` · `Momentum` · `Motion` · `Natural_frequency` · `Newton's_law_of_universal_gravitation` · [[Newton's_laws_of_motion]] · `Non-inertial_reference_frame` · `Overshoot_(signal)` · `Paul_Émile_Appell` · `Pendulum_(mechanics)` · [[Physical_system]] · `Pierre-Simon_Laplace` · `Pierre_Louis_Maupertuis` · `Potential_energy` · `Q_factor` · `Radiation` · `Reactive_centrifugal_force` · `Relative_velocity` · `Rigid_body` · `Rigid_body_dynamics` · `Rotating_reference_frame` · `Rotation_around_a_fixed_axis` · `Rotational_frequency` · `Routhian_mechanics` · [[Science]] · [[Simple_harmonic_motion]] · `Siméon_Denis_Poisson` · [[Sine_wave]] · `Space` · `Speed` · `Statics` · `Statistical_mechanics` · `Step_response` · [[Structural_engineering]] · `Suspension_(mechanics)` · `Tangential_speed` · `Time` · `Time_constant` · `Timeline_of_classical_mechanics` · `Torque` · `Tuning_fork` · [[Velocity]] · `Vibration` · `Virtual_work` · [[Viscosity]] · `Viscous_damping` · `Weighing_scale` · `William_Rowan_Hamilton` · `Work_(physics)` · `YouTube` · `Zeta`
## Media (PD/CC)
<!-- MEDIA-DEPLOY:Damping/Damped_spring.gif -->
!Gif Library/Damping/Damped spring.gif
*Damped_spring.gif · Public domain*
<!-- /MEDIA-DEPLOY -->
<!-- SIGN-SYSTEMS:START -->
**Semiotic universals** (the notations and alphabet letters this article speaks — each opens its canonical card): acoustic diagrams · damping · energy · exponential · oscillation. Index: the glyph gallery · SEMIOTICS PORTAL.
<!-- SIGN-SYSTEMS:END -->
> **Room:** [[Energy]] · **Status:** ✅ shipped
## Overview
Damping is the mechanism by which an oscillating [[System|system]] converts mechanical energy into heat (or radiation, or acoustic loss) and so settles back toward equilibrium after disturbance. In the canonical single-degree-of-freedom mass-spring model `m*x_ddot + c*x_dot + k*x = 0`, the damping coefficient `c` controls the entire qualitative character of the response through the dimensionless damping ratio `zeta = c / (2*sqrt(m*k))`. Three regimes exhaust the possibilities: **underdamped** (`zeta < 1`) oscillates at the damped natural frequency `omega_d = omega_0 * sqrt(1 - zeta^2)` with an envelope that decays as `exp(-zeta*omega_0*t)`; **critically damped** (`zeta = 1`) returns to equilibrium in the shortest possible time without overshoot; **overdamped** (`zeta > 1`) returns slowly via two real exponential modes. The logarithmic decrement `delta = ln(x_n / x_{n+1}) = 2*pi*zeta / sqrt(1 - zeta^2)` lets engineers measure `zeta` from a free-vibration record by counting peak amplitudes. Real losses arrive as viscous damping (dashpots, fluid drag), Coulomb friction (constant-magnitude opposing [[Force|force]]), structural damping (hysteresis in the material), and radiation damping (energy lost to surrounding waves). Designers tune it deliberately: shock absorbers near critical, seismic isolators light, instrument needles critical for fast unambiguous reading.
## See also
- Room hub: [[Energy]]
- p5.js Editor conventions: P5 JS EDITOR
- Wiki root: MAIN
---
*Scaffolded by `generative-microsim` from row 0 of the Energy sheet on 2026-04-30T08:23:30Z.*
Letters: damping · energy · exponential · oscillation · amplitude · frequency · equilibrium · flow
<!-- CRAFT-LINK:START g12 -->
*Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*
<!-- CRAFT-LINK:END -->
<!-- SPINEPATH:BEGIN g20 — shortest chain of Wikipedia links between local articles to a Compendium Main article; do not hand-edit inside -->
*Connected to the Apex Spine:* Damping → [[Viscosity|Viscosity]] — [[WT!Thury_Hydrodynamics_Compendium|Compendium]] section 24, *Thick fluids and pipe flow*.
<!-- SPINEPATH:END -->
<!-- ACOUSIM:BEGIN g22 — Acoustics portal microsim (framework build, specs/acoustics/variants/Damping.json); do not hand-edit inside -->
**Microsim — three.js (Wikitube framework):** *Damping*
<div class="wt-sim" data-src="https://wikitube-3d-microsims.netlify.app/acoustics/Damping.html" data-title="Damping"></div>
*Built from `MICROSIM_GUIDE/specs/acoustics/variants/Damping.json`; part of the [[PORTAL_Acoustics|Acoustics portal]] spine (section sims and See-also variants).*
<!-- ACOUSIM:END -->
## Wikipedia : Wikitube
**Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Damping) : [Wikitube](https://en.wikitube.io/wiki/Damping)
## Previous hub tags
Tree parent: [[Complex_system]].
Legacy hubs: `GENERATIVE`.
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*