API marketplace

Dimensionless flow-number maths for fluid-mechanics similitude as an API, computed locally and deterministically. The reynolds endpoint computes the Reynolds number, Re = v·L/ν = ρvL/μ — the ratio of inertial to viscous forces — from the velocity, a characteristic length (pipe diameter) and either the kinematic viscosity or the density and dynamic viscosity, and classifies the flow as laminar (< 2300), transitional (2300–4000) or turbulent (> 4000). The froude endpoint computes the Froude number, Fr = v/√(g·L) — the ratio of inertia to gravity used for open-channel and ship flows — together with the critical velocity, and tells you whether the flow is subcritical (tranquil), critical or supercritical (shooting). The mach endpoint computes the Mach number, M = v/c, with the sound speed taken directly or worked out from the air temperature, c = √(γRT), and classifies the speed as subsonic, transonic, supersonic or hypersonic. Everything is computed locally and deterministically, so it is instant and private. Ideal for fluid-mechanics, aerodynamics and hydraulics tools, model-scaling and wind-tunnel similitude, pipe-flow and open-channel analysis, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is dimensionless-number similitude; for pipe friction pressure drop use a Darcy-Weisbach API and for open-channel uniform flow use a Manning API.

Uptime

100.0%

Latency

77ms

Subs

4,385

Reinforcement-steel (rebar) maths as an API, computed locally and deterministically. The area endpoint computes the cross-sectional area of a reinforcing bar, a = π/4·d², its mass per metre (a·7850/1e6, steel ρ = 7850 kg/m³), the total area and mass for a number of bars, and — given a required steel area — the number of bars needed and the area provided. The spacing endpoint lays out bars across a section: from the width, the cover, the bar diameter and either a centre-to-centre spacing or a bar count it returns the other, n = floor((width − 2·cover − d)/spacing) + 1, the total steel area and the area per metre of width. The ratio endpoint computes the reinforcement ratio ρ = As/(b·d) of a section from the steel area (or the bars) and the section width and effective depth, as a fraction and a percentage, the single number that governs whether a beam is under- or over-reinforced. Everything is computed locally and deterministically, so it is instant and private. Ideal for structural and site-engineering tools, reinforced-concrete detailing, bar-bending schedules and steel take-off, and civil-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rebar geometry and quantities; for concrete mix proportions use a concrete API.

Uptime

100.0%

Latency

76ms

Subs

3,879

Concrete mix-design maths as an API, computed locally and deterministically. The mix endpoint breaks down a volume of concrete into its materials from a nominal mix ratio (cement:sand:aggregate, for example 1:2:4): it applies the 1.54 dry-volume allowance, then returns the cement in cubic metres, kilograms and 50 kg bags, the sand and aggregate volumes and masses, and the water from the water-cement ratio — the complete batch for the pour. The quantity endpoint computes the concrete volume of a slab, footing, or round or square column from its dimensions, adds a wastage allowance and gives the dry material volume. The watercement endpoint solves the water-cement ratio, the water or the cement from the other two — the single most important number for concrete strength and durability. Densities used are cement 1440, sand 1600 and aggregate 1450 kg/m³, with a 50 kg cement bag. Everything is computed locally and deterministically, so it is instant and private. Ideal for construction, estimating and site-engineering tools, material take-off and ordering, DIY and builder apps, and civil-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is nominal volume-batch concrete estimating; for retaining-wall earth pressure use an earth-pressure API.

Uptime

100.0%

Latency

78ms

Subs

4,345

Control-valve flow-coefficient (Cv / Kv) maths as an API, computed locally and deterministically. The liquid endpoint sizes a control valve for liquid service using Q = Kv·√(ΔP/SG): give any two of the flow rate (m³/h), the pressure drop across the valve (bar) and the flow coefficient Kv, and it returns the third — the required Kv to size a valve, the flow a valve passes, or the pressure drop it develops — together with the equivalent Cv. The convert endpoint converts between the three flow coefficients in use around the world: the metric Kv, the US Cv = 1.156·Kv, and the SI Av = 2.4e-5·Cv. The opening endpoint computes how far a valve must open to pass an operating Kv against its rated Kvs, for both a linear trim (opening = Kv/Kvs) and an equal-percentage trim (opening = 1 + ln(Kv/Kvs)/ln(R) for a rangeability R), so you can keep the valve in its controllable 20–80 % travel band. Everything is computed locally and deterministically, so it is instant and private. Ideal for process, instrumentation and HVAC engineering tools, control-valve selection and commissioning, hydronic-balancing and plant-design apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is control-valve sizing; for pump power and head use a pump API and for orifice-plate metering use an orifice API.

