API marketplace

Knitting and crochet gauge maths as an API, computed locally and deterministically. The stitches endpoint turns a gauge — the standard stitches and rows per 10 cm measured from a tension swatch — into the number of stitches to cast on for a target width and the number of rows for a target length; at 22 stitches and 30 rows per 10 cm, a 50 cm wide by 60 cm long piece needs 110 stitches and 180 rows. The gauge endpoint works backwards from a measured swatch, converting a count over a measured distance into stitches (or rows) per 10 cm, per centimetre and per inch — 33 stitches over 15 cm is a gauge of 22 per 10 cm. The convert-pattern endpoint re-scales a pattern written for one gauge to your own gauge so the finished garment keeps its intended size: your count = pattern count · (your gauge / pattern gauge), so a 100-stitch cast-on at a 20-per-10 cm pattern becomes 110 at your 22-per-10 cm tension. Dimensions are in centimetres. Everything is computed locally and deterministically, so it is instant and private. Ideal for knitting, crochet, pattern-design, craft-marketplace and maker app developers, gauge and tension calculators, and yarn-shop tools. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is gauge and stitch maths; works for crochet too by using your stitch gauge.

Uptime

100.0%

Latency

78ms

Subs

3,961

3D-printing filament maths as an API, computed locally and deterministically. The length-weight endpoint converts between the length and the weight of a spool of filament from its diameter (1.75 mm or 2.85 mm) and material density, using weight = (π/4·d²·length)·density — so one metre of 1.75 mm PLA weighs about 2.98 g, a standard 1 kg PLA spool holds roughly 335 m, and the same weight of the lighter ABS gives about 400 m. The cost endpoint computes the filament cost of a print from the weight or length used and the price per kilogram, and the spool-remaining endpoint turns a remaining-weight measurement (weigh the spool, subtract the empty-spool weight) into the remaining length so you know whether a job will finish. Built-in densities cover PLA, ABS, PETG, TPU, nylon, ASA, PC, HIPS, PVA, wood-fill and carbon-fibre blends, or supply your own. Diameters are in millimetres, lengths in metres and weights in grams. Everything is computed locally and deterministically, so it is instant and private. Ideal for 3D-printing, maker, print-farm, slicer-plugin, prototyping and STEM-education app developers, filament-usage and print-cost tools, and workshop software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is filament geometry and cost; for tank or material volume use a volume API.

Uptime

100.0%

Latency

77ms

Subs

4,651

Pet-age conversion as an API, computed locally and deterministically. The dog endpoint converts a dog’s age in years to a human-equivalent age three ways: the modern epigenetic model from the 2019 UCSD DNA-methylation study, human = 16·ln(dog_age) + 31 (valid from age 1), which makes a 1-year-old dog about 31, a 4-year-old about 53 and a 10-year-old about 68 human years; the American Kennel Club size-based table for small, medium, large and giant breeds, interpolated between yearly anchor points so a large breed ages faster late in life; and the old ×7 rule of thumb for comparison. The cat endpoint converts a cat’s age, counting 15 human years in the first year, 24 by the second, and four per year after that, so a 10-year-old cat is about 56. Ages are in years and decimals are allowed. Everything is computed locally and deterministically, so it is instant and private. Ideal for pet, veterinary, animal-shelter, pet-insurance and lifestyle app developers, dog-years and pet-profile widgets, and fun tools. These are estimates for general guidance, not veterinary advice. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 2 endpoints. This is pet-to-human age; for human body metrics use a BMI or body-fat API.

Uptime

100.0%

Latency

84ms

Subs

4,817

