API marketplace

Shaft torsion as an API, computed locally and deterministically. The stress endpoint computes the maximum torsional shear stress in a circular shaft, τ = T·r/J — torque times the outer radius divided by the polar moment of inertia — for a solid shaft (J = π·d⁴/32) or a hollow tube (J = π·(D⁴−d⁴)/32), and solves the torque a shaft can carry for an allowable stress. The twist endpoint computes the angle of twist along the shaft, θ = T·L/(G·J), in radians and degrees, from the torque, length and the shear modulus (given directly or from a built-in material table — steel, aluminium, copper, titanium and more), plus the torsional stiffness G·J/L. The power endpoint relates the power a rotating shaft transmits to its torque and speed, P = T·ω = T·2πN/60, and solves any of the three, reporting power in watts, kilowatts and horsepower. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical and drivetrain engineering tools, shaft, axle and coupling design, motor and gearbox apps, and machine-design education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is circular-shaft torsion; for axial stress-strain use a Young's-modulus API and for the 2D stress state use a Mohr-circle API.

Uptime

100.0%

Latency

75ms

Subs

3,732

Axial stress, strain and Young's modulus as an API, computed locally and deterministically. The stress endpoint relates the three quantities of an axially loaded member — the stress σ = F/A, the strain ε = ΔL/L and Young's modulus E = σ/ε — and solves for whichever you leave out, taking the modulus directly, in gigapascals, or from a built-in material table (steel, aluminium, copper, titanium, concrete, glass and more), with stress reported in pascals, MPa and GPa. The elongation endpoint computes how much a bar stretches under an axial load, δ = F·L/(A·E), from the force, length and cross-section (area or diameter) and the material or modulus, along with the stress, strain and the axial stiffness k = A·E/L. The poisson endpoint works with Poisson's ratio ν: the lateral strain that accompanies an axial strain, and the shear modulus G = E/(2(1+ν)) and bulk modulus K = E/(3(1−2ν)) derived from the Young's modulus. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical, civil and materials-engineering tools, structural and machine-design apps, materials testing and education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is axial material deformation; for the 2D state of stress (principal stresses, Mohr's circle) use a Mohr-circle API and for column buckling use a buckling API.

Uptime

100.0%

Latency

75ms

Subs

4,803

Ideal-transformer relations as an API, computed locally and deterministically. The transformer endpoint works from the turns ratio a = Np/Ns = Vp/Vs = Is/Ip: give any ratio-defining pair — the primary and secondary turns, voltages or currents — and it derives the rest, classifies the transformer as step-up, step-down or 1:1 isolation, and reports the primary and secondary apparent power (which are equal for an ideal transformer, so a step-down in voltage is a step-up in current). The power endpoint applies the power balance with an efficiency, Ps = η·Pp, from the primary or secondary power (given directly or as voltage times current) and reports the power loss. The impedance endpoint reflects an impedance across the transformer, Zp/Zs = (Np/Ns)² = a² — the basis of impedance matching, so an 8 Ω speaker on a 10:1 transformer looks like 800 Ω to the source. Everything is computed locally and deterministically, so it is instant and private. Ideal for electrical and electronics-engineering tools, power-supply and audio-amplifier design, impedance-matching and EE-education apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is ideal-transformer ratios; for Ohm's law, reactance and series/parallel components use an Ohm's-law API.

Uptime

100.0%

Latency

78ms

Subs

4,979

Heat-engine efficiency and coefficient of performance as an API, computed locally and deterministically. The efficiency endpoint gives the Carnot maximum efficiency of any heat engine working between two temperatures, η = 1 − Tc/Th (in kelvin) — the absolute upper limit no real engine can beat — and, given a heat input, the maximum work it could produce and the heat it must reject. The heat-pump endpoint gives the Carnot coefficient of performance of a heat pump, COP = Th/(Th − Tc), and of a refrigerator or air conditioner, COP = Tc/(Th − Tc), and the heat moved for a given work input. The engine endpoint analyses a real engine from its heat balance: from any two of the heat input, the work output, the efficiency or the heat rejected it returns the rest using η = W/Qh and Qc = Qh − W, and — given the reservoir temperatures — compares it to the Carnot limit and reports the second-law (exergy) efficiency. Temperatures accept kelvin, Celsius or Fahrenheit. Everything is computed locally and deterministically, so it is instant and private. Ideal for thermodynamics-education tools, engine, turbine and HVAC design, refrigeration and heat-pump apps, and energy-systems software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is heat-engine and refrigeration-cycle efficiency; for sensible heat use a specific-heat API and for heat-exchanger LMTD use a heat-exchanger API.

Uptime

100.0%

Latency

77ms

Subs

3,359

Optical resolution by the Rayleigh criterion as an API, computed locally and deterministically. The angular endpoint gives the smallest angle two points can be apart and still be told apart through a circular aperture, θ = 1.22·λ/D — the diffraction limit set by the wavelength and the aperture diameter — in radians, degrees, arcminutes and arcseconds (a 100 mm telescope resolves about 1.4 arcseconds in green light), and solves the aperture needed for a target resolution. The distance endpoint turns that angle into a real separation at a distance, s = θ·L = 1.22·λ·L/D — how far apart two objects must be to be resolved at a given range. The microscope endpoint computes resolving power from the numerical aperture: the Rayleigh limit d = 0.61·λ/NA and the Abbe limit d = λ/(2·NA), with NA = n·sin(θ) from a refractive index and half-angle, and the maximum useful magnification. Wavelength defaults to 550 nm (visible) and can be set in metres, nanometres or micrometres. Everything is computed locally and deterministically, so it is instant and private. Ideal for astronomy, telescope and binocular tools, microscopy and imaging-system design, camera and optics apps, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is the diffraction-limited resolving power; for thin-lens imaging use a lens API and for slit and grating diffraction use a diffraction API.

Uptime

100.0%

Latency

70ms

Subs

4,796

Hooke's law and elastic potential energy as an API, computed locally and deterministically. The hooke endpoint applies F = k·x — the restoring force of a spring equals its spring constant times the extension — and solves for whichever of the force, the spring constant or the displacement you leave out, also returning the elastic potential energy ½·k·x². The energy endpoint computes the elastic potential energy E = ½·k·x² stored in a stretched or compressed spring, solves the extension from a stored energy, and finds the work done in stretching a spring from one extension to another, W = ½·k·(x2² − x1²). The combine endpoint combines springs: in series the assembly is softer, 1/k = Σ 1/kᵢ, and in parallel it is stiffer, k = Σ kᵢ — the spring equivalent of resistors in a circuit. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and mechanics-education tools, spring and suspension design, mechanism and gadget engineering, and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is the force-extension law and elastic energy; for the spring rate of a helical coil from its geometry use a spring-coil API and for spring-mass natural frequency use a vibration API.

Uptime

100.0%

Latency

75ms

Subs

4,460

Inclined-plane and friction statics and dynamics as an API, computed locally and deterministically. The incline endpoint analyses a block on a ramp: from a mass, the slope angle and a coefficient of friction it returns the normal force N = m·g·cosθ, the gravity component along the slope m·g·sinθ, the maximum static friction μ·N, whether the block stays put or slides (it slides when tanθ > μ) and, if it slides, the net force and the acceleration a = g·(sinθ − μ·cosθ). The friction endpoint handles a flat surface: the friction force f = μ·N (the normal force given directly or from a mass), the angle of repose atan(μ), and — given an applied force — whether the object moves and its acceleration. The ramp endpoint gives the force needed to move a load up or down a ramp at constant velocity, F = m·g·(sinθ ± μ·cosθ), the frictionless force, the efficiency and whether the ramp is self-locking. Gravity defaults to 9.80665 m/s² and can be overridden. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and mechanics-education tools, materials-handling, conveyor and ramp design, and engineering-statics apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is inclined-plane forces with friction; for the ideal (frictionless) mechanical advantage of simple machines use a lever API.

Uptime

100.0%

Latency

79ms

Subs

4,043

Magnetic fields and forces as an API, computed locally and deterministically. The wire endpoint computes the magnetic field around a long straight current-carrying wire, B = μ0·I/(2π·r) — the field at a distance r from a wire carrying a current I — and solves for whichever of the current, the distance or the field you leave out, reporting the field in tesla, millitesla, microtesla and gauss. The solenoid endpoint gives the uniform field inside a long solenoid, B = μ0·n·I (n turns per metre, given directly or as a total number of turns over a length), or the field at the centre of a circular loop, B = μ0·N·I/(2R). The force endpoint computes the magnetic force on a moving charge, F = q·v·B·sin(θ) (the Lorentz force), or on a current-carrying wire in a field, F = B·I·L·sin(θ), with the force per metre. The vacuum permeability μ0 = 4π×10⁻⁷ is built in, with an optional relative permeability for a magnetic core. Everything is computed locally and deterministically, so it is instant and private. Ideal for electromagnetism-education tools, electromagnet, motor and inductor design, magnetic-sensor and physics-simulation apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is magnetostatics; for Coulomb electrostatics use a Coulomb API and for Ohm's-law circuits use an Ohm's-law API.

Uptime

100.0%

Latency

78ms

Subs

3,152

Linear momentum, impulse and one-dimensional collisions as an API, computed locally and deterministically. The momentum endpoint computes the linear momentum p = m·v of a moving body, with its kinetic energy, and solves for whichever of the mass, velocity or momentum you leave out. The impulse endpoint applies the impulse-momentum theorem, J = F·Δt = m·Δv = Δp: from a force and a time it gives the impulse and, with a mass, the change in velocity; or from a mass and a velocity change it gives the impulse and the average force over a contact time — the physics of a bat hitting a ball or an airbag softening a crash. The collision endpoint solves a head-on collision between two bodies using conservation of momentum and a coefficient of restitution: e = 1 for a perfectly elastic collision (kinetic energy conserved), e = 0 for a perfectly inelastic one (the bodies stick together), or any value between for a partially inelastic collision — returning both final velocities, the conserved total momentum, the kinetic energy before and after, and the energy lost. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics-education and simulation tools, game and ballistics engines, vehicle-crash and sports apps, and engineering-dynamics software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is linear momentum and collisions; for rotational angular momentum and flywheel energy use a flywheel API.

Uptime

100.0%

Latency

82ms

Subs

3,432

Newton's law of cooling and convective heat transfer as an API, computed locally and deterministically. The convection endpoint applies the convective-heat-transfer rate Q = h·A·ΔT — the heat carried away from a surface equals the convection coefficient times the area times the temperature difference between the surface and the fluid — and solves for whichever of the heat rate, the coefficient, the area or the temperature difference you leave out, with typical coefficients for natural and forced air, water, boiling and condensing built in. The cooling endpoint applies Newton's law of cooling, T(t) = T_env + (T0 − T_env)·e^(−k·t): from an initial temperature, the ambient temperature and a cooling constant (or time constant τ = 1/k) it gives the temperature after a time, or the time to reach a target temperature, or it solves the cooling constant from a measured temperature at a known time — the maths behind how a hot drink, a forensic body or a cooling casting approaches room temperature. The coefficient endpoint links the cooling constant to the physical properties, k = h·A/(m·c), and the thermal time constant. Everything is computed locally and deterministically, so it is instant and private. Ideal for thermal-engineering and HVAC tools, food-safety and forensic cooling apps, electronics-cooling and process-control software, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is convection and transient cooling; for steady conduction through walls use a U-value API and for thermal radiation use a Stefan-Boltzmann API.

Uptime

100.0%

Latency

81ms

Subs

3,276

Coulomb's-law electrostatics as an API, computed locally and deterministically. The force endpoint computes the electrostatic force between two point charges, F = k·q1·q2/(εr·r²) — Coulomb's law, with k = 8.9876×10⁹ N·m²/C² — from the two charges, their separation and an optional relative permittivity for a dielectric medium, and tells you whether the force is attractive (opposite signs) or repulsive (like signs). The field endpoint gives the electric field of a point charge, E = k·q/(εr·r²), its direction (away from a positive charge, toward a negative one), and the force on a test charge placed there, F = q_test·E. The potential endpoint gives the electric potential V = k·q/(εr·r) and, for a pair of charges, the electrostatic potential energy U = k·q1·q2/(εr·r) in joules and electron-volts. Charges may be entered in coulombs, microcoulombs or nanocoulombs. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and electrical-engineering education tools, electrostatics and field-theory apps, and laboratory and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is electrostatics; for Ohm's law and DC/AC circuits use an Ohm's-law API.

Uptime

100.0%

Latency

76ms

Subs

3,359

Aerodynamic drag and terminal-velocity maths as an API, computed locally and deterministically. The drag endpoint computes the drag force on a body moving through a fluid, F_d = ½·ρ·Cd·A·v² — half the fluid density times the drag coefficient, the reference area and the velocity squared — together with the dynamic pressure ½·ρ·v², from a fluid (air, water, seawater, oil and more, or a custom density), a drag coefficient (given directly or from a built-in shape table) the area and the speed. The terminal endpoint computes the terminal velocity of a falling object, v_t = √(2·m·g/(ρ·Cd·A)) — the steady speed at which drag balances gravity — from the mass and area, or for a sphere from its diameter and material density, in metres per second, km/h and mph (a belly-down skydiver reaches about 55 m/s, 200 km/h). The shapes endpoint lists typical drag coefficients for spheres, cubes, cylinders, flat plates, streamlined bodies, skydivers, cars, parachutes and more. Everything is computed locally and deterministically, so it is instant and private. Ideal for aerodynamics and ballistics tools, skydiving, model-rocketry and motorsport apps, sphere-settling and sedimentation calculators, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is drag and terminal velocity; for vacuum projectile and SUVAT kinematics use a physics API and for pipe friction pressure drop use a Darcy-Weisbach API.

Uptime

100.0%

Latency

72ms

Subs

3,670

Wave-optics diffraction and interference as an API, computed locally and deterministically. The double-slit endpoint applies Young's two-slit interference, d·sinθ = m·λ: from a wavelength and the slit separation it returns the angle of the m-th bright fringe and, given the screen distance, the fringe spacing Δy = λ·L/d and the position of any maximum — the classic experiment that proved light is a wave. The grating endpoint handles a diffraction grating, d·sinθ = m·λ with d = 1/lines: from a wavelength and the grating density (lines per millimetre) it gives the diffraction angle of each order and the maximum observable order ⌊d/λ⌋, flagging orders that do not exist. The single-slit endpoint computes single-slit diffraction, a·sinθ = m·λ for the dark fringes (minima), and, given the screen distance, the width of the bright central maximum 2·λ·L/a. Wavelengths may be entered in metres, nanometres or micrometres. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and optics-education tools, spectroscopy and grating design, laser and photonics apps, and laboratory software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is wave-optics diffraction; for thin-lens imaging use a lens API and for Snell's-law refraction use a Snell API.

Uptime

100.0%

Latency

79ms

Subs

3,907

Thin-lens and mirror imaging optics as an API, computed locally and deterministically. The lens endpoint applies the thin-lens equation, 1/f = 1/do + 1/di, and solves for whichever of the focal length, object distance or image distance you leave out, then returns the magnification m = −di/do and the full description of the image — real or virtual, upright or inverted, enlarged, reduced or the same size — and whether the lens is converging (convex, f > 0) or diverging (concave, f < 0). The mirror endpoint does the same for a spherical mirror, taking the focal length or the radius of curvature (f = R/2), classifying it as concave or convex and describing the image. The power endpoint converts between focal length in metres and optical power in diopters, D = 1/f, and combines several thin lenses placed in contact by adding their powers, D_total = ΣD, returning the combined focal length. Distances use whatever consistent unit you supply. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and optics-education tools, lens and optical-system design, eyewear and vision apps, and photography learning. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is geometric-optics imaging; for Snell's-law refraction angles use a Snell API and for camera depth of field and field of view use a photography API.

Uptime

100.0%

Latency

80ms

Subs

4,065

Coriolis and centrifugal forces in a rotating frame as an API, computed locally and deterministically. The coriolis endpoint computes the Coriolis acceleration a = 2·Ω·v·sin(θ) and, given a mass, the Coriolis force F = m·a, for an object moving at a speed in a frame rotating at a given rate — supplied directly in radians per second, as rpm, or as planet=earth (Ω = 7.2921×10⁻⁵ rad/s) — with the angle taken as the latitude for motion over the Earth or an explicit angle to the rotation axis. The centrifugal endpoint computes the centrifugal acceleration a = ω²·r = v²/r and force from a radius and an angular speed (rad/s, rpm or a tangential velocity), and reports the g-force, handy for centrifuges, rotating machinery and amusement rides. The earth endpoint gives the rotation effects at a latitude: the Coriolis parameter f = 2·Ω·sin(lat), the inertial-oscillation period 2π/|f|, the eastward speed of the Earth's surface, the centrifugal acceleration, and which way moving objects are deflected (right in the Northern Hemisphere, left in the Southern). Everything is computed locally and deterministically, so it is instant and private. Ideal for meteorology, oceanography and geophysics tools, centrifuge and rotating-machinery design, ballistics and physics-education apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rotating-frame dynamics; for projectile and SUVAT kinematics use a physics API and for banked-curve cornering use a banked-curve API.

Uptime

100.0%

Latency

78ms

Subs

3,044

Stefan-Boltzmann thermal radiation and Wien's displacement law as an API, computed locally and deterministically. The power endpoint computes the radiant exitance of a surface, M = ε·σ·T⁴ — how much power a body radiates per unit area at a temperature, from its emissivity (1 for a black body) and absolute temperature — and, given the area, the total radiant power in watts and kilowatts; it also solves the temperature from a measured exitance. Temperatures may be entered in kelvin, Celsius or Fahrenheit. The exchange endpoint computes the net radiative heat transfer between an object and its surroundings, Q = ε·σ·A·(T_object⁴ − T_surroundings⁴), telling you whether the object is losing or gaining heat by radiation. The wien endpoint applies Wien's displacement law, λmax = b/T, to give the peak wavelength and frequency of the thermal spectrum and which band it falls in (the Sun at 5778 K peaks in visible green light, a room at 300 K in the infrared), and solves the temperature from a peak wavelength. The Stefan-Boltzmann constant 5.670×10⁻⁸ and Wien constant 2.898×10⁻³ are built in. Everything is computed locally and deterministically, so it is instant and private. Ideal for heat-transfer and building-physics tools, astronomy, infrared-thermography and solar apps, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is thermal-radiation physics; for the RGB colour of a black body at a colour temperature use a colour-temperature API.

Uptime

100.0%

Latency

104ms

Subs

4,184

Archimedes buoyancy and flotation maths as an API, computed locally and deterministically. The buoyancy endpoint computes the buoyant force on a submerged or floating body, Fb = ρ_fluid·g·V_displaced — the upthrust equals the weight of the displaced fluid — from a displaced volume and a fluid (water, seawater, oil, mercury and more, or a custom density), and also gives the mass of displaced fluid; it solves the volume from a known force too. The float endpoint decides whether an object floats, sinks or is neutrally buoyant by comparing its density (given directly, from a built-in material, or as mass divided by volume) with the fluid density, and for a floating object returns the fraction submerged f = ρ_object/ρ_fluid (so 90 % of an iceberg sits below the waterline), or for a sinking object its apparent (underwater) weight. The payload endpoint sizes flotation: the displaced volume needed to float a given load, V = W/(ρ_fluid·g), or the maximum extra payload a floating body of a given volume and density can carry before it submerges, Wmax = (ρ_fluid − ρ_body)·V·g. Everything is computed locally and deterministically, so it is instant and private. Ideal for naval-architecture and marine tools, diving, ROV and ballast apps, raft and pontoon design, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is buoyancy and flotation; for pressure at depth and hydrostatic force on a wall use a hydrostatics API.

Uptime

100.0%

Latency

83ms

Subs

3,391

Lever, moment-balance and simple-machine mechanical-advantage maths as an API, computed locally and deterministically. The lever endpoint applies the lever law, effort·effort_arm = load·load_arm, and solves for whichever of the effort, the load, the effort arm or the load arm you leave out, returning the mechanical advantage MA = effort_arm/load_arm = load/effort and whether the lever multiplies force or speed. The moment endpoint computes a single moment of force, M = F·d, or balances a seesaw about a pivot: from the force and distance on each side it tells you whether it is balanced, the net moment and which way it rotates, or solves the one value you omit to bring it into equilibrium. The machine endpoint gives the ideal mechanical advantage of a simple machine — an inclined plane (length/height), a screw (2πR/pitch), a wheel and axle (R/r), a wedge (length/thickness) or a pulley system (number of supporting strands) — and, given an efficiency and an effort, the actual mechanical advantage and the output force. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and engineering-education tools, mechanics and statics apps, and machine-design and DIY calculators. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is levers and simple-machine mechanical advantage; for gear and belt drive ratios use a gear or belt-drive API.

Uptime

100.0%

Latency

75ms

Subs

3,056

Heat-exchanger LMTD and effectiveness-NTU maths as an API, computed locally and deterministically. The lmtd endpoint computes the log mean temperature difference, LMTD = (ΔT1 − ΔT2)/ln(ΔT1/ΔT2), the true average driving temperature of a heat exchanger, from the hot and cold stream inlet and outlet temperatures for either a counterflow or a parallel-flow arrangement, and flags a temperature cross. The duty endpoint applies Q = U·A·LMTD·F — the heat duty equals the overall heat-transfer coefficient times the area times the LMTD times an optional correction factor — and solves for whichever of the duty, the coefficient, the area or the LMTD you leave out, taking the LMTD directly or from the four temperatures. The effectiveness endpoint uses the effectiveness-NTU method: from the hot and cold heat-capacity rates (given directly or as mass flow times specific heat) and the number of transfer units NTU = U·A/Cmin, it returns the capacity ratio, the effectiveness for the arrangement, and — given the inlet temperatures — the maximum and actual heat duty and the outlet temperatures. Everything is computed locally and deterministically, so it is instant and private. Ideal for process, chemical and mechanical engineering tools, HVAC, refrigeration and thermal-design apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is two-stream heat-exchanger analysis; for the sensible heat of a single stream Q = m·c·ΔT use a specific-heat API.

Uptime

100.0%

Latency

81ms

Subs

3,823

Single-degree-of-freedom vibration (spring-mass-damper) maths as an API, computed locally and deterministically. The natural endpoint gives the undamped natural frequency of a spring-mass system, ωn = √(k/m), fn = ωn/2π and the period T = 1/fn, and solves for whichever of the stiffness, mass or natural frequency you leave out. The damped endpoint analyses a damped system from the stiffness, mass and either a damping coefficient or a damping ratio: it returns the critical damping coefficient cc = 2√(km), the damping ratio ζ = c/cc, the classification (underdamped, critically damped or overdamped), and — for an underdamped system — the damped natural frequency ωd = ωn·√(1−ζ²), its period, and the logarithmic decrement δ = 2πζ/√(1−ζ²). The pendulum endpoint gives the period and frequency of a simple pendulum, T = 2π·√(L/g), and solves the length from a target period, with gravity adjustable. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical, structural and earthquake-engineering tools, machine-condition-monitoring and isolation-design apps, instrument and clock design, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is discrete spring-mass-damper vibration; for standing waves on strings and in air columns use a standing-wave API.

Uptime

100.0%

Latency

79ms

Subs

3,990

Darcy-Weisbach pipe pressure-drop and head-loss as an API, computed locally and deterministically. The friction endpoint gives the Darcy friction factor: laminar flow uses f = 64/Re, and turbulent flow uses the explicit Swamee-Jain approximation of the Colebrook-White equation, f = 0.25/[log₁₀(ε/3.7D + 5.74/Re⁰·⁹)]², from a Reynolds number (given directly, or computed from velocity, diameter and fluid) and the relative roughness, classifying the flow as laminar, transitional or turbulent. The headloss endpoint computes the major head loss hf = f·(L/D)·v²/(2g) from a friction factor (given or derived) and the pipe length, diameter and velocity, and — given the fluid density — the pressure drop Δp = ρ·g·hf in pascals, kilopascals and bar. The pipe endpoint does the whole calculation end to end: from a flow rate or velocity, the pipe diameter, length, fluid (water, seawater, air, oil and more, or a custom density and viscosity) and roughness material, it returns the velocity, Reynolds number, friction factor, head loss, pressure drop and the pumping power needed to overcome friction. Everything is computed locally and deterministically, so it is instant and private. Ideal for plumbing, HVAC and process-piping tools, hydraulics and pump-sizing apps, irrigation and fire-protection design, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is pipe friction pressure drop; for the continuity relation and Reynolds number use a pipe-flow API and for pump power and head use a pump API.

Uptime

100.0%

Latency

76ms

Subs

3,136

Building-fabric thermal maths — U-value, R-value and heat loss — as an API, computed locally and deterministically. The rvalue endpoint takes a wall, roof or floor build-up as a list of layers (each given as a thickness and a thermal conductivity, or a thickness and a named material from a built-in table, or a direct R-value) and adds the interior and exterior surface resistances to return the total thermal resistance R = Rsi + ΣR_layer + Rse and the thermal transmittance U = 1/R, in both metric (RSI, m²K/W and W/m²K) and imperial (R-value) units, with a per-layer breakdown. The layer endpoint gives the R-value of a single material from its thickness and conductivity, R = thickness/conductivity, and solves for whichever of the three you leave out, with conductivities for concrete, brick, timber, plasterboard, mineral wool, EPS, XPS, PIR and more. The heatloss endpoint computes the steady-state heat loss through an element, Q = U·A·ΔT, in watts, BTU per hour and kWh per day from a U-value (or R-value), an area and a temperature difference (direct or as indoor minus outdoor), and an annual figure from heating degree days. Everything is computed locally and deterministically, so it is instant and private. Ideal for building-energy and retrofit tools, architecture and construction apps, insulation and SAP/Passivhaus calculators, and energy-assessment software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is building-fabric thermal performance; for rule-of-thumb HVAC equipment sizing use an HVAC API.

Uptime

100.0%

Latency

75ms

Subs

4,531

Euler column buckling as an API, computed locally and deterministically. The critical-load endpoint computes the Euler critical (buckling) load of a slender column, Pcr = π²·E·I / (K·L)², from the Young's modulus, the second moment of area, the length and the end conditions — pinned-pinned (K=1), fixed-fixed (K=0.5), fixed-pinned (K≈0.7) or fixed-free / cantilever (K=2), or a custom effective-length factor — and, given the cross-section area, also the radius of gyration, slenderness ratio and critical buckling stress. The section endpoint returns the area, the second moment of area about both axes and the radius of gyration for a solid circle, a hollow circle or tube, or a rectangle, and highlights the weak-axis value that governs buckling. The slenderness endpoint computes the slenderness ratio λ = K·L/r and, given the modulus and yield strength, the transition slenderness λ1 = π·√(2E/σy) that separates long Euler columns from short and intermediate ones, classifies the column and returns both the Euler and the J.B. Johnson critical stresses. Everything is computed locally and deterministically, so it is instant and private. Ideal for structural, mechanical and aerospace engineering tools, strut and frame design, machine-design and stability-analysis apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is column buckling and stability; for beam bending, shear and deflection use a beam-statics API.

Uptime

100.0%

Latency

79ms

Subs

4,035

Mohr's circle and 2D (plane) stress transformation as an API, computed locally and deterministically. The principal endpoint takes a plane-stress state — the normal stresses σx and σy and the shear stress τxy — and returns the principal stresses σ1 and σ2 = (σx+σy)/2 ± √(((σx−σy)/2)² + τxy²), the maximum in-plane shear stress, the orientation of the principal and maximum-shear planes, the centre and radius of Mohr's circle, and the von Mises and Tresca equivalent stresses (treating plane stress with the third principal σ3 = 0). The transform endpoint rotates the stress state onto a plane at any angle θ, returning σx', σy' and τx'y' using the standard transformation equations, and confirms the σx+σy invariant. The safety endpoint computes the factor of safety against a material's yield strength under either the von Mises (distortion-energy) or the Tresca (maximum-shear) criterion, from a full stress state or from principal stresses directly. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical, structural and aerospace engineering tools, finite-element pre- and post-processing, machine-design and stress-analysis apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is stress-state analysis; for fillet-weld throat sizing use a weld API and for helical-spring rates use a spring API.

Uptime

100.0%

Latency

73ms

Subs

4,502