Uptime

100.0%

Latency

86ms

Subs

4,052

Structural wind-load maths as an API, computed locally and deterministically. The pressure endpoint computes the velocity (dynamic) pressure of wind, q = ½·ρ·v², from the wind speed and air density — the pressure the wind exerts when it is brought to rest against a surface — and also solves the wind speed back from a given pressure, reporting the speed in m/s, km/h and mph. The force endpoint computes the wind force on a surface, F = q·Cf·A, from the velocity pressure (or wind speed), the exposed area and a force coefficient (≈1.3 for a building wall, ≈1.2 for a flat plate), and — given a height — the overturning moment about the base. The beaufort endpoint converts between a wind speed and the Beaufort scale using v = 0.836·B^1.5, returning the Beaufort number, the standard description from calm to hurricane force and the corresponding pressure. Everything is computed locally and deterministically, so it is instant and private. Ideal for structural and façade-engineering tools, signage, solar-array, scaffold and temporary-structure wind checks, sailing and meteorology apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is structural wind pressure and force; for wind-turbine energy output use a wind-power API.

Uptime

100.0%

Latency

82ms

Subs

3,252

Cable voltage-drop and conductor-sizing maths as an API, computed locally and deterministically. The drop endpoint computes the voltage lost along a cable run from the current, the one-way run length, the conductor cross-section and the material: the conductor resistance R = ρ·L/A, the voltage drop Vd = k·I·R (k = 2 for single-phase, √3 for three-phase), the drop as a percentage of the supply and the voltage left at the load. The sizing endpoint works backwards: from an allowable percentage drop it returns the minimum conductor cross-section needed, A ≥ k·I·ρ·L/Vd_allow, rounds up to the next standard cable size (1.5, 2.5, 4, 6, 10, 16, 25 … mm²) and reports the actual drop at that size. The power endpoint computes the power dissipated as heat in the cable, P = N·I²·R (N = 2 or 3 current-carrying conductors), and the cable efficiency given a load power. Copper (ρ = 0.0172) and aluminium (ρ = 0.0282 Ω·mm²/m) are supported. Everything is computed locally and deterministically, so it is instant and private. Ideal for electrical-installation and panel-design tools, cable selection to wiring-regulation limits, solar, EV-charger and sub-main sizing, and electrical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is cable voltage drop and sizing; for Ohm's law, reactance and resonance use an Ohm's-law API and for transformer ratios use a transformer API.

Uptime

100.0%

Latency

79ms

Subs

3,090

Lateral earth-pressure maths (Rankine theory) as an API, computed locally and deterministically for retaining-wall design. The active endpoint computes the active earth pressure that pushes a wall outward when the soil is allowed to yield: the coefficient Ka = (1−sinφ)/(1+sinφ) from the soil friction angle, the pressure at the base of the wall σ = Ka·γ·H, the total thrust per metre run ½·Ka·γ·H², plus the contributions of a surface surcharge and of soil cohesion (which reduces the pressure by 2c√Ka and forms a tension crack of depth 2c/(γ√Ka)). The passive endpoint computes the passive resistance Kp = (1+sinφ)/(1−sinφ) that the soil mobilises when a wall is pushed into it — the resisting pressure and thrust, with cohesion adding 2c√Kp. The atrest endpoint computes the at-rest pressure K0 = 1−sinφ (Jaky) for unyielding walls such as basements and braced excavations. Everything is computed locally and deterministically, so it is instant and private. Ideal for geotechnical and civil-engineering tools, retaining-wall, sheet-pile and basement-wall design, excavation-shoring and foundation apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is Rankine lateral earth pressure; for slope geometry use a slope API and for open-channel weir flow use a weir API.

