# Voltage
## Microsim
<iframe src="https://editor.p5js.org/sciencenibber/full/jSgb5aAeX" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>
<img src="../SPINTRONICS Images/Voltage.png" alt="Voltage microsim">
*Live sketch: [open in the p5.js editor](https://editor.p5js.org/sciencenibber/sketches/jSgb5aAeX). The poster image above is a placeholder pending an attended or server-side canvas capture.*
### p5.js source
```js
// Voltage.js -- Wikitube MicroSim
// Hub: SPINTRONICS · Branch: P - Power transmission
// Pattern: V (field) + a single accelerated test charge + an energy ledger.
// Animation is the point (a charge falls through a potential
// difference), so we loop() but keep every per-frame loop bounded.
//
// CONCEPT
// Voltage is energy per unit charge: W = q*V (volt = joule/coulomb). Between
// two parallel plates a distance d apart at potential difference V the field
// is uniform, E = V/d, so a charge q feels a constant force F = q*E = q*V/d.
// Pushed across the gap it gains work W = F*d = q*V -- the d CANCELS, so the
// energy gained depends only on V, not on the gap or the path. Released from
// rest, all of qV becomes kinetic energy: (1/2) m v^2 = q V, hence the exit
// speed v = sqrt(2 q V / m). For an electron (q = e) the exit energy in eV
// equals V in volts (the definition of the electron-volt). A heavier proton
// gains the SAME qV but leaves far slower.
//
// The real crossing is sub-microsecond, so the motion is shown in slow motion:
// a normalized phase p in [0,1] advances at a fixed wall-clock rate while the
// on-screen position follows x/d = p^2 (constant-acceleration shape) and the
// live readouts report the true physical E, F, v, t_cross, and energy.
//
// GOLDEN RULES honoured: 720x520 + pixelDensity(2); layout derived from
// width/height; ASCII-only strings (Unicode only in comments); SI units
// internally, convert at the input; dt clamped (min(deltaTime/1000,0.05));
// cheap draw() with a baked offscreen scenery buffer; bounded per-frame loops
// (a handful of field lines, no per-pixel work); HUD watermark drawn last; one
// concept per control; reset restores ALL state; p5.disableFriendlyErrors=true.
const ARTICLE = "Voltage"; // single source of truth (HUD + save name + URL)
// ---- physical constants (SI) ----
const ECHARGE = 1.602e-19; // e, coulombs (magnitude of the elementary charge)
const MASS_E = 9.109e-31; // electron mass, kg
const MASS_P = 1.673e-27; // proton mass, kg
// ---- control ranges (real symbols, meaningful ranges) ----
const V_MIN = 10, V_MAX = 2000, V_DEF = 1000; // V, volts (potential difference)
const D_MIN = 1, D_MAX = 50, D_DEF = 10; // d, millimetres (plate gap)
// ---- animation ----
const CROSS_WALL = 2.6; // wall-clock seconds for the slow-motion crossing
// ---- controls ----
let vSlider, dSlider;
let particleButton, releaseButton, playButton, resetButton;
// ---- state ----
let isProton = false; // false = electron, true = proton
let isPlaying = true;
let phase = 0; // p in [0,1]; on-screen distance fraction = p^2
let scenery; // baked static buffer (plates, axes, fixed labels)
// ---- layout (all derived; never hard-code magic coords in draw) ----
let capX0, capX1, capCX; // plate horizontal extent + centre line
let plateTopY, plateBotY, gapPix; // plate y positions + on-screen gap
let barX, barW; // energy ledger bar
// ---- palette (ASCII identifiers only; none collide with p5 globals) ----
let BG, INK, MUTE, FRAME, POSC, NEGC, FIELDC, PARTC, KEC, PEC, GOOD;
function setup() {
createCanvas(720, 520);
pixelDensity(2);
p5.disableFriendlyErrors = true; // clean + cheap; no FES overhead
textFont("monospace");
BG = color(14, 18, 32);
INK = color(232, 238, 248);
MUTE = color(120, 134, 158);
FRAME = color(60, 72, 96);
POSC = color(255, 120, 110); // + plate (red, high potential)
NEGC = color(90, 150, 255); // - plate (blue, low potential / ref)
FIELDC = color(150, 165, 200); // field lines
PARTC = color(255, 210, 90); // the test charge
KEC = color(120, 230, 150); // kinetic-energy bar (green)
PEC = color(150, 120, 220); // potential-energy bar (violet)
GOOD = color(120, 230, 150);
// --- geometry from the canvas, not magic numbers ---
capX0 = 70; capX1 = 350; capCX = (capX0 + capX1) / 2;
plateTopY = 96; plateBotY = 304; gapPix = plateBotY - plateTopY;
barX = 404; barW = 48;
buildControls();
buildScenery(); // bake once -> draw() paints only dynamics
// loop() runs while playing; we start armed and playing
}
function buildControls() {
// one slider per concept, carrying the field's real symbol + a meaningful range
vSlider = createSlider(V_MIN, V_MAX, V_DEF, 10); // V, volts
dSlider = createSlider(D_MIN, D_MAX, D_DEF, 1); // d, mm
vSlider.position(24, 392); vSlider.style("width", "180px");
dSlider.position(24, 430); dSlider.style("width", "180px");
particleButton = createButton("particle: electron");
particleButton.position(24, 470);
particleButton.mousePressed(toggleParticle);
releaseButton = createButton("release");
releaseButton.position(190, 470);
releaseButton.mousePressed(doRelease);
playButton = createButton("pause");
playButton.position(286, 470);
playButton.mousePressed(togglePlay);
resetButton = createButton("reset");
resetButton.position(360, 470);
resetButton.mousePressed(resetAll);
// changing V, d re-arms the launch so the shown trajectory matches the params
vSlider.input(reArm);
dSlider.input(reArm);
}
// re-arm to the start plate when a parameter changes (keeps play state)
function reArm() {
phase = 0;
if (!isPlaying) redraw();
}
function toggleParticle() {
isProton = !isProton;
particleButton.html(isProton ? "particle: proton" : "particle: electron");
phase = 0;
if (!isPlaying) redraw();
}
function doRelease() {
// launch again from rest at the start plate
phase = 0;
isPlaying = true; playButton.html("pause"); loop();
}
function togglePlay() {
isPlaying = !isPlaying;
playButton.html(isPlaying ? "pause" : "play");
if (isPlaying) loop(); else noLoop();
}
function resetAll() {
// reset restores ALL state, not just some
vSlider.value(V_DEF);
dSlider.value(D_DEF);
isProton = false; particleButton.html("particle: electron");
phase = 0;
isPlaying = true; playButton.html("pause"); loop();
redraw();
}
// Pure model: SI in, named results out. Keeps draw() readable and unit-clean.
function computeModel(Vvolt, Dmm) {
const Vsi = Vvolt; // volts
const dsi = Dmm * 1e-3; // metres
const mass = isProton ? MASS_P : MASS_E;
const dir = isProton ? +1 : -1; // +1 = downward (proton), -1 = upward (electron)
const Efield = Vsi / dsi; // V/m (E = V/d)
const force = ECHARGE * Efield; // N (F = qE, magnitude)
const work = ECHARGE * Vsi; // J (W = qV)
const workEV = Vsi; // eV (W/e = V for q = e)
const accel = force / mass; // m/s^2
const vExit = Math.sqrt(2 * work / mass); // m/s (1/2 m v^2 = qV)
const tCross = vExit / accel; // s (v = a t)
return { Vsi, dsi, mass, dir, Efield, force, work, workEV, accel, vExit, tCross };
}
function draw() {
background(BG);
image(scenery, 0, 0); // blit baked static scenery
// read every control ONCE into named locals
const Vvolt = vSlider.value();
const Dmm = dSlider.value();
const m = computeModel(Vvolt, Dmm);
// advance the slow-motion playhead: phase rises at a fixed wall-clock rate so
// the crossing is always watchable; on-screen distance fraction is phase^2
// (the constant-acceleration shape x = 1/2 a t^2).
if (isPlaying) {
const dt = Math.min(deltaTime / 1000, 0.05);
phase += dt / CROSS_WALL;
if (phase >= 1) { phase = 1; isPlaying = false; playButton.html("play"); noLoop(); }
}
const frac = phase * phase; // fraction of the gap travelled
drawField(m); // dynamic: field-line brightness ~ E
drawParticle(m, frac); // the accelerating charge + velocity arrow
drawEnergyBar(m, frac); // PE -> KE ledger (sums to qV)
drawReadouts(Vvolt, Dmm, m, frac); // numeric block + slider labels
drawHUD(Vvolt, Dmm, m); // HUD watermark, drawn LAST
}
// ---- dynamic field lines (brightness/weight encode E = V/d) ----
function drawField(m) {
// normalize E across the parameter box to a 0..1 intensity (log-ish via sqrt)
const eMax = (V_MAX) / (D_MIN * 1e-3); // strongest field in range
const inten = constrain(Math.sqrt(m.Efield / eMax), 0.08, 1);
const nLines = 9;
for (let i = 0; i < nLines; i++) { // bounded, cheap
const x = lerp(capX0 + 22, capX1 - 22, i / (nLines - 1));
stroke(red(FIELDC), green(FIELDC), blue(FIELDC), 40 + inten * 180);
strokeWeight(0.8 + inten * 2.0);
line(x, plateTopY + 6, x, plateBotY - 6); // field points + (top) -> - (bottom)
// arrowhead pointing DOWN (E direction), midway
const ay = (plateTopY + plateBotY) / 2;
noStroke(); fill(red(FIELDC), green(FIELDC), blue(FIELDC), 60 + inten * 180);
triangle(x - 4, ay - 5, x + 4, ay - 5, x, ay + 4);
}
// current field magnitude label
noStroke(); textAlign(CENTER, TOP); textSize(11); fill(INK);
text("E = V/d = " + fmtField(m.Efield), capCX, plateBotY + 24);
}
// ---- the accelerating test charge + a velocity arrow ----
function drawParticle(m, frac) {
// electron starts at the bottom plate and rises; proton starts at top, falls
const yStart = m.dir < 0 ? plateBotY - 12 : plateTopY + 12;
const yEnd = m.dir < 0 ? plateTopY + 12 : plateBotY - 12;
const yPart = lerp(yStart, yEnd, frac);
// faint path from the start plate to the current position
stroke(PARTC, 70); strokeWeight(1);
drawingContext.setLineDash([4, 5]);
line(capCX, yStart, capCX, yPart);
drawingContext.setLineDash([]);
// velocity arrow (length ~ instantaneous speed fraction = phase)
const vLen = 34 * phase;
const vdir = m.dir < 0 ? -1 : +1; // up for electron, down for proton
stroke(PARTC); strokeWeight(2);
line(capCX, yPart, capCX, yPart + vdir * vLen);
noStroke(); fill(PARTC);
triangle(capCX - 4, yPart + vdir * vLen, capCX + 4, yPart + vdir * vLen,
capCX, yPart + vdir * (vLen + 7));
// the charge itself, with its sign
fill(PARTC); noStroke(); circle(capCX, yPart, 20);
fill(20, 24, 38); textAlign(CENTER, CENTER); textSize(14);
text(isProton ? "+" : "-", capCX, yPart - 1);
fill(INK); textSize(10); textAlign(LEFT, CENTER);
text(isProton ? "proton" : "electron", capCX + 14, yPart);
}
// ---- energy ledger: PE converts to KE, always summing to qV ----
function drawEnergyBar(m, frac) {
const top = plateTopY, bot = plateBotY, H = gapPix;
const keH = H * frac; // KE fraction = p^2
// frame
noFill(); stroke(FRAME); strokeWeight(1.5);
rect(barX, top, barW, H);
// PE (top, shrinking) then KE (bottom, growing)
noStroke();
fill(red(PEC), green(PEC), blue(PEC), 200);
rect(barX, top, barW, H - keH);
fill(red(KEC), green(KEC), blue(KEC), 220);
rect(barX, bot - keH, barW, keH);
// labels
fill(INK); textSize(10); textAlign(CENTER, BOTTOM);
text("qV", barX + barW / 2, top - 4);
fill(PEC); textAlign(LEFT, CENTER); textSize(10);
text("PE = qV(1-p^2)", barX + barW + 8, top + (H - keH) / 2);
fill(KEC);
text("KE = qV*p^2", barX + barW + 8, bot - keH / 2);
// live KE value in eV
fill(INK); textAlign(LEFT, TOP); textSize(11);
text("KE = " + fmtEnergyEV(m.work * frac), barX, bot + 10);
}
// ---- control-region numeric readouts ----
function drawReadouts(Vvolt, Dmm, m, frac) {
// slider value labels (control hints), middle column
fill(INK); textSize(12); textAlign(LEFT, CENTER); noStroke();
text("V = " + Vvolt.toFixed(0) + " V", 214, 401);
text("d = " + Dmm.toFixed(0) + " mm", 214, 439);
// results block, right column
const bx = 470, by = 96;
textAlign(LEFT, TOP); textSize(12); fill(INK);
text("E = V/d = " + fmtField(m.Efield), bx, by);
text("F = qE = " + fmtForce(m.force), bx, by + 20);
text("a = F/m = " + m.accel.toExponential(2) + " m/s2", bx, by + 40);
text("W = qV = " + fmtEnergyEV(m.work), bx, by + 60);
text(" " + m.work.toExponential(2) + " J", bx, by + 78);
text("v_exit = " + fmtSpeed(m.vExit), bx, by + 98);
text("t_cross = " + fmtTime(m.tCross), bx, by + 118);
// live (now) values as it crosses
fill(GOOD); textSize(12);
text("v(now) = " + fmtSpeed(m.vExit * phase), bx, by + 144);
text("t(now) = " + fmtTime(m.tCross * phase), bx, by + 162);
// the invariance punchline
fill(MUTE); textSize(11);
text("note: change d -> E and F change,", bx, by + 188);
text("but W = qV is unchanged.", bx, by + 204);
}
// ---- HUD watermark: title, URL, control hints, live equation footer ----
function drawHUD(Vvolt, Dmm, m) {
noStroke(); textAlign(LEFT, TOP);
fill(INK); textSize(15);
text("Voltage -- energy per unit charge (W = qV)", 16, 12);
fill(MUTE); textSize(11);
text("en.wikitube.io/wiki/Voltage", 16, 33);
text("drag V, d | toggle electron/proton | release | play/pause | reset",
24, 368);
// live equation footer (drawn last, bottom)
fill(MUTE); textSize(12); textAlign(LEFT, BOTTOM);
text("E = V/d F = qE W = qV = KE v = sqrt(2qV/m)", 16, height - 10);
}
// ---- baked static scenery (never changes -> offscreen buffer) ----
function buildScenery() {
scenery = createGraphics(720, 520);
const g = scenery;
g.pixelDensity(2);
g.background(BG);
g.textFont("monospace");
// --- parallel plates: + on top (high potential), - on bottom (reference) ---
g.noStroke();
g.fill(red(POSC), green(POSC), blue(POSC), 230);
g.rect(capX0, plateTopY - 10, capX1 - capX0, 10, 2); // top plate (+)
g.fill(red(NEGC), green(NEGC), blue(NEGC), 230);
g.rect(capX0, plateBotY, capX1 - capX0, 10, 2); // bottom plate (-)
// plate signs and potentials
g.textSize(13); g.textAlign(LEFT, CENTER);
g.fill(255); g.text("+", capX0 + 8, plateTopY - 5);
g.text("-", capX0 + 8, plateBotY + 5);
g.fill(POSC); g.textSize(11); g.textAlign(RIGHT, BOTTOM);
g.text("+V (high potential)", capX1, plateTopY - 14);
g.fill(NEGC); g.textAlign(RIGHT, TOP);
g.text("0 V (reference)", capX1, plateBotY + 14);
// gap dimension marker on the left
g.stroke(FRAME); g.strokeWeight(1);
g.line(capX0 - 18, plateTopY, capX0 - 18, plateBotY);
g.line(capX0 - 22, plateTopY, capX0 - 14, plateTopY);
g.line(capX0 - 22, plateBotY, capX0 - 14, plateBotY);
g.noStroke(); g.fill(MUTE); g.textSize(11);
g.push();
g.translate(capX0 - 26, (plateTopY + plateBotY) / 2);
g.rotate(-HALF_PI);
g.textAlign(CENTER, BOTTOM);
g.text("gap d", 0, 0);
g.pop();
// section caption under the capacitor
g.fill(MUTE); g.textSize(10); g.textAlign(CENTER, TOP);
g.text("uniform field between parallel plates (slow motion)",
capCX, plateBotY + 40);
// --- energy-bar caption ---
g.fill(INK); g.textSize(12); g.textAlign(LEFT, BOTTOM);
g.text("energy", barX, plateTopY - 20);
// --- divider between drawing region and control region ---
g.stroke(FRAME); g.strokeWeight(1);
g.line(16, 352, 704, 352);
}
// ---- compact engineering-unit formatters (ASCII units) ----
function fmtField(e) {
if (e >= 1e6) return (e / 1e6).toFixed(2) + " MV/m";
if (e >= 1e3) return (e / 1e3).toFixed(1) + " kV/m";
return e.toFixed(0) + " V/m";
}
function fmtForce(f) {
if (f >= 1e-9) return (f / 1e-9).toFixed(2) + " nN";
if (f >= 1e-12) return (f / 1e-12).toFixed(2) + " pN";
if (f >= 1e-15) return (f / 1e-15).toFixed(2) + " fN";
return f.toExponential(2) + " N";
}
function fmtSpeed(v) {
if (v >= 1e6) return (v / 1e6).toFixed(2) + " Mm/s";
if (v >= 1e3) return (v / 1e3).toFixed(1) + " km/s";
return v.toFixed(0) + " m/s";
}
function fmtTime(t) {
if (t >= 1) return t.toFixed(2) + " s";
if (t >= 1e-3) return (t * 1e3).toFixed(2) + " ms";
if (t >= 1e-6) return (t * 1e6).toFixed(2) + " us";
if (t >= 1e-9) return (t * 1e9).toFixed(2) + " ns";
return (t * 1e12).toFixed(2) + " ps";
}
function fmtEnergyEV(j) {
const ev = j / ECHARGE;
if (ev >= 1e6) return (ev / 1e6).toFixed(2) + " MeV";
if (ev >= 1e3) return (ev / 1e3).toFixed(2) + " keV";
return ev.toFixed(0) + " eV";
}
```
<!-- REAL-GENERATIVE-MEDIA:START -->
## MicroSim
Two charged plates face each other with a uniform field drawn as vertical lines whose brightness tracks `E = V/d`. A test charge starts at rest on one plate and accelerates across the gap (shown in slow motion — the real crossing is sub-microsecond), its speed growing as it falls through the potential. A stacked energy bar shows electric potential energy converting into kinetic energy, the two always summing to `qV`; live readouts give `E`, `F`, `v`, the crossing time `t_cross`, and the exit energy in both joules and electron-volts. Sliders set `V` and `d`; a toggle swaps the **electron** for a **proton** (same `qV`, very different speed); buttons **release** (re-launch from rest), **play/pause**, and **reset**. Widen the gap `d` and watch the field and force weaken while the exit energy `qV` stays exactly the same — the signature invariance of voltage.
**Possible extensions (publish/refine):** add a relativistic correction at high `V` (electrons pass ~10% of `c` by a few keV); overlay the **circuit view** (`V = I*R` with a battery, resistor, and a voltmeter tap); add a second reference probe to show that only **differences** of potential are physical; sweep `V` to plot exit energy `qV` and exit speed `sqrt(2qV/m)` side by side.
## Links (Wikipedia order)
<!-- injected from _registry/childlinks/Voltage.json (2026-07-30T02:09:12Z) -->
`AC_motor` · `Abraham–Lorentz_force` · `Albert_Einstein` · `Alessandro_Volta` · `Alfred-Marie_Liénard` · [[Alternating_current]] · `Ampère's_circuital_law` · `Ampère's_force_law` · `André-Marie_Ampère` · `Annales_de_chimie_et_de_physique` · `Automotive_battery` · `Benjamin_Franklin` · `Biot–Savart_law` · `Bremsstrahlung` · `Bridge_circuit` · `Capacitance` · `Capacitor` · `Carl_Friedrich_Gauss` · `Charge_density` · `Charles-Augustin_de_Coulomb` · `Charles_Proteus_Steinmetz` · `Classical_electromagnetism` · `Classical_electromagnetism_and_special_relativity` · `Computational_electromagnetics` · `Conservative_force` · `Coulomb` · [[Coulomb's_law]] · `Covariant_formulation_of_classical_electromagnetism` · `Curl_(mathematics)` · `Current_density` · `Cyclotron_radiation` · `DC_motor` · `Dimensional_analysis` · `Direct_current` · `Eddy_current` · `Electret` · `Electric_battery` · `Electric_charge` · [[Electric_current]] · `Electric_dipole_moment` · `Electric_field` · `Electric_flux` · `Electric_generator` · `Electric_machine` · [[Electric_motor]] · `Electric_potential` · `Electric_potential_energy` · `Electric_power` · [[Electric_power_transmission]] · `Electrical_conductor` · [[Electrical_engineering]] · `Electrical_impedance` · `Electrical_network` · `Electrical_resistance_and_conductance` · `Electricity` · `Electrochemical_potential` · `Electrolysis` · `Electromagnetic_field` · `Electromagnetic_four-potential` · `Electromagnetic_induction` · `Electromagnetic_mass` · `Electromagnetic_radiation` · `Electromagnetic_stress–energy_tensor` · `Electromagnetic_tensor` · `Electromagnetism` · `Electromotive_force` · [[Electron]] · `Electroscope` · `Electrostatic_discharge` · `Electrostatic_induction` · `Electrostatics` · `Emil_Lenz` · `Emil_Wiechert` · [[Energy]] · `English_language` · `Faraday's_law_of_induction` · `Fermi_level` · `Four-current` · `Franz_Ernst_Neumann` · `François_Arago` · `Félix_Savart` · `Galvani_potential` · `Gauge_fixing` · `Gauss's_law` · `Gauss's_law_for_magnetism` · `Georg_Ohm` · `George_Francis_FitzGerald` · `George_Green_(mathematician)` · `George_Singer` · `Giovanni_Aldini` · `Ground_(electricity)` · `Gustav_Kirchhoff` · `Gyrator–capacitor_model` · `Hans_Christian_Ørsted` · `Heinrich_Hertz` · `Helmholtz_decomposition` · `Hendrik_Lorentz` · `Hermann_von_Helmholtz` · `High_voltage` · `Hippolyte_Fizeau` · `History_of_electromagnetic_theory` · `Humphry_Davy` · `Hydraulic_analogy` · `Inductance` · `Induction_motor` · `Insulator_(electricity)` · `International_System_of_Units` · `J._J._Thomson` · `James_Clerk_Maxwell` · `James_Prescott_Joule` · `Jean-Baptiste_Biot` · `Jefimenko's_equations` · `John_Henry_Poynting` · `John_Hopkinson` · `Joseph_Henry` · `Joseph_Larmor` · `Josephson_effect` · [[Josiah_Willard_Gibbs]] · `Joule` · `Joule_heating` · `Kirchhoff's_circuit_laws` · `Larmor_formula` · `Lenz's_law` · `Line_integral` · `Linear_motor` · `List_of_electrical_phenomena` · `List_of_textbooks_in_electromagnetism` · `Liénard–Wiechert_potential` · `London_equations` · `Lord_Kelvin` · `Lorentz_force` · `Lorenz_gauge_condition` · `Luigi_Galvani` · `Magnetic_circuit` · `Magnetic_complex_reluctance` · `Magnetic_field` · `Magnetic_flux` · `Magnetic_moment` · `Magnetic_reluctance` · `Magnetic_scalar_potential` · `Magnetic_vector_potential` · `Magnetism` · `Magnetization` · `Magnetomotive_force` · `Magnetostatics` · `Mains_electricity` · `Mains_electricity_by_country` · `Mathematical_descriptions_of_the_electromagnetic_field` · `Maxwell's_equations` · `Maxwell's_equations_in_curved_spacetime` · `Maxwell_stress_tensor` · `Michael_Faraday` · `Multimeter` · `Network_analysis_(electrical_circuits)` · `Nikola_Tesla` · `Ohm's_law` · `Oliver_Heaviside` · `Open-circuit_voltage` · `Optics` · `Orders_of_magnitude_(voltage)` · `Oscilloscope` · `Overhead_line` · `Permeability_(electromagnetism)` · `Permeance` · `Permittivity` · `Physical_constant` · `Polarization_density` · `Potential` · `Potentiometer_(measuring_instrument)` · `Poynting's_theorem` · `Pressure` · `Pump` · `Quantity` · `Relativistic_electromagnetism` · `Resistor` · `Resonator` · `Retarded_potential` · `Right-hand_rule` · `Rotor_(electric)` · `SI_base_unit` · `SI_derived_unit` · `Scalar_(physics)` · `Series_and_parallel_circuits` · `Simply_connected_space` · `Siméon_Denis_Poisson` · `Speed_of_light` · `Static_electricity` · `Stator_(electric_machines)` · `Synchrotron_radiation` · `Test_particle` · `Thermoelectric_effect` · `Transformer` · `Triboelectric_effect` · `Turbine` · `Vacuum_tube` · `Volt` · `Voltage_(disambiguation)` · `Voltage_drop` · `Voltage_source` · `Voltaic_pile` · `Voltmeter` · `Volume` · `Watt` · `Waveguide_(radio_frequency)` · [[Wayback_Machine]] · `Wilhelm_Eduard_Weber` · `William_Gilbert_(physicist)` · `William_Ritchie_(physicist)`
## From the Real GENERATIVE library
*Voltage — placed from the Real G.E.N.E.R.A.T.I.V.E. course library (Audio room). Source: Wikimedia Commons (via Wikipedia article media). [Details & license](https://commons.wikimedia.org/wiki/File:AA_AAA_AAAA_A23_battery_comparison-1.jpg).*
> Voltage, also known as (electrical) potential difference, electric pressure, or electric tension is the difference in electric potential between two points.[1][2] In a static electric field, it corresponds to the work needed per unit of charge to move a positive test charge from the first point to the second point. In the International System of Units (SI), ([Wikipedia](https://en.wikipedia.org/wiki/Voltage))
<!-- REAL-GENERATIVE-MEDIA:END -->
*SPINTRONICS · branch **P — Power transmission** · MicroSim pattern **V** (field) with a single accelerated test charge and an [[Energy|energy]] ledger. Draft staged by the headless draft queue; the publish stage adds frontmatter, the live editor iframe, and routes this into the Power-transmission branch folder.*
## Overview
**Voltage**, or **electric potential difference**, is the work needed per unit charge to move a charge between two points in an electric field. Its unit, the **volt** (V), is one **joule per coulomb** (`1 V = 1 J/C`). Voltage is the "pressure" that drives current through a circuit: connect two points at different potentials with a conductor and charge flows from high to low potential, just as water flows from high to low pressure. It is always a **difference** between two points — a single point's potential is only defined relative to a chosen reference (often ground at 0 V).
Voltage ties together the three things electricity does. It is **energy per charge** (`U = qV`), it is the **integral of the electric field** along a path (`V = E*d` in a uniform field), and through **Ohm's law** (`V = I*R`) it sets the current a resistance will pass. This sketch builds the meaning from the first of these: a charge crossing a potential difference `V` gains exactly `qV` of energy, no matter how wide the gap or what path it takes.
## The physics / derivation
**Definition — energy per unit charge.** Moving a charge `q` between two points that differ in potential by `V` does work
```
W = q * V so U = q * V (electric potential energy)
```
Voltage is `W/q`: the joules delivered per coulomb. That is why a 1.5 V cell and a 12 V battery differ — each coulomb leaving the 12 V terminal carries eight times the energy.
**Uniform field between parallel plates.** Hold two parallel plates a distance `d` apart at a potential difference `V`. The field between them is uniform and points from the `+` plate to the `-` plate, with magnitude
```
E = V / d equivalently V = E * d
```
So volts-per-metre is literally the unit of electric field. Halving the gap at fixed `V` doubles the field.
**[[Force]], work, and the key invariance.** A charge `q` in that field feels a constant force `F = q*E = q*V/d`. Pushed across the full gap it receives work
```
W = F * d = (q V / d) * d = q V
```
The `d` cancels: **the energy a charge gains depends only on the potential difference `V`, not on the gap width or the path.** That path-independence is exactly what makes "voltage" a single useful number for each point.
**From potential energy to speed.** Release the charge from rest; all of `qV` becomes kinetic energy:
```
(1/2) m v^2 = q V -> v = sqrt( 2 q V / m )
```
This is how [[Electron|electron]] guns, CRTs, and particle accelerators work, and it defines the **electron-volt**: an electron (`q = e`) accelerated through `1 V` gains `1 eV` of energy — so the exit energy in electron-volts equals the voltage in volts. A heavier [[Proton|proton]] gains the **same** `qV` of energy but comes out much slower.
**Circuit view.** Across a resistor, voltage and current obey **Ohm's law** `V = I*R`, and around any closed loop the voltage rises and drops sum to zero (**Kirchhoff's voltage law**) — the same statement that potential is single-valued at each node.
## Parameter table (controls -> real symbols)
| Control | Symbol | Meaning | Range (sim) |
|---------|:------:|---------|-------------|
| potential difference | `V` | plate-to-plate voltage; sets `E = V/d` and `W = qV` | 10 – 2000 V |
| plate gap | `d` | separation; larger `d` weakens the field at fixed `V` | 1 – 50 mm |
| test particle | `q, m` | electron (`-e`, `m_e`) or proton (`+e`, `m_p`) | toggle |
*Derived and displayed:* field `E = V/d`, force `F = qE`, work/energy `W = qV` (in joules and electron-volts), exit speed `v = sqrt(2qV/m)`, the real crossing time `t_cross`, and the running split of energy between potential and kinetic as the charge crosses.
## Learning objective
Understand that **voltage is energy per unit charge**: a charge `q` falling through a potential difference `V` gains exactly `W = qV` of energy — **independent of the gap width or path** — and that the same `V` defines the uniform field `E = V/d` between plates and, on release, an exit speed `v = sqrt(2qV/m)` (so equal energy, but lighter charges go faster).
<!-- 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/Voltage) : [Wikitube](https://en.wikitube.io/wiki/Voltage)
## Previous hub tags
Tree parents: [[Control_theory]] · [[Graph_theory]] · [[Helium]].
Legacy hubs: none.
---
*Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*