Tyre-size geometry as an API, computed locally and deterministically. The dimensions endpoint parses a metric tyre code such as 205/55R16 — or separate width, aspect ratio and rim values — into its full geometry: the sidewall height (width·aspect/100), the overall diameter (rim·25.4 + 2·sidewall) in millimetres and inches, the rolling circumference, and the revolutions per kilometre and per mile; a 205/55R16 works out to a 112.75 mm sidewall and a 631.9 mm (24.88 in) outside diameter. The compare endpoint takes an original and a replacement size and computes the speedometer error and ground-clearance change of swapping between them: because the speedometer is calibrated to the original rolling diameter, a larger tyre makes it read low, so true speed = indicated · OD_new/OD_old, and a tyre that is 2 % bigger means an indicated 100 is really about 102 km/h. Staying within ±3 % keeps the error and clearance change small. Tyre codes use the metric P-metric/Euro-metric form. Everything is computed locally and deterministically, so it is instant and private. Ideal for automotive, tyre-shop, fitment, car-enthusiast, fleet and vehicle-spec app developers, plus-sizing and speedo-error tools, and garage software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 2 endpoints. This is metric tyre geometry; for fuel economy use a fuel-economy API.

Uptime

100.0%

Latency

81ms

Subs

4,165

Landscape-material volume estimating as an API, computed locally and deterministically. The volume endpoint computes how much mulch, topsoil, compost or gravel a bed needs as area × depth — from an explicit area or from length × width or a circular diameter/radius, with the depth given in metres, centimetres, feet or inches — and reports the result in cubic metres, cubic yards, cubic feet and litres; a 10 m × 5 m bed at 7.5 cm (3 in) deep needs 3.75 m³, about 4.9 cubic yards, and pass a bag size to also get the number of bags (75 fifty-litre bags). The coverage endpoint inverts it: the area a known volume covers at a chosen depth — one cubic yard at 2 inches deep covers about 15 m² (162 sq ft). The bags endpoint returns how many bags of a given litre size supply a required volume. Lengths use unit=m (default) or unit=ft, and depth also accepts depth_cm or depth_inches. Everything is computed locally and deterministically, so it is instant and private. Ideal for landscaping, gardening, home-improvement, nursery, hardscape and contractor-estimating app developers, mulch-and-soil calculators and material-ordering tools, and trade software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is loose-material volume by geometry; for structural concrete mixes use a concrete API.

Uptime

100.0%

Latency

80ms

Subs

3,782

Computus and calendar maths as an API, computed locally and deterministically. The easter endpoint computes the date of Easter Sunday for any year — both the Western date, by the Anonymous Gregorian (Meeus/Jones/Butcher) algorithm, and the Orthodox date, by the Julian computus converted to the Gregorian calendar — with the month name and weekday; Easter is the first Sunday after the paschal full moon, so 2024 falls on 31 March in the West and 5 May for the Orthodox church, while in 2025 both coincide on 20 April. The movable-feasts endpoint returns the whole Easter-anchored cycle for a year as calendar dates — Ash Wednesday (−46 days), Palm Sunday (−7), Maundy Thursday (−3), Good Friday (−2), Ascension (+39), Pentecost (+49) and Corpus Christi (+60). The julian-day endpoint converts a Gregorian date to its Julian Day Number — the continuous day count astronomers use, where 2451545 is 1 January 2000 — and back, returning the weekday too. Years are in the Gregorian calendar. Everything is computed locally and deterministically, so it is instant and private. Ideal for calendar, scheduling, liturgical, church, holiday-planning and date-arithmetic app developers, movable-feast and Julian-day tools, and almanac software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is the computus and Julian-day conversion; for general date arithmetic and time zones use a date-time API.

Uptime

100.0%

Latency

75ms

Subs

3,657