Uptime

100.0%

Latency

75ms

Subs

4,107

Room-acoustics reverberation-time maths as an API, computed locally and deterministically. The sabine endpoint computes the reverberation time of a room — the RT60, the time for the sound to decay by 60 dB — from the Sabine formula RT60 = 0.161·V/A, where V is the room volume and A the total absorption in metric sabins; you can give the absorption directly, or as a surface area times an average absorption coefficient, and it also solves the absorption you would need to hit a target reverberation time. The eyring endpoint uses the Eyring-Norris formula RT60 = 0.161·V/(−S·ln(1−ᾱ)), which is more accurate than Sabine for absorbent rooms with a high average coefficient, and reports both for comparison. The absorption endpoint builds the absorption budget from a list of surfaces, each with its area and absorption coefficient, returning the total and average absorption and the resulting Sabine RT60, plus the extra absorption needed to reach a target. Everything is computed locally and deterministically, so it is instant and private. Ideal for acoustic-design, studio, classroom and home-theatre tools, room-treatment planning and building-acoustics apps, and audio-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is room reverberation time; for decibel conversion and combining sound levels use a sound-level API.

Uptime

100.0%

Latency

74ms

Subs

4,497

Weir flow maths for open-channel discharge measurement as an API, computed locally and deterministically. The rectangular endpoint computes the flow over a rectangular sharp-crested weir, Q = (2/3)·Cd·b·√(2g)·H^1.5, from the crest width and the head of water above the crest — and solves the head back from a known discharge. The vnotch endpoint computes the flow over a triangular V-notch weir, Q = (8/15)·Cd·√(2g)·tan(θ/2)·H^2.5, from the notch angle and head, the most accurate weir for small flows because the discharge varies with the head to the power 2.5. The broadcrested endpoint computes the flow over a broad-crested weir, Q = Cd·(2/3)^1.5·√g·b·H^1.5 ≈ Cd·1.705·b·H^1.5, the rugged field structure used for river gauging. Each device carries its standard discharge coefficient (rectangular 0.62, V-notch 0.58, broad-crested 0.85) which you can override, and each solves either the discharge from a measured head or the head required for a target discharge. Everything is computed locally and deterministically, so it is instant and private. Ideal for hydrology, irrigation and civil-engineering tools, flow gauging in channels and treatment plants, stormwater and water-resource apps, and fluid-mechanics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is weir overflow discharge; for uniform open-channel flow use a Manning API and for differential-pressure pipe metering use an orifice API.

Uptime

100.0%

Latency

72ms

Subs

4,566

Pulley and block-and-tackle mechanics as an API, computed locally and deterministically. The advantage endpoint computes the mechanical advantage of a pulley system — the ideal MA equals the number of rope parts supporting the load, which is also the velocity ratio — and returns the effort needed to hold or raise a load, effort = load/(n·efficiency), the length of rope that must be pulled (n times the lift height) and the work in and out. The friction endpoint models a real block and tackle where every sheave loses a little tension: the mechanical advantage becomes MA = e·(1−eⁿ)/(1−e) for a per-sheave efficiency e (≈0.96 for a plain bearing, ≈0.98 for a ball bearing), so it returns the true MA, the overall efficiency and the extra effort friction costs you. The solve endpoint takes any two of the load, the effort and the number of rope parts and returns the third — for example, how many parts you need so a given person can raise a given load, or the heaviest load a winch can lift. Everything is computed locally and deterministically, so it is instant and private. Ideal for rigging, lifting and hoist-design tools, sailing, climbing and theatre-rigging apps, crane and winch sizing, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is pulley and block-and-tackle mechanics; for lever and moment balance use a lever API and for rope-around-a-drum capstan friction use a capstan API.

Uptime

100.0%

Latency

75ms

Subs

3,648

