#mechanical-engineering

O-ring seal-design maths as an API, computed locally and deterministically — the squeeze, gland and stretch numbers an engineer or maker designs a seal to. The squeeze endpoint gives the compression that makes the seal: squeeze = (cross-section − gland depth) ÷ cross-section, so a 0.139-inch cord in a 0.113-inch deep groove is squeezed 18.7 %, and it grades the result — roughly 10–16 % suits dynamic (reciprocating) seals and 15–30 % static ones — and, given the groove width, the gland fill percentage, which should stay under about 85 % so the rubber has room to expand from heat or fluid swell. The gland endpoint works the other way: from the cross-section and whether the seal is static or dynamic (or a target squeeze) it returns the groove depth and a width sized for about 70 % fill — typically 1.3 to 1.5 times the cross-section — plus a corner radius. The stretch endpoint checks installation: stretch = (mating diameter − o-ring ID) ÷ ID, which should stay under about 5 % on a rod because stretching thins the cross-section and steals squeeze. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical-engineering, hydraulics, pneumatics, vacuum and product-design app developers, seal-selection and gland-design tools, and CAD plugins. Pure local computation — no key, no third-party service, instant. Inches or millimetres. Live, nothing stored. 3 compute endpoints.

api.oanor.com/oring-api

Gear-train ratio, speed and torque maths as an API, computed locally and deterministically. The ratio endpoint computes the gear ratio of a single pair from the driver and driven tooth counts (or pitch diameters), ratio = N_driven/N_driver, classifies it as a reduction (more torque, less speed) or an overdrive, and — given an input speed and torque — returns the output speed (input/ratio) and the output torque (input·ratio·efficiency). The train endpoint computes a compound gear train: the overall ratio is the product of the individual stage ratios, and it returns each stage ratio, the output speed and torque, noting that idler gears change only the direction of rotation, not the ratio. The solve endpoint finds the missing one of the input speed, the output speed and the ratio from the other two — for example, the ratio needed to drop a 1500 rpm motor to a 500 rpm output. Everything is computed locally and deterministically, so it is instant and private. Ideal for drivetrain, robotics and machine-design tools, gearbox and transmission selection, bicycle and vehicle gearing, and mechanical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is gear-train ratio and torque; for spur-gear tooth geometry use a spur-gear API.

api.oanor.com/gearratio-api

Belt-conveyor design maths as an API, computed locally and deterministically. The capacity endpoint computes the throughput of a belt conveyor — the volumetric capacity Q = A·v·3600 (m³/h) from the belt cross-section and speed, and the mass capacity Q·ρ/1000 (t/h) from the bulk density — and, when only the belt width is given, estimates the cross-section as A ≈ load_factor·width². The power endpoint computes the drive power as the sum of the horizontal friction power, μ·g·(material + 2·belt + idler mass per metre)·length·speed, and the vertical lift power, ṁ·g·height, then divides by the drive efficiency to give the motor power. The tension endpoint computes the belt tensions from the effective tension Te = P/v: the tight-side tension T1 = Te·e^(μθ)/(e^(μθ)−1) and the slack-side tension T2 = T1 − Te, using the Euler-Eytelwein grip of the belt on the drive pulley. Everything is computed locally and deterministically, so it is instant and private. Ideal for bulk-materials-handling, mining and plant-design tools, conveyor selection and motor sizing, and mechanical-engineering education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is a simplified belt-conveyor model; for rope/belt capstan friction use a capstan API and for belt-drive geometry use a belt-drive API.

api.oanor.com/conveyor-api

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.

api.oanor.com/pulley-api

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.

api.oanor.com/bolttorque-api

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.

api.oanor.com/crankslider-api

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.

api.oanor.com/bearing-api

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.

api.oanor.com/clutch-api

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.

api.oanor.com/capstan-api

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.

api.oanor.com/hydraulic-api

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.

api.oanor.com/torsion-api

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.

api.oanor.com/youngmodulus-api

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.

api.oanor.com/vibration-api

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.

api.oanor.com/buckling-api

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.

api.oanor.com/mohr-api

Flywheel and rotational-energy dynamics as an API, computed locally and deterministically. The energy endpoint computes the rotational kinetic energy stored in a spinning body, E = ½·I·ω², together with its angular momentum L = I·ω, in joules, kilojoules and watt-hours — from a moment of inertia (given directly, or worked out from a shape, mass and dimension) and an angular speed given as rpm, radians per second or hertz, which it reports in all three. The inertia endpoint returns the moment of inertia about the central axis for the common shapes — solid disk and cylinder (½·m·r²), thin ring and hoop (m·r²), hollow cylinder (½·m·(r_out²+r_in²)), solid sphere (⅖·m·r²), hollow sphere (⅔·m·r²) and a rod about its centre (1/12·m·L²) or end (⅓·m·L²) — from a mass and a radius, diameter or length. The flywheel endpoint sizes a flywheel: give a target energy and an operating speed and it returns the required inertia I = 2E/ω², or give an inertia and a maximum and minimum rpm and it returns the energy delivered between them, ΔE = ½·I·(ω₁²−ω₂²), with the coefficient of fluctuation. Everything is computed locally and deterministically, so it is instant and private. Ideal for mechanical-engineering and energy-storage tools, motor, engine and powertrain design, kinetic-energy-recovery and physics-education apps. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is rotational energy and inertia; for bolt tightening torque use a torque API and for power-screw mechanics use a screw-jack API.

api.oanor.com/flywheel-api