Survey and poll sample-size planning as an API, computed locally and deterministically. The proportion endpoint computes the number of respondents needed to estimate a proportion within a target margin of error at a chosen confidence level, n = z²·p(1−p)/E², defaulting to the worst-case p = 0.5 that maximises the required size, with an optional finite-population correction n/(1 + (n−1)/N) for a known population — the classic ±5 % margin at 95 % confidence needs 385 responses, ±3 % needs 1 068, and capping the population at 1 000 cuts the ±5 % requirement to 278. The mean endpoint sizes a sample for estimating a mean to within a margin of error from the standard deviation, n = (z·σ/E)². The margin endpoint inverts the relationship, returning the margin of error a given sample size actually achieves. The critical z-value is computed from the confidence level with a high-accuracy inverse-normal so any confidence works, not just the textbook 90/95/99 %. Margins, proportions and confidence are decimals (0.05, 0.5, 0.95). Everything is computed locally and deterministically, so it is instant and private. Ideal for market-research, polling, UX-research, survey-platform, product-analytics and statistics-education app developers, study-planning and sample-size tools, and research software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is sample-size planning with the normal approximation; for A/B-test significance use an A/B-test API and for descriptive statistics a statistics API.

Uptime

100.0%

Latency

76ms

Subs

3,896

Linear least-squares regression as an API, computed locally and deterministically. The linear endpoint fits the best straight line y = a + b·x through a set of x/y data points by ordinary least squares, returning the slope b = Σ((x−x̄)(y−ȳ))/Σ(x−x̄)², the intercept a = ȳ − b·x̄, the ready-to-use equation, the Pearson correlation r and the coefficient of determination R² (the fraction of variance the line explains), and the residual and slope standard errors — the points (1,2),(2,4),(3,5),(4,4),(5,5) fit to y = 2.2 + 0.6·x with R² = 0.6, and a perfectly linear set returns R² = 1. Pass a predict_x and it also extrapolates the fitted value at that point. The predict endpoint evaluates y = intercept + slope·x for a known line. The x and y lists may be given as comma-separated values (x=1,2,3&y=2,4,5) or as JSON arrays in a POST body and must be equal length. Everything is computed locally and deterministically, so it is instant and private. Ideal for data-science, analytics, BI, forecasting, machine-learning-preprocessing and statistics-education app developers, trend-line and best-fit tools, and dashboards. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 2 endpoints. This is the regression line; for the Pearson correlation alone or descriptive statistics use a statistics API and for probability distributions a probability API.

Uptime

100.0%

Latency

82ms

Subs

4,651

Centre-of-mass and barycentre mechanics as an API, computed locally and deterministically. The point-masses endpoint computes the centre of mass of a system of point masses in one, two or three dimensions, applying x_com = Σ(m_i·x_i)/Σm_i to each axis from a list of masses and their x (and optional y and z) coordinates — masses of 1, 2 and 3 at positions 0, 1 and 2 give a centre of mass at 1.333, and four equal masses at the corners of a square sit at its centre. The two-body endpoint computes the barycentre of two masses separated by a distance, r1 = d·m2/(m1+m2) from the first body, which always lies closer to the heavier one — for the Earth-Moon system the barycentre is about 4 670 km from Earth’s centre, still inside the planet. Lists may be passed as comma-separated values (masses=1,2,3&x=0,1,2) or as JSON arrays in a POST body, and units are consistent and unit-agnostic. Everything is computed locally and deterministically, so it is instant and private. Ideal for physics, engineering-statics, astronomy, robotics, game-physics and mechanics-education app developers, balance-point and barycentre tools, and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 2 endpoints. This is the centre of mass; for the rotational moment of inertia use a moment-of-inertia API.

Uptime

100.0%

Latency

82ms

Subs

4,573

Roofing geometry as an API, computed locally and deterministically. The pitch endpoint converts freely between the three ways trades describe a roof slope — the pitch as rise per 12 of run (the X:12 notation), the angle in degrees and the slope as a percentage — using angle = atan(pitch/12); a 6:12 roof is 26.57° and a 50 % slope, and it also returns the pitch multiplier √(1 + tan²) that scales a flat plan length to the true along-slope length. The rafter endpoint computes the common rafter length from the horizontal run and the pitch, rafter = √(run² + rise²) with rise = run·tan(angle), and adds the along-slope length of an optional horizontal overhang — a 12-unit run at 6:12 needs a 13.42-unit rafter. The area endpoint converts a flat building footprint into the actual sloped roof surface area, footprint / cos(angle), the figure you need to order shingles, membrane or underlay; a 100 m² footprint under a 6:12 roof is about 111.8 m². Lengths are unit-agnostic — use a consistent unit. Everything is computed locally and deterministically, so it is instant and private. Ideal for roofing, construction, contractor-estimating, home-improvement, solar-install and architecture app developers, take-off and material-ordering tools, and trade software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is roofing-specific geometry; for a general grade or gradient use a slope API.