Bolted-joint torque, preload and stress maths as an API, computed locally and deterministically for ISO metric fasteners. The torque endpoint applies the torque-tension relation T = K·D·F — the tightening torque equals the nut factor times the nominal diameter times the bolt preload — and solves either way: the torque needed for a target preload, or the preload achieved by a given torque, with the nut factor K capturing the lubrication condition (≈0.20 plain, 0.16 plated, 0.12 lubricated). The stressarea endpoint computes the tensile stress area from the thread geometry, As = π/4·(d − 0.9382·P)² — the effective cross-section that carries the load — together with the nominal shank area and, given a proof or yield stress, the proof and yield loads of the bolt. The preload endpoint sets the clamp force as a percentage of the proof load (75 % is the usual target for reusable joints), F = (percent/100)·σproof·As, and returns the resulting tensile stress and, with a diameter and nut factor, the tightening torque. Grade proof stresses for 8.8, 10.9 and 12.9 bolts are documented. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical-design, assembly and maintenance tools, torque-spec generation, fastener selection and structural-bolting apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is bolt tightening and preload mechanics; for thread pitch/lead geometry use a thread API and for bolt-circle hole patterns use a bolt-circle API.

Uptime

100.0%

Latency

76ms

Subs

3,966

Differential-pressure flow-meter maths (ISO 5167) as an API, computed locally and deterministically for orifice plates, venturi tubes and flow nozzles. The flow endpoint computes the mass and volumetric flow rate from the measured pressure drop across the meter, qm = Cd·ε·E·A·√(2·ρ·ΔP), where E = 1/√(1−β⁴) is the velocity-of-approach factor, β = d/D the diameter ratio and A the bore area — and it reports the throat velocity and the permanent (unrecovered) pressure loss. The pressure endpoint works the other way: from a known flow it returns the differential pressure the meter will develop, ΔP = (qm/(Cd·ε·E·A))²/(2ρ), and the permanent loss. The sizing endpoint solves the meter geometry: from a target flow and an allowable pressure drop it iterates the required bore diameter and diameter ratio, and flags whether β falls in the ISO-recommended 0.2–0.75 range. Each device type carries its standard discharge coefficient (orifice 0.61, venturi 0.984, nozzle 0.96) which you can override. Everything is computed locally and deterministically, so it is instant and private. Ideal for process, HVAC and instrumentation engineering tools, flow-meter selection and commissioning, and fluid-mechanics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is differential-pressure flow metering; for pipe continuity (Q=A·v) use a flow-rate API and for friction pressure drop use a Darcy-Weisbach API.

Uptime

100.0%

Latency

76ms

Subs

3,033

Slider-crank (piston-crank) mechanism kinematics as an API, computed locally and deterministically. The position endpoint takes the crank radius, the connecting-rod length and the crank angle from top dead centre and returns the exact piston displacement from TDC, x = r(1−cosθ) + l(1 − √(1−λ²sin²θ)) with λ = r/l, the piston-pin distance from the crank axis, the connecting-rod swing angle φ = asin(λ·sinθ), the stroke (2r), the rod ratio n = l/r and the fraction of stroke travelled. The velocity endpoint adds the crank speed (as rpm or angular velocity) and returns the exact piston velocity, v = ω·[r·sinθ + r·λ·sinθcosθ/√(1−λ²sin²θ)], and the piston acceleration from the standard two-term approximation a ≈ r·ω²·(cosθ + λ·cos2θ) — the inertia term engine designers use for balancing. The geometry endpoint summarises the whole mechanism: the stroke, the rod ratio, the top- and bottom-dead-centre positions, the maximum connecting-rod angle asin(λ), and — with a speed — the mean piston speed 2·stroke·(rev/s). Everything is computed locally and deterministically, so it is instant and private. Ideal for engine, compressor and pump-mechanism design tools, robotics and linkage simulation, CNC and animation, and mechanical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is slider-crank linkage kinematics; for rotational energy use a flywheel API and for shaft torsion use a torsion API.

Uptime

100.0%

Latency

76ms

Subs

4,825

