# Dynamics (mechanics)
<!-- MICROSIMGEN:BEGIN v1.7 — generated by g08_place_microsims.py; three.js first (§15); do not hand-edit inside -->
## Microsims — p5.js
### Dynamics (mechanics) (p5.js)
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/TrjZRL5AZ" width="100%" height="480" frameborder="0" loading="lazy" sandbox="allow-scripts allow-same-origin" title="Dynamics (mechanics) — p5.js microsim"></iframe>
</div>
*Dynamics as Newton's second law in action: apply an unbalanced force to a mass and watch ΣF = m·a set its acceleration, velocity, and path.*
**Open in the editor:** [▶ fork this sketch](https://editor.p5js.org/sciencenibber/sketches/TrjZRL5AZ) · library `p5js`
*Sim hosted off-article; the article owns the reference, not the runtime (WIKI_RULES §10.4). Placed by `g08_place_microsims.py`.*
<!-- g09-shelf-note -->
> **Also on this page:** 1 further p5.js sketch already published for this article live further down. Per WIKI_RULES §5 a collision promotes rather than forks — they are one shelf, not rivals; this block is the §10.4 *current best* reference.
<!-- MICROSIMGEN:END -->
## Microsim
### Live player
<div class="microsim-player">
<iframe src="https://editor.p5js.org/sciencenibber/full/wEl75DPti" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
</div>
<div class="microsim-fallback">
<img src="Microsims/thumbs/Dynamics_(mechanics).png" alt="Dynamics_(mechanics) 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/wEl75DPti">open sketch in the p5.js editor</a></em></p>
</div>
**Editor URL:** https://editor.p5js.org/sciencenibber/sketches/wEl75DPti
**Description (100 words):**
A 5 kg block rests on an incline of angle theta against kinetic friction mu, with an optional user push F applied along the slope. Three sliders drive theta (0–60 deg), mu (0–1), and F (±50 N). Each frame the sketch draws the four free-body forces — gravity (red), normal (blue), friction (green), applied (magenta) — and integrates Newton's 2nd law a = (F − m·g·sin θ − μ·N·sign v)/m forward-Euler at dt = 0.02 s. A static-friction switch holds the block when |Fdrive| ≤ μN to avoid chatter. A position-time scope inset traces s(t); a reset button returns the block to the top.
```js
// =====================================================================
// Dynamics_(mechanics).js — Wikitube microsim
// Article: Dynamics_(mechanics)
// en.wikitube.io/wiki/Dynamics_(mechanics)
// Room: Engineering Pattern: A reskin (FBD + Newton's 2nd law)
// ---------------------------------------------------------------------
// Idea: a rigid block of mass m sits on a flat incline of angle theta.
// Gravity pulls it down, the surface pushes back as a normal force,
// kinetic friction opposes its motion along the slope, and the user
// may apply an extra parallel push F (positive = up the slope).
//
// The reader scrubs three sliders (theta, mu, F) and watches:
//
// * the incline tilt and the block translate along the surface
// driven by forward-Euler integration of Newton's 2nd law,
// * the free-body diagram on the block render the four forces
// (gravity, normal, friction, applied) as labelled arrows,
// * a strip-chart inset (Pattern H) plot the block's position
// s(t) along the slope so motion vs. equilibrium is visible,
// * a readout of the net force, acceleration, velocity, and
// position with the equation of motion below.
//
// The single governing equation is the entire content of dynamics:
//
// sum F = m * a (Newton's 2nd law, vector form)
//
// Resolved along the slope (positive = up the slope), with the body
// free to slide:
//
// a = ( F - m * g * sin(theta) - mu * N * sign(v) ) / m
// N = m * g * cos(theta) (normal force balance)
//
// When the block is momentarily at rest (|v| ~ 0), kinetic friction
// switches to static friction: if the magnitude of the driving force
// along the slope is less than mu * N, friction adjusts to hold the
// block stationary and a = 0 (this avoids the classic forward-Euler
// "chatter" near zero velocity).
//
// Color codes (Engineering palette from P5_JS_EDITOR section 12):
// LOAD red -> gravity vector m*g (always vertical)
// REACT blue -> normal force N (perpendicular to slope)
// COMP green -> kinetic friction f_k (along slope)
// COUPLE magenta -> user-applied force F (along slope)
// STRUCT grey -> incline silhouette, ground hatch, block
// BG near-white background (Engineering reads like blueprints)
//
// All non-ASCII characters live in COMMENTS ONLY. Inside string
// literals and text() arguments we use ASCII (sigma -> "sum",
// theta -> "theta", mu -> "mu", subscripts -> "_x") because the
// p5.js Web Editor preview pipeline mangles non-ASCII in string
// positions (see Skills/.../pitfalls.md, 2026-04-30 entries).
// =====================================================================
const ARTICLE = "Dynamics_(mechanics)";
p5.disableFriendlyErrors = true;
// ----- Sliders (real-world parameter ranges, not pixel values) -------
let thetaSlider; // incline angle, degrees (0..60)
let muSlider; // kinetic friction coefficient (0..1)
let fSlider; // applied parallel force, N (-50..+50, +up-slope)
let resetBtn; // re-place block at top of slope
// ----- Layout constants (computed in setup() from canvas size) -------
let pivotX, pivotY; // pin point of the incline (top-of-slope hinge)
let slopeLen; // visible incline length, pixels
// ----- Physical constants --------------------------------------------
const m = 5.0; // block mass, kg
const g = 9.81; // gravity, m/s^2
const Lm = 4.0; // incline length used for the math, metres
const dt = 0.02; // integration time-step, s (50 Hz)
const eps = 1e-3; // velocity threshold for static-friction switch
// ----- Engineering palette (P5_JS_EDITOR section 12) -----------------
const STRUCT = [80, 90, 110];
const LOAD = [220, 60, 60];
const REACT = [60, 130, 220];
const COMP = [60, 180, 90];
const COUPLE = [180, 60, 200];
// ----- Simulation state (forward-Euler integrator) -------------------
let s, v; // block position (m, along slope) and velocity (m/s)
const sMax = Lm; // upper bound: top of slope (block falls off above)
const sMin = 0.0; // lower bound: bottom of slope (block stops here)
// ----- Strip-chart ring buffer (Pattern H scope inset) ---------------
const N_SAMP = 240;
let scopeBuf; // array of position samples
let scopeIdx; // ring-buffer write head
function setup() {
// Canvas size matches the Wikitube standard (720x520).
// pixelDensity(2) keeps text and edges crisp on retina screens.
createCanvas(720, 520);
pixelDensity(2);
// Incline geometry: hinge at lower-left, slope going up to the right.
// We re-derive the incline endpoints each frame so a slider tilt
// animates the wedge in place.
pivotX = 110;
pivotY = 360;
slopeLen = 380; // 4 m of math span -> 380 px on screen
// Three sliders along the bottom-left, plus a reset button.
thetaSlider = createSlider(0, 60, 25, 1);
thetaSlider.position(20, height - 90);
thetaSlider.style("width", "200px");
muSlider = createSlider(0, 1, 0.20, 0.01);
muSlider.position(20, height - 60);
muSlider.style("width", "200px");
fSlider = createSlider(-50, 50, 0, 1);
fSlider.position(20, height - 30);
fSlider.style("width", "200px");
resetBtn = createButton("reset");
resetBtn.position(230, height - 30);
resetBtn.mousePressed(resetMotion);
// Initial state: block at top of slope, at rest.
resetMotion();
// Strip-chart buffer initialised to NaN so untouched samples don't
// contaminate the polyline before the buffer fills up.
scopeBuf = new Array(N_SAMP).fill(NaN);
scopeIdx = 0;
}
function resetMotion() {
s = sMax; // block at top of slope
v = 0.0; // initially at rest
}
function draw() {
// ----- Read sliders ONCE at top of draw() (standard rule §6) ------
// Subsequent code references the named locals; the rest of draw()
// reads as physics rather than as DOM plumbing.
const thetaDeg = thetaSlider.value();
const theta = radians(thetaDeg);
const mu = muSlider.value();
const Fapp = fSlider.value(); // along-slope applied force, N
// ----- Newton's 2nd law along the slope ---------------------------
// Take +s direction = up the slope. The forces along the slope are:
// gravity component: - m * g * sin(theta) (always pulls down)
// applied force: + Fapp (up-slope if +)
// kinetic friction: - mu * N * sign(v) (opposes motion)
// The normal force balances the perpendicular gravity component:
// N = m * g * cos(theta) (no perp accel)
const N = m * g * cos(theta);
const Fgx = -m * g * sin(theta); // along-slope, signed
let Ffr = 0.0; // friction along slope, signed
let Fnet = 0.0; // total along slope, signed
let a = 0.0; // along-slope acceleration, m/s^2
if (abs(v) > eps) {
// moving -> kinetic friction opposes velocity direction
Ffr = -mu * N * Math.sign(v);
Fnet = Fgx + Fapp + Ffr;
a = Fnet / m;
} else {
// momentarily at rest -> test whether static friction can hold it.
// The driving force (gravity + applied) along the slope is Fdrv;
// if its magnitude does not exceed mu*N, static friction matches
// it exactly and the block stays put (a = 0). Otherwise the block
// breaks free with kinetic friction opposing the would-be motion.
const Fdrv = Fgx + Fapp;
if (abs(Fdrv) <= mu * N) {
Ffr = -Fdrv; // exact balance
Fnet = 0.0;
a = 0.0;
} else {
Ffr = -mu * N * Math.sign(Fdrv);
Fnet = Fdrv + Ffr;
a = Fnet / m;
}
}
// ----- Forward-Euler integration step -----------------------------
// s_{n+1} = s_n + v_n*dt v_{n+1} = v_n + a*dt
// Cap s within [sMin, sMax] and zero v on contact with either end so
// the strip chart shows a clean stop rather than an out-of-bounds run.
v += a * dt;
s += v * dt;
if (s <= sMin) { s = sMin; if (v < 0) v = 0; }
if (s >= sMax) { s = sMax; if (v > 0) v = 0; }
// ----- Push current position into the strip-chart ring buffer ----
scopeBuf[scopeIdx] = s;
scopeIdx = (scopeIdx + 1) % N_SAMP;
// ----- Background --------------------------------------------------
background(248);
// ----- Incline + ground hatch --------------------------------------
// The slope rises from (pivotX, pivotY) at the lower-left up and to
// the right by an angle theta. We draw the wedge as three corners.
const topX = pivotX + slopeLen * cos(theta);
const topY = pivotY - slopeLen * sin(theta);
noStroke();
fill(...STRUCT, 50);
triangle(pivotX, pivotY, topX, topY, topX, pivotY);
stroke(...STRUCT);
strokeWeight(2);
line(pivotX, pivotY, topX, topY); // slope surface
line(pivotX, pivotY, topX, pivotY); // ground baseline
drawGroundHatch(pivotX - 16, pivotY, slopeLen + 32, 12);
// ----- Block on the slope ------------------------------------------
// Map s (metres along slope) to pixel position along the slope unit
// vector. The block is a 28x18 rectangle drawn rotated to the slope.
const ux = cos(theta);
const uy = -sin(theta);
const blockX = pivotX + (s / Lm) * slopeLen * ux;
const blockY = pivotY + (s / Lm) * slopeLen * uy;
push();
translate(blockX, blockY);
rotate(-theta);
noStroke();
fill(...STRUCT);
rect(-16, -22, 32, 18, 3); // sit ON the slope (offset up)
pop();
// ----- Free-body arrows (centre = block centre, just above slope) -
// Center of the FBD floats slightly off the block to keep it readable
// even when the block sits at one end of the slope.
const cx = blockX + 18 * (-uy); // perpendicular off-slope offset
const cy = blockY + 18 * (ux);
drawFbd(cx, cy, theta, m, g, N, Fapp, Ffr);
// ----- Strip-chart inset (Pattern H position-time scope) -----------
drawScope(width - 250, 20, 230, 110, scopeBuf, scopeIdx, sMin, sMax);
// ----- HUD: title, URL, control hints, readouts, equation ----------
drawHud(thetaDeg, mu, Fapp, N, Fnet, a, v, s);
}
// ---------------------------------------------------------------------
// Free-body diagram on the block: four labelled force arrows.
// gravity (LOAD red) - vertical, magnitude m*g
// normal (REACT blue)- perpendicular to slope, magnitude N
// friction(COMP green)- along slope, magnitude |Ffr|, signed
// applied (COUPLE) - along slope, magnitude |Fapp|, signed
// All four are scaled to a common pixels-per-newton factor so the
// reader compares magnitudes by visual length.
// ---------------------------------------------------------------------
function drawFbd(cx, cy, theta, m, g, N, Fapp, Ffr) {
const k = 0.9; // pixels per newton (visual scaling factor)
// unit vectors: u = up-slope direction, n = surface-outward normal
const ux = cos(theta), uy = -sin(theta);
const nx = -uy, ny = ux;
// gravity: straight down, magnitude m*g
drawForceArrow(cx, cy, cx, cy + k * m * g, LOAD,
"mg = " + nf(m * g, 1, 1) + " N");
// normal: along +n, magnitude N
drawForceArrow(cx, cy, cx + k * N * nx, cy + k * N * ny, REACT,
"N = " + nf(N, 1, 1) + " N");
// friction: along +u with sign of Ffr
drawForceArrow(cx, cy, cx + k * Ffr * ux, cy + k * Ffr * uy, COMP,
"f = " + nf(Ffr, 1, 1) + " N");
// applied: along +u with sign of Fapp
drawForceArrow(cx, cy, cx + k * Fapp * ux, cy + k * Fapp * uy, COUPLE,
"F = " + nf(Fapp, 1, 1) + " N");
// small dot at the application point (block centre proxy)
noStroke();
fill(40);
circle(cx, cy, 5);
}
// ---------------------------------------------------------------------
// Force arrow: from (x1,y1) to (x2,y2), coloured, with a label at the
// arrow's TIP. Skips drawing if the magnitude is below 1 px to avoid
// dot-and-degenerate-triangle artefacts when a force is near-zero.
// ---------------------------------------------------------------------
function drawForceArrow(x1, y1, x2, y2, col, label) {
const dx = x2 - x1, dy = y2 - y1;
const L = sqrt(dx * dx + dy * dy);
if (L < 1.5) return;
stroke(...col);
strokeWeight(2.5);
fill(...col);
line(x1, y1, x2, y2);
push();
translate(x2, y2);
rotate(atan2(dy, dx));
noStroke();
triangle(0, 0, -8, -4, -8, 4);
pop();
noStroke();
fill(...col);
textSize(10);
textAlign(LEFT, CENTER);
text(label, x2 + 6, y2);
}
// ---------------------------------------------------------------------
// Pattern H strip-chart: ring buffer of position samples plotted as a
// polyline against a labelled grid. The current write head is rendered
// as a vertical cursor so the reader can read "now" off the trace.
// ---------------------------------------------------------------------
function drawScope(x, y, w, h, buf, head, yMin, yMax) {
// outer panel
noStroke();
fill(255);
rect(x, y, w, h, 4);
stroke(...STRUCT, 120);
strokeWeight(1);
noFill();
rect(x, y, w, h, 4);
// gridlines (3 horizontal)
for (let i = 1; i < 3; i++) {
const yy = y + (i * h) / 3;
line(x, yy, x + w, yy);
}
// polyline through ring buffer (oldest..newest)
noFill();
stroke(...REACT);
strokeWeight(1.5);
beginShape();
for (let i = 0; i < N_SAMP; i++) {
const k = (head + i) % N_SAMP;
const v = buf[k];
if (isNaN(v)) continue;
const sx = x + (i * w) / N_SAMP;
const sy = y + h - ((v - yMin) / (yMax - yMin)) * h;
vertex(sx, sy);
}
endShape();
// axis labels (kept ASCII; non-ASCII in comments only)
noStroke();
fill(60);
textSize(10);
textAlign(LEFT, TOP);
text("position s(t) [m, along slope]", x + 6, y + 4);
textAlign(RIGHT, BOTTOM);
text("0", x + w - 4, y + h - 2);
textAlign(RIGHT, TOP);
text(nf(yMax, 1, 1), x + w - 4, y + 2);
}
// ---------------------------------------------------------------------
// Hatched ground beneath the incline.
// ---------------------------------------------------------------------
function drawGroundHatch(x, y, w, h) {
stroke(...STRUCT);
strokeWeight(1);
noFill();
line(x, y, x + w, y);
for (let i = 0; i <= 16; i++) {
const xi = x + (i * w) / 16;
line(xi, y, xi - 6, y + h);
}
}
// ---------------------------------------------------------------------
// HUD — every Wikitube microsim carries the same four-corner layout.
// Top-left: article title (line 1) + Wikitube URL line (line 2)
// Top-right: control-hint lines naming each slider
// Bottom-left: live numerical readouts for the parameters and outputs
// Bottom-right: canonical equation footer (ASCII only)
// ---------------------------------------------------------------------
function drawHud(thetaDeg, mu, Fapp, N, Fnet, a, v, s) {
noStroke();
textFont("system-ui");
// ----- Top-left title block --------------------------------------
fill(20);
textSize(20);
textAlign(LEFT, TOP);
text("Dynamics (mechanics)", 14, 10);
fill(110);
textSize(12);
text("Wikitube microsim - en.wikitube.io/wiki/" + ARTICLE, 14, 36);
// ----- Top-right control hints -----------------------------------
fill(110);
textSize(11);
textAlign(RIGHT, TOP);
text("sliders: theta (deg), mu (friction), F (applied N)",
width - 12, 56);
text("Newton's 2nd law: sum F = m * a", width - 12, 70);
// ----- Bottom-left readouts --------------------------------------
textSize(12);
textAlign(LEFT, BOTTOM);
fill(...LOAD);
text("theta = " + nf(thetaDeg, 1, 0) + " deg mu = " + nf(mu, 1, 2),
260, height - 90);
fill(...COUPLE);
text("F_applied = " + nf(Fapp, 1, 1) + " N (+ up-slope)",
260, height - 72);
fill(...REACT);
text("N = " + nf(N, 1, 1) + " N Fnet = " + nf(Fnet, 1, 2) + " N",
260, height - 54);
fill(...COMP);
text("a = " + nf(a, 1, 3) + " m/s^2 v = " + nf(v, 1, 3) + " m/s",
260, height - 36);
fill(60);
text("s = " + nf(s, 1, 3) + " m of " + nf(Lm, 1, 1) + " m",
260, height - 18);
// ----- Bottom-right equation footer ------------------------------
textSize(11);
textAlign(RIGHT, BOTTOM);
fill(80);
text("a = ( F - m*g*sin(theta) - mu*N*sign(v) ) / m",
width - 12, height - 22);
text("integrated forward-Euler at dt = " + nf(dt, 1, 2) + " s",
width - 12, height - 6);
// ----- Slider labels (drawn inside the canvas, see standard §7) --
textSize(11);
textAlign(LEFT, CENTER);
fill(60);
text("theta (deg)", 225, height - 82);
text("mu (friction)", 225, height - 52);
text("F (applied N)", 225, height - 22);
}
function windowResized() { /* canvas is fixed at 720x520 by design */ }
```
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Dynamics_(mechanics).json (2026-07-30T02:09:12Z) -->
`Acceleration` · `Aerodynamics` · `Aircraft` · `Alexis_Clairaut` · `Analytical_mechanics` · `Angular_acceleration` · `Angular_displacement` · [[Angular_frequency]] · `Angular_momentum` · `Angular_velocity` · `Appell's_equation_of_motion` · `Applied_mechanics` · `Augustin-Louis_Cauchy` · `Ballistics` · `Bernard_Koopman` · `Brownian_dynamics` · `Carl_Gustav_Jacob_Jacobi` · `Celestial_mechanics` · `Centrifugal_force` · `Centripetal_force` · [[Christiaan_Huygens]] · `Circular_motion` · `Classical_field_theory` · `Classical_mechanics` · `Contact_dynamics` · `Continuum_mechanics` · `Coriolis_force` · `Couple_(mechanics)` · `D'Alembert's_principle` · [[Damping]] · `Daniel_Bernoulli` · `Deformation_(physics)` · [[Density]] · `Displacement_(geometry)` · `Dynamical_simulation` · `Edmond_Halley` · `Edward_Routh` · `Elasticity_(physics)` · [[Energy]] · [[Engineering]] · `Equations_of_motion` · `Euler's_equations_(rigid_body_dynamics)` · `Euler's_laws_of_motion` · `Fictitious_force` · `File_dynamics` · `Flight_dynamics` · `Flow_measurement` · `Flow_velocity` · `Fluid` · [[Fluid_dynamics]] · `Fluid_mechanics` · [[Force]] · `Frame_of_reference` · `Friction` · `Galileo_Galilei` · `Gas` · `Geophysical_fluid_dynamics` · `Hamiltonian_mechanics` · `Hamilton–Jacobi_equation` · `Harmonic_oscillator` · `History_of_classical_mechanics` · `Hydrodynamic_stability` · `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` · `Langevin_dynamics` · `Leonhard_Euler` · `Linear_motion` · `Liquid` · `List_of_textbooks_on_classical_mechanics_and_quantum_mechanics` · `Magnetohydrodynamics` · `Mass` · `Mass_flow_rate` · [[Molecular_dynamics]] · `Moment_(physics)` · `Moment_of_inertia` · `Momentum` · `Motion` · `N-body_problem` · `Nebula` · `Newton's_law_of_universal_gravitation` · [[Newton's_laws_of_motion]] · `Newtonian_dynamics` · `Non-inertial_reference_frame` · `Nuclear_weapon_design` · `Paul_Émile_Appell` · `Pendulum_(mechanics)` · `Petroleum` · `Physical_chemistry` · `Physical_object` · [[Physical_system]] · [[Physics]] · `Pierre-Simon_Laplace` · `Pierre_Louis_Maupertuis` · `Plasticity_(physics)` · `Potential_energy` · `Pressure` · `Quantum_chromodynamics` · `Quantum_dynamics` · `Quantum_electrodynamics` · `Reactive_centrifugal_force` · `Relative_velocity` · `Relativistic_dynamics` · `Rigid_body` · `Rigid_body_dynamics` · `Rotating_reference_frame` · `Rotation_around_a_fixed_axis` · `Rotational_frequency` · `Routhian_mechanics` · [[Simple_harmonic_motion]] · `Siméon_Denis_Poisson` · `Space` · `Speed` · `Statics` · `Statistical_mechanics` · `Stellar_dynamics` · `Streamlines,_streaklines,_and_pathlines` · [[System_dynamics]] · `Tangential_speed` · `Temperature` · [[Thermodynamics]] · `Time` · `Time-variant_system` · `Timeline_of_classical_mechanics` · `Torque` · `Vehicle_dynamics` · [[Velocity]] · `Vibration` · `Virtual_work` · `Vortex` · `Vortex_shedding` · [[Weather_forecasting]] · `William_Rowan_Hamilton` · `Work_(physics)`
## From the Real GENERATIVE library
*Dynamics (mechanics) — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Engineering room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Stylised_atom_with_three_Bohr_model_orbits_and_stylised_nucleus.svg).*
*Animated: Dynamics (mechanics) — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Engineering room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:Orbital_motion.gif).*
> Classical mechanics is a physical theory describing the motion of objects such as projectiles, parts of machinery, spacecraft, planets, stars, and galaxies. The development of classical mechanics involved substantial change in the methods and philosophy of physics.[1] The qualifier classical distinguishes this type of mechanics from physics developed after t ([Wikipedia](https://en.wikipedia.org/wiki/Dynamics_%28mechanics%29))
<!-- REAL-GENERATIVE-MEDIA:END -->
## Media (PD/CC)
<!-- MEDIA-DEPLOY:Dynamics_(mechanics)/Orbital_motion.gif -->
!Gif Library/Dynamics (mechanics)/Orbital motion.gif
*Orbital_motion.gif · Public domain*
<!-- /MEDIA-DEPLOY -->
<!-- SIGN-SYSTEMS:START -->
**Semiotic universals** (the notations and alphabet letters this article speaks — each opens its canonical card): kanji radicals · force · rotation · sampling · equilibrium. Index: the glyph gallery · SEMIOTICS PORTAL.
<!-- SIGN-SYSTEMS:END -->
> **Canonical — promoted from collision 2026-06-21.** Appeared in: G.E.N.E.R.A.T.I.V.E./Engineering/GENERATIVE_ENGINEERING_Articles, G.E.N.E.R.A.T.I.V.E./Robotics/GENERATIVE_ROBOTICS_Articles. Per-hub sections to be added by the Microsim Worklist skill.
---
title: Dynamics (mechanics)
slug: Dynamics_(mechanics)
room: Engineering
status: ✅
microsim: shipped
editor_url: https://editor.p5js.org/sciencenibber/sketches/wEl75DPti
session_id: S-sched-engineering-1777558317
claimed_at: 2026-04-30T14:13:03Z
source_row: 0
completed_at: 2026-04-30T14:19:58Z
---
> **Room:** [[Engineering]] · **Status:** ✅ shipped
## Overview
**Dynamics** is the branch of classical mechanics that studies bodies in motion under the action of unbalanced forces — the natural sequel to statics, in which the net [[Force|force]] vanishes and nothing accelerates. Codified by Galileo's inclined-plane experiments and finalised by Newton's three laws (1687), dynamics rests on a single vector equation applied to any chosen free body: **ΣF = m·a** (Newton's second law). Where statics solves the equilibrium equation algebraically for unknown reactions, dynamics integrates the equation of motion forward in time to produce a trajectory: position, [[Velocity|velocity]], and acceleration as functions of time. The same free-body diagram that opens a statics problem opens a dynamics problem; only the right-hand side changes from zero to mass-times-acceleration. Sub-branches include kinematics ([[Geometry|geometry]] of motion alone), kinetics (forces causing motion), and rigid-body dynamics (extended bodies that translate and rotate). Dynamics underwrites every problem in vehicle motion, projectile flight, vibrating structures, rotating machinery, [[Robotics|robotics]], and orbital mechanics. The microsim below presents the canonical case: a block sliding down a frictional incline under gravity, with the free-body diagram, the net-force calculation, and the resulting forward-Euler trajectory all rendered live as the reader varies the slope, friction, and applied push.
## See also
- Room hub: [[Engineering]]
- p5.js Editor conventions: P5 JS EDITOR
- Wiki root: MAIN
---
*Scaffolded by `generative-microsim` from row 0 of the Engineering sheet on 2026-04-30T14:13:03Z.*
<!-- 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/Dynamics_%28mechanics%29) : [Wikitube](https://en.wikitube.io/wiki/Dynamics_%28mechanics%29)
## Previous hub tags
Tree parents: [[Dynamical_system]] · [[Self-organization]].
Legacy hubs: none.
*Legacy media (later editing), kept in place under `Wikitube - Collision And Promoted Articles/Dynamics_(mechanics)/`: `Dynamics_(mechanics) Books` (4) · `Dynamics_(mechanics) History` (1) · `Dynamics_(mechanics) Systems` (1)*
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*