Uptime

100.0%

Latency

75ms

Subs

4,952

X-ray crystallography maths as an API, computed locally and deterministically. The angle endpoint applies Bragg’s law, n·λ = 2·d·sinθ, to give the diffraction angle θ and the experimentally plotted 2θ from a crystal’s inter-planar spacing and the X-ray wavelength, defaulting to the common Cu Kα source at 0.15406 nm and reporting the highest observable order ⌊2d/λ⌋ — a 0.2 nm plane spacing diffracts Cu Kα to θ ≈ 22.65°, a 2θ peak near 45.3°. The spacing endpoint inverts the law, d = n·λ/(2·sinθ), reading the lattice spacing straight off a measured XRD peak — the everyday job of indexing a diffraction pattern, so a 2θ of 31.77° for table salt gives the 0.2814 nm (200) spacing. The wavelength endpoint solves λ = 2·d·sinθ/n to identify or calibrate the source. Lengths are entered in nanometres or ångström and angles in degrees, and any diffraction order n is supported. Everything is computed locally and deterministically, so it is instant and private. Ideal for materials-science, crystallography, mineralogy, XRD, semiconductor and solid-state-physics app developers, lattice-spacing and pattern-indexing tools, and laboratory software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is reflection-geometry Bragg diffraction with the 2d factor; for optical double-slit and grating diffraction use a wave-optics diffraction API.

Uptime

100.0%

Latency

78ms

Subs

3,493

Photometry and lighting maths as an API, computed locally and deterministically. The illuminance endpoint computes the light falling on a surface from a point source, E = I·cos(θ)/d² in lux, from the luminous intensity in candela, the distance in metres and the angle of incidence from the surface normal — a 1000 cd source straight down at 2 m gives 250 lux. The inverse-square endpoint scales a known illuminance to a new distance, E2 = E1·(d1/d2)², so doubling the distance quarters the light. The flux-intensity endpoint converts between luminous flux in lumens and luminous intensity in candela through the solid angle, I = Φ/Ω and Φ = I·Ω, with the solid angle taken as the full sphere 4π steradian for an isotropic source or, for a spotlight of full beam angle β, Ω = 2π·(1 − cos(β/2)) — so a 100 cd isotropic source emits about 1256.6 lm, and a 1000 cd lamp in a 30° beam emits about 214 lm. Distances are in metres and angles in degrees. Everything is computed locally and deterministically, so it is instant and private. Ideal for lighting-design, architecture, photography, film, horticulture-grow-light, stage and AV app developers, lux-and-lumen and luminaire-planning tools, and engineering software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. These are photometric (perceived-light) quantities; for blackbody/peak-wavelength radiometry use a Wien/radiation API.

Uptime

100.0%

Latency

78ms

Subs

3,220

Body-fat-percentage and body-composition maths as an API, computed locally and deterministically. The navy endpoint applies the US Navy circumference method — for men %BF = 495/(1.0324 − 0.19077·log10(waist − neck) + 0.15456·log10(height)) − 450, and for women a formula that adds the hip measurement — to estimate body fat from a tape measure alone, returning the percentage and the fitness category (essential, athletes, fitness, acceptable or obese); a man of 178 cm with a 40 cm neck and 90 cm waist reads about 18.7 %. The deurenberg endpoint gives the BMI-based estimate %BF = 1.20·BMI + 0.23·age − 10.8·(1 if male) − 5.4 from BMI or weight and height plus age. The composition endpoint splits a total weight into fat mass and lean (fat-free) mass from a body-fat percentage. Circumferences and height are in centimetres and weight in kilograms. Everything is computed locally and deterministically, so it is instant and private. Ideal for fitness, wellness, gym, nutrition, body-tracking and health-education app developers, body-composition and progress-tracking tools, and coaching software. These are estimation formulas, not a substitute for DEXA or professional assessment. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is body-fat percentage; for body-mass index use a BMI API and for basal metabolic rate a BMR API.