Rolling-element bearing life maths (ISO 281) as an API, computed locally and deterministically. The life endpoint computes the basic rating life of a ball or roller bearing, L10 = (C/P)^p — where p is 3 for ball bearings and 10/3 for roller bearings — from the dynamic load rating C and the equivalent load P, reporting the life in millions of revolutions and, given a speed in rpm, in hours and days; it also works backwards, solving the minimum dynamic load rating needed for a target life, or the maximum load a bearing can carry to still reach it. The load endpoint computes the equivalent dynamic load P = X·Fr + Y·Fa from the radial and axial loads and the bearing X and Y factors, the single load value the life formula needs. The reliability endpoint applies the ISO 281 life-modification factor a1 to give the adjusted rating life Lna = a1·L10 for any survival probability from 90 % up to 99.95 %, interpolated from the standard reliability table. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical-engineering, maintenance and reliability tools, machine and drivetrain design, predictive-maintenance and lifetime-costing apps, and engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rolling-bearing rating life; for shaft torsion stress use a torsion API and for rotational energy use a flywheel API.

Uptime

100.0%

Latency

77ms

Subs

3,567

Gravity-driven pendulum maths as an API, computed locally and deterministically. The simple endpoint computes the period of a simple pendulum, T = 2π·√(L/g), together with its frequency and angular frequency, and solves for the length needed to give a target period — with an optional large-amplitude correction (the first two terms of the amplitude series) for swings where the small-angle approximation no longer holds. The physical endpoint handles a compound (physical) pendulum — any rigid body swinging about a pivot — from its moment of inertia about the pivot, its mass and the distance from the pivot to its centre of mass, T = 2π·√(I/(m·g·d)), and reports the equivalent simple-pendulum length I/(m·d). The conical endpoint solves a conical pendulum, a bob sweeping a horizontal circle, T = 2π·√(L·cosθ/g), giving the radius of the circle, the speed of the bob, the angular velocity and — with a mass — the string tension m·g/cosθ and the centripetal force. Everything is an idealised system under constant gravity with no air resistance or string mass, computed locally and deterministically, so it is instant and private. Ideal for physics-education and engineering tools, clock and metronome design, swing and amusement-ride dynamics, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is gravity-pendulum dynamics; for spring-mass-damper vibration use a vibration API, for rotational kinetic energy use a flywheel API.

Uptime

100.0%

Latency

85ms

Subs

3,073

Ballistic projectile-motion maths as an API, computed locally and deterministically. The launch endpoint takes a launch speed and angle (and, optionally, a launch height above the landing plane and a custom gravity) and returns the full flight: the horizontal and initial vertical velocity components, the time of flight, the range, the maximum height, the time to the apex and the impact speed and angle — using R = v0²·sin(2θ)/g on flat ground and solving the full quadratic h0 + vy0·t − ½g·t² = 0 when launched from a height. The trajectory endpoint gives the exact state of the projectile — its x and y position, its horizontal and vertical velocity, its speed and its direction — at any given time t or at any given horizontal distance x. The range endpoint works backwards: from a target range it solves the two complementary launch angles that reach it for a given speed (the flat fast shot and the high lob), or the launch speed needed at a chosen angle, and reports the maximum achievable range. Everything is an idealised point mass under constant gravity with no air resistance, computed locally and deterministically, so it is instant and private. Ideal for physics-education and ballistics tools, game and simulation development, sports-trajectory and artillery-style calculators, and STEM teaching. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is ballistic projectile kinematics; for orbital mechanics use an orbital API, for universal gravitation use a gravitation API.

Uptime

100.0%

Latency

81ms

Subs

4,974

555-timer (NE555) astable and monostable design as an API, computed locally and deterministically. The astable endpoint designs the classic oscillator: from the two timing resistors R1 and R2 and the capacitor it returns the output frequency f = 1/(ln2·(R1+2R2)·C), the high and low times (T_high = ln2·(R1+R2)·C, T_low = ln2·R2·C), the period and the duty cycle (R1+R2)/(R1+2R2), or solves the capacitor for a target frequency. The monostable endpoint designs the one-shot timer, T = 1.1·R·C — the pulse width of a single output pulse — and solves for whichever of the resistance, capacitance or pulse width you leave out. The design endpoint works backwards: from a target frequency, a chosen capacitor and a duty cycle it computes the resistor values R1 and R2 you need (a standard 555 needs a duty above 50 %). Capacitors may be entered in farads, microfarads, nanofarads or picofarads. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics-hobbyist and maker tools, oscillator, blinker, PWM and timing-circuit design, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is 555-timer design; for Ohm's law, reactance and RC time constants use an Ohm's-law API.