Uptime

100.0%

Latency

72ms

Subs

3,042

Ideal body weight and clinical body-metric maths as an API, computed locally and deterministically. The ideal endpoint computes ideal body weight from height and sex by the four standard formulas — Devine (the clinical standard for drug dosing), Robinson, Miller and Hamwi — each adding a per-inch increment for every inch above 5 ft, plus their average; a 5 ft 10 in (178 cm) man comes out at 73.0 kg by Devine. The adjusted endpoint computes the adjusted body weight used to dose drugs in overweight patients, ABW = IBW + 0.4·(actual − IBW), from height, sex and actual weight. The bsa endpoint computes body surface area — central to chemotherapy and cardiac-index dosing — by the Mosteller (√(height·weight/3600)), Du Bois and Haycock formulas, so a 180 cm, 80 kg adult is about 2.0 m². Height is accepted in centimetres or inches and weight in kilograms. Everything is computed locally and deterministically, so it is instant and private. Ideal for digital-health, EHR, pharmacy, clinical-decision-support, telemedicine and medical-education app developers, dosing and body-metric tools, and health software. These are clinical estimation formulas, not a substitute for professional medical judgement. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is ideal/adjusted weight and body surface area; for body-mass index use a BMI API.

Uptime

100.0%

Latency

84ms

Subs

4,308

Investment growth and return maths as an API, computed locally and deterministically. The cagr endpoint computes the compound annual growth rate, CAGR = (end/begin)^(1/years) − 1 — the single smoothed annual rate that compounds a starting value into an ending value — together with the total return and the growth multiple, so €1,000 growing to €2,000 over five years works out to about 14.87 %/yr. The future-value endpoint compounds a single lump sum, FV = PV·(1+r)^n, and the present-value endpoint discounts a future lump sum back to today, PV = FV/(1+r)^n. The annualize endpoint converts a total holding-period return over a span of years into an equivalent annual rate, and back the other way. The doubling-time endpoint gives the exact time for money to double, ln2/ln(1+r), alongside the Rule-of-72, Rule-of-70 and Rule-of-69.3 quick estimates — at 8 % money doubles in about nine years. Rates are decimals (0.07 = 7 %) except the doubling endpoint which takes a percentage. Everything is computed locally and deterministically, so it is instant and private. Ideal for fintech, investing, portfolio, robo-advisor, personal-finance and finance-education app developers, return-and-growth calculators, and dashboards. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. These are single-sum growth and return metrics; for level-payment loans use a loan API and for regular-deposit savings a savings API.

Uptime

100.0%

Latency

75ms

Subs

4,872

Black-Scholes-Merton European option pricing as an API, computed locally and deterministically. The price endpoint computes the fair value of a European call and put from the spot price, strike, annualized risk-free rate, annualized volatility, time to expiry in years and an optional continuous dividend yield, using Call = S·e^(−qT)·N(d1) − K·e^(−rT)·N(d2) and the put-call-parity put, with d1 = [ln(S/K) + (r − q + σ²/2)·T]/(σ√T) and d2 = d1 − σ√T and a high-accuracy standard-normal CDF — an at-the-money option on a 100 spot with a 5 % rate, 20 % volatility and one year to expiry is worth about 10.45 for the call and 5.57 for the put. The greeks endpoint returns the full risk sensitivities for both call and put: delta (∂V/∂S), gamma (∂²V/∂S²), vega (∂V/∂σ, per 1.00 and per 1 % point), theta (∂V/∂t, per year and per calendar day) and rho (∂V/∂r). Rates, dividend yield and volatility are annualized and time is in years, continuous compounding. Everything is computed locally and deterministically, so it is instant and private. Ideal for fintech, trading, quant, portfolio-risk, derivatives and finance-education app developers, option-pricing and Greeks dashboards, and risk engines. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 2 endpoints. This is the European Black-Scholes model; for American-style early exercise or implied volatility solving it returns the closed-form European result only.

Uptime

100.0%

Latency

82ms

Subs

3,807

Stellar-parallax and astrometry maths as an API, computed locally and deterministically. The distance endpoint turns a measured trigonometric parallax angle into a distance using d(pc) = 1/p(arcsec), accepting the parallax in arcseconds or milliarcseconds and returning the distance in parsecs, light-years and astronomical units — a parallax of one arcsecond is one parsec (≈3.2616 light-years) by definition, and Proxima Centauri’s 0.7687-arcsecond parallax gives about 1.30 pc, or 4.24 light-years. The parallax endpoint inverts it, p(arcsec) = 1/d(pc), giving the tiny annual back-and-forth angle a star traces against the background as Earth orbits the Sun. The proper-motion endpoint computes a star’s tangential (transverse) velocity across the sky from its proper motion and distance, v_t = 4.74047·μ(arcsec/yr)·d(pc) km/s — Barnard’s Star, with a proper motion of about 10.39 arcsec/yr at 1.83 pc, races across the sky at roughly 90 km/s. Everything is computed locally and deterministically, so it is instant and private. Ideal for astronomy, astrophysics, planetarium, education and science-communication app developers, star-distance and stellar-kinematics tools, and Gaia-catalogue post-processing. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is geometric distance and kinematics; for a star’s apparent and absolute brightness use a star-magnitude API.

Uptime

100.0%

Latency

83ms

Subs

3,656

Convective heat-transfer dimensionless numbers as an API, computed locally and deterministically. The prandtl endpoint computes the Prandtl number Pr = μ·cp/k (or ν/α), the ratio of momentum to thermal diffusivity that sets the relative thickness of the velocity and thermal boundary layers — air is about 0.71 and water about 7 at 20 °C. The grashof endpoint computes the Grashof number Gr = g·β·|ΔT|·L³/ν², buoyancy versus viscous forces in natural convection (for an ideal gas the thermal-expansion coefficient β ≈ 1/T). The rayleigh endpoint gives the Rayleigh number Ra = Gr·Pr, either from Gr and Pr or from the full natural-convection inputs, which governs the onset of convection (critical ≈ 1708 for a heated horizontal layer). The peclet endpoint computes the Péclet number Pe = Re·Pr = v·L/α, advection versus diffusion of heat. The biot endpoint computes the Biot number Bi = h·L/k and flags whether the lumped-capacitance transient model applies (Bi < 0.1). All inputs are SI. Everything is computed locally and deterministically, so it is instant and private. Ideal for thermal-engineering, HVAC, electronics-cooling, CFD, process-engineering and heat-transfer-education app developers, natural-convection and transient-conduction tools, and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 5 endpoints. These are convective heat-transfer groups; for the Reynolds number alone use a Reynolds API and for surface-tension numbers a Weber API.

Uptime

100.0%

Latency

75ms

Subs

3,766

Tank-gauging geometry as an API, computed locally and deterministically. The horizontal-cylinder endpoint computes the liquid volume in a partially-filled horizontal cylindrical tank from the fill height, the radius (or diameter) and the length, V = L·[r²·acos((r−h)/r) − (r−h)·√(2rh−h²)] — the non-linear relationship that makes a horizontal tank read so unintuitively, e.g. a tank filled to a quarter of its diameter holds only about 20 % of its capacity, while half height is exactly half full. The vertical-cylinder endpoint gives the straightforward V = π·r²·h for an upright tank. The sphere endpoint computes the volume in a spherical tank filled to a height h as the spherical cap V = π·h²·(3r−h)/3, exactly half the sphere at h = r. Every response returns the liquid volume in cubic metres and litres, the full capacity, and the fill percentage. All lengths are in metres. Everything is computed locally and deterministically, so it is instant and private. Ideal for industrial, fuel-station, agriculture, water-utility, chemical-storage and process app developers, tank-gauging, dipstick-to-volume and inventory tools, and IoT level sensors. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is tank volume by geometry; for flow rate through a pipe use a flow-rate API.