Uptime

100.0%

Latency

77ms

Subs

3,256

Operational-amplifier gain and bandwidth maths as an API, computed locally and deterministically. The gain endpoint computes the closed-loop gain of an inverting (Av = −Rf/Rin) or non-inverting (Av = 1 + Rf/Rin) amplifier from the feedback and input resistors, gives the gain in decibels (20·log₁₀|Av|) and the output voltage for an input, and solves the feedback resistor needed for a target gain. The summing endpoint computes the output of an inverting summing (adder) amplifier, Vout = −Rf·Σ(Vi/Ri), from any number of weighted inputs — the basis of analogue mixers and digital-to-analogue converters. The bandwidth endpoint applies the gain-bandwidth product, GBW = closed-loop gain × bandwidth, and solves any of the three (a 1 MHz op-amp at a gain of 10 has a 100 kHz bandwidth), and computes the full-power bandwidth from the slew rate and the peak output voltage, f = slew_rate/(2π·Vpeak). Everything is computed locally and deterministically, so it is instant and private. Ideal for analogue-electronics and circuit-design tools, amplifier, filter and sensor-conditioning design, audio and instrumentation apps, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is op-amp amplifier design; for Ohm's law, reactance and resonance use an Ohm's-law API.

Uptime

100.0%

Latency

78ms

Subs

3,113

Rectifier ripple and smoothing-capacitor maths as an API, computed locally and deterministically. The ripple endpoint computes the peak-to-peak ripple voltage left on a reservoir (smoothing) capacitor after a rectifier, Vr = I_load/(f_ripple·C), where the ripple frequency is the line frequency for a half-wave rectifier and twice it for a full-wave or bridge rectifier — and it solves for whichever of the load current, the capacitance or the ripple you leave out, also giving the RMS ripple. The capacitor endpoint sizes the smoothing capacitor for a target ripple, C = I_load/(f_ripple·Vr), and the energy it stores. The output endpoint gives the DC output of the rectifier from the transformer RMS voltage: the peak Vrms·√2, minus the diode drops in the conduction path (one for half-wave and centre-tapped, two for a bridge), the average DC voltage and, given the ripple, the ripple factor. Everything is computed locally and deterministically, so it is instant and private. Ideal for power-supply and electronics-design tools, linear PSU, charger and audio-amplifier design, and electronics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rectifier ripple and filtering; for Ohm's law, reactance and RC time constants use an Ohm's-law API.

Uptime

100.0%

Latency

82ms

Subs

4,340

Friction clutch and disc-brake torque as an API, computed locally and deterministically. The clutch endpoint computes the torque a plate (disc) clutch can transmit from the friction coefficient, the axial clamping force and the friction-face inner and outer radii, by both standard theories — uniform-wear, T = n·μ·F·(Ro+Ri)/2, and uniform-pressure, T = ⅔·n·μ·F·(Ro³−Ri³)/(Ro²−Ri²) — for any number of friction surfaces (a multi-plate clutch multiplies the torque), plus the maximum power at a given speed. The cone endpoint does the same for a cone clutch, T = n·μ·F·Rm/sin α, where the wedge angle amplifies the normal force by 1/sin α. The brake endpoint gives the braking torque of a disc brake, T = n·μ·F·R_eff, the power dissipated at a speed and — given a rotating inertia and its speed — the angular deceleration, the time and number of revolutions to stop, and the kinetic energy turned into heat. Everything is computed locally and deterministically, so it is instant and private. Ideal for drivetrain, automotive and machine-design tools, clutch, brake and winch engineering, and mechanical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rotating-friction clutch and brake torque; for shaft torsion stress use a torsion API and for rope/belt capstan friction use a capstan API.

Uptime

100.0%

Latency

78ms

Subs

3,678