Uptime

100.0%

Latency

77ms

Subs

3,924

Surface-tension dimensionless numbers for droplets, sprays, atomization and two-phase flow as an API, computed locally and deterministically. The weber endpoint computes the Weber number We = ρ·v²·L/σ — the ratio of inertia to surface tension — and classifies the secondary-droplet-breakup regime (no breakup below We≈12, then bag, multimode, sheet-thinning and catastrophic breakup), the key number for atomization and spray formation. The capillary endpoint gives the Capillary number Ca = μ·v/σ, the ratio of viscous to surface-tension forces used in coating and microfluidics. The bond endpoint computes the Bond (Eötvös) number Bo = Δρ·g·L²/σ, gravity versus surface tension, which governs whether a drop stays spherical or is flattened by gravity. The ohnesorge endpoint gives the Ohnesorge number Oh = μ/√(ρ·σ·L) = √We/Re, viscosity versus inertia and surface tension, plus the inkjet printability number Z = 1/Oh whose sweet spot is roughly 1 < Z < 14. All quantities are SI: density kg/m³, velocity m/s, length m, surface tension N/m, viscosity Pa·s (water σ ≈ 0.0728 N/m at 20 °C). Everything is computed locally and deterministically, so it is instant and private. Ideal for microfluidics, inkjet, spray, atomization, coating, lab-on-a-chip and fluid-physics-education app developers, droplet-regime and printability tools, and research software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. These are the dimensionless ratios; for capillary rise (Jurin) and Young-Laplace pressure use a capillary/surface-tension API.

Uptime

100.0%

Latency

87ms

Subs

3,984

Froude-number hydrodynamics as an API, computed locally and deterministically. The number endpoint computes the Froude number Fr = v/√(g·L) — the dimensionless ratio of inertial to gravitational forces — from a velocity and a characteristic length, classifies the flow as subcritical (Fr<1, tranquil), critical (Fr=1) or supercritical (Fr>1, rapid), and returns the critical velocity √(g·L) at which Fr=1; the velocity endpoint inverts it to v = Fr·√(g·L). The channel endpoint gives the open-channel Froude number from a flow velocity and depth, the flow regime, and the critical depth y_c = (q²/g)^(1/3) for the unit discharge q = v·y — the boundary between tranquil and shooting flow used in spillway and weir design. The hull-speed endpoint computes the displacement hull speed of a boat from its waterline length, v = 1.34·√(L_wl in ft) knots, the wave-making speed limit where the bow and stern waves equal the hull length, returned in knots, m/s and km/h with the corresponding Froude number — a 10 m waterline gives about 7.7 knots. Gravity defaults to 9.80665 m/s². Everything is computed locally and deterministically, so it is instant and private. Ideal for naval-architecture, marine, hydraulics, civil-engineering, river-modelling and fluid-mechanics-education app developers, spillway, weir and hull-design tools, and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This is the Froude number and flow regime; for Manning open-channel discharge use a Manning API.

Uptime

100.0%

Latency

86ms

Subs

4,153

Fluid-viscosity physics as an API, computed locally and deterministically. The sutherland endpoint gives the dynamic viscosity of a gas at any temperature from Sutherland’s law, μ(T) = μ_ref·(T/T_ref)^1.5·(T_ref+S)/(T+S), with built-in constants for air, nitrogen, oxygen, carbon dioxide, hydrogen, helium and argon (or your own μ_ref, T_ref and S) — air comes out at about 1.72×10⁻⁵ Pa·s at 0 °C, 1.84×10⁻⁵ at 25 °C and 2.17×10⁻⁵ at 100 °C, returned in Pa·s, micro-Pa·s and centipoise. The kinematic endpoint converts between dynamic viscosity μ and kinematic viscosity ν through the density, ν = μ/ρ and μ = ν·ρ, so water at 1.002 cP and 998 kg/m³ becomes about 1.004 cSt. The convert endpoint handles viscosity units both ways — dynamic between Pa·s, centipoise and poise (1 Pa·s = 1000 cP = 10 P) and kinematic between m²/s, centistokes and stokes (1 m²/s = 10⁶ cSt = 10⁴ St). Temperatures are in °C or kelvin. Everything is computed locally and deterministically, so it is instant and private. Ideal for fluid-mechanics, CFD, process-engineering, lubrication, HVAC and chemical-engineering app developers, viscosity-correlation and unit-conversion tools, and simulation software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This computes viscosity; for the Reynolds number that uses it use a Reynolds API.

Uptime

100.0%

Latency

78ms

Subs

4,120

Resistive voltage-divider circuit design as an API, computed locally and deterministically. The divide endpoint takes an input voltage and two resistors and returns the output voltage Vout = Vin·R2/(R1+R2), the current I = Vin/(R1+R2) that flows through the chain, and the power dissipated in each resistor and in total — a 12 V source with R1 = 1 kΩ and R2 = 2 kΩ gives 8 V at 4 mA. The loaded endpoint adds a load resistor across R2, computes the parallel combination R2′ = R2·RL/(R2+RL) and the loaded output Vout = Vin·R2′/(R1+R2′), and reports the droop in volts and percent against the unloaded value, the classic mistake when a divider feeds a real load. The resistor endpoint sizes the missing resistor for a target output — R2 = R1·Vout/(Vin−Vout) or R1 = R2·(Vin−Vout)/Vout — so you can pick parts for a reference or sensor-bias point. All quantities are volts, ohms, amps and watts. Everything is computed locally and deterministically, so it is instant and private. Ideal for electronics, embedded, hardware, sensor-interfacing and EE-education app developers, reference-voltage and bias-network tools, and maker software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is the resistive divider; for a single Ohm’s-law relationship use an Ohm’s-law API and for RC/RL filters an RC-filter API.

Uptime

100.0%

Latency

76ms

Subs

4,087

Mach-number and compressible-flow aerodynamics as an API, computed locally and deterministically. The mach endpoint computes the local speed of sound a = √(γ·R·T) (air γ = 1.4, R = 287.05 J/(kg·K)) and the Mach number M = v/a from a speed and a static temperature — given directly in °C or kelvin, or derived from a geopotential altitude through the International Standard Atmosphere (troposphere T = 288.15 − 0.0065·h up to 11 km, then the isothermal 216.65 K layer to 20 km) — and classifies the flight regime as subsonic, transonic, supersonic or hypersonic; the speed of sound is about 340.3 m/s at 15 °C and 295 m/s at 11 km. The speed endpoint inverts it, returning v = M·a in m/s, km/h and knots. The stagnation endpoint gives the isentropic total-to-static ratios T0/T = 1 + (γ−1)/2·M², P0/P = (T0/T)^(γ/(γ−1)) and ρ0/ρ = (T0/T)^(1/(γ−1)) — at Mach 2 the total pressure is about 7.82 times the static pressure — and will scale a supplied static temperature and pressure to their stagnation values. Everything is computed locally and deterministically, so it is instant and private. Ideal for aerospace, CFD, flight-simulation, wind-tunnel, UAV and aerodynamics-education app developers, compressible-flow and flight-envelope tools, and engineering software. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is compressible aerodynamics; for viscous flow and the Reynolds number use a Reynolds API and for incompressible pressure/velocity a Bernoulli API.

Uptime

100.0%

Latency

79ms

Subs

4,452