Capstan and belt-friction maths (the Euler-Eytelwein equation) as an API, computed locally and deterministically. The capstan endpoint applies T1/T2 = e^(μ·β) — the ratio of the tight-side to the slack-side tension of a rope or belt wrapped around a drum depends only on the friction coefficient and the wrap angle, not the drum diameter — and solves for whichever of the two tensions, the friction or the wrap angle you leave out, with the wrap angle given in degrees, radians or whole turns. The holding endpoint shows the capstan effect: how a small force holds or moves a large load, holding force = Load·e^(−μβ) and pulling force = Load·e^(+μβ) — a few turns of rope around a bollard lets one person hold a ship. The belt endpoint sizes a belt drive: from the maximum tight-side tension, the friction and the wrap angle it gives the slack-side tension, the effective (net) tension T1 − T2 that drives the load and, with the belt speed, the maximum power transmittable before the belt slips. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical and marine-engineering tools, belt-drive, winch, hoist and band-brake design, climbing and rigging apps, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is belt and rope friction; for belt length, wrap angle and speed ratio use a belt-drive API.

Uptime

100.0%

Latency

86ms

Subs

4,672

Pascal's-principle hydraulics as an API, computed locally and deterministically. The press endpoint computes the force multiplication of a hydraulic press, jack or master/slave cylinder: a pressure P = F/A acts equally throughout a connected fluid, so a small input force on a small piston becomes a large output force on a large piston, F2 = F1·A2/A1, with the mechanical advantage A2/A1 — areas given directly or as piston diameters, and the pressure in pascals, bar and psi. The stroke endpoint applies volume conservation, A1·d1 = A2·d2: the big piston moves less the more force it gains, and the work F·d is the same on both sides. The cylinder endpoint gives the push and pull force of a hydraulic cylinder at a pressure, F = P·A on the bore side and F = P·(A_bore − A_rod) on the rod (annulus) side. Everything is computed locally and deterministically, so it is instant and private. Ideal for hydraulics and fluid-power engineering tools, press, jack and lift design, brake and machine apps, and physics education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is Pascal-principle force multiplication; for pressure at depth and force on a submerged wall use a hydrostatics API and for pump power use a pump API.

Uptime

100.0%

Latency

70ms

Subs

4,023

AC power triangle and power-factor maths as an API, computed locally and deterministically. The power-factor endpoint solves the power triangle: from any two of the apparent power S (volt-amperes), the real power P (watts), the reactive power Q (VAR), the power factor (cos φ) or the phase angle it returns all of them, using S = √(P²+Q²), P = S·cosφ, Q = S·sinφ and PF = P/S. The load endpoint computes the powers of a load directly from its voltage, current and power factor — single-phase S = V·I or three-phase S = √3·V·I from line values. The correction endpoint sizes power-factor correction: the reactive power a capacitor must supply to raise the power factor from a present value to a target, Qc = P·(tanφ1 − tanφ2), and — given the supply voltage and frequency — the capacitance, C = Qc/(2π·f·V²), the basis of cutting reactive demand and utility penalties. Everything is computed locally and deterministically, so it is instant and private. Ideal for electrical-engineering and power-systems tools, motor, industrial and HVAC load analysis, energy-billing and power-quality apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is AC power and power-factor correction; for Ohm's law, reactance and resonance use an Ohm's-law API.

Uptime

100.0%

Latency

76ms

Subs

4,602

Newtonian gravitation as an API, computed locally and deterministically. The force endpoint applies Newton's law of universal gravitation, F = G·m1·m2/r² — the attractive force between two masses a distance apart, with G = 6.6743×10⁻¹¹ — and solves for whichever of the two masses, the separation or the force you leave out (the Earth and Moon pull on each other with about 2×10²⁰ newtons). The field endpoint gives the gravitational field strength g = G·M/r² at a distance from a mass, or the surface gravity of a built-in body (the Sun, the planets, the Moon and major moons), as a multiple of Earth gravity, and the weight of a test mass placed there. The weight endpoint tells you what something weighs on another world, W = m·g_body — your weight on the Moon, Mars or Jupiter — from a mass or your Earth weight, with the ratio to Earth. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics and astronomy-education tools, space and planetary apps, science museums and games, and engineering. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is gravitational force, field and weight; for orbital speed, period and escape velocity use an orbital-mechanics API.

Uptime

100.0%

Latency

79ms

Subs

4,813