Calculator Methodology: How ArcheryEra Calculates It

1 Quick Summary

The visualizer treats an arrow as a point mass under gravity and an exponential drag term set by fletching and head type. Time-of-flight comes out of that drag model in closed form, drop follows from time-of-flight, and wind drift is scaled by how long drag has made the arrow linger in the air — not by the full flight time.

2 Inputs & Parameters

3 Constants & Static Values

4 Formulas & Mathematical Equations

5 Code Snippet (Logic Core)

// trajectory-core.js — verbatim from the live tool
var G = 9.81; // m/s²
var EFF_MASS = 30; // grains — same sitewide virtual-mass constant as the Arrow Speed Calculator

function speedFps(s) {
  if (s.bow === 'compound') {
    var vBase = s.ibo + 2*(s.dw-70) + 10*(s.dl-30);
    var baseline = 5*s.dw;
    var sw = s.sw || 0;
    return Math.max(100, vBase*Math.sqrt((baseline+EFF_MASS)/(s.aw+sw+EFF_MASS)));
  }
  return Math.sqrt(0.5*s.dw*(s.dl-1.75)/12*0.72*450240/s.aw);
}
function tof(d, v0, k)  { return (Math.exp(k*d) - 1) / (k*v0); }
function drop(d, v0, k) { var t = tof(d, v0, k); return 0.5*G*t*t; }
function ke(grains, fps)  { return grains*fps*fps/450240; }
function mom(grains, fps) { return grains*fps/225218; }
function impactFps(fps, k, d) { return fps*Math.exp(-k*d); }

6 Assumptions & Edge Cases

• Drag is modeled as a constant fraction of velocity lost per metre (the k value), not a full aerodynamic drag-coefficient simulation — it is calibrated to match observed field-point and broadhead behavior, not derived from a wind-tunnel model.
• The compound speed formula adjusts off an ATA-condition (70 lb / 30 in / 350 gr) rated speed linearly for draw length and draw weight, then applies the same virtual-mass ratio as the Arrow Speed & Performance Calculator for arrow weight (fixed 2026-09-14 to replace an older flat per-grain penalty that understated speed at heavy arrow weights) — see that tool's methodology below for why ATA and IBO numbers are not interchangeable inputs. This tool does not collect a string-weight input, so its estimate runs a few fps optimistic next to a build that adds real accessory mass.
• Wind drift only accrues during the time drag has already cost the arrow — a zero-drag arrow in this model would not drift at all, which matches the actual physics of a crosswind acting on lag time, not on distance traveled.

7 Out of Scope / Limitations

• No air density, altitude or temperature correction — the drag constants are calibrated at sea-level standard conditions.
• No spin-drift or gyroscopic precession modeling (negligible at archery velocities and distances, unlike rifle ballistics).
• Crosswind is treated as a steady, uniform value for the whole flight — gusting and shear are not modeled.

8 Worked Step-by-Step Example

9 Validation & Testing

The 37.2 in drop this example produces at 40 yards matches the figure the tool's own guide section cites for a 294 fps compound setup, and the drag constants are chosen so a hunting-vane, fixed-blade setup and a target-vane, field-point setup on the same bow diverge in the direction and rough magnitude bowhunters report when they chronograph both configurations. This is a physics-plus-calibration model, not a wind-tunnel measurement — treat the drift and drop numbers as planning figures to sight in against, not a replacement for your own sight tape.

10 Scientific References & Citations

Standard gravity (9.81 m/s²) per NIST's reference value. Rated-speed baseline per the Archery Trade Association's ATA speed standard (70 lb / 30 in / 350 gr), the modern successor to the AMO standard.

1 Quick Summary

A finished arrow is six lumps of mass on a rigid stick — nock, wrap, vanes, shaft, insert and point. Where it balances is the weight-averaged position of those six lumps, and FOC is just that balance point expressed as a percentage of arrow length ahead of center. All the modeling effort goes into getting each part's position right, not into the arithmetic itself.

2 Inputs & Parameters

3 Constants & Static Values

4 Formulas & Mathematical Equations

5 Code Snippet (Logic Core)

// foc-core.js — verbatim from the live tool
var parts = [
  { w: nock,               x: NOCK_X[nockType] },
  { w: wrapLen * wrapGpi,  x: wrapLen / 2 },
  { w: vanes * vaneWt,     x: vaneMargin + vaneLen / 2 },
  { w: len * gpi,          x: len / 2 },
  { w: insert,             x: len - insertLen / 2 },
  { w: point,              x: len + pointLen * POINT_COM[pointType] }
];
var total = 0, moment = 0;
for (var i = 0; i < parts.length; i++) {
  total  += parts[i].w;
  moment += parts[i].w * parts[i].x;
}
var bal = moment / total;
var foc = 100 * (bal - len / 2) / len;

6 Assumptions & Edge Cases

• Every part is treated as a point mass at a single x-position — a reasonable simplification for a nock, insert or point, but the shaft and vanes are distributed mass modeled at their geometric midpoint, which is exact only for uniform-density components (true for a constant-taper carbon shaft; not exactly true for a shaft with internal reinforcement).
• A point's own center of mass (0.42 for field points, 0.50 for broadheads) is a modeling choice, not a measurement of your specific point — the code's own comment notes that getting it wrong by 0.1 moves FOC by roughly a twentieth of a percent, which is why the tool does not expose it as an input.
• FOC is reported two ways: to AMO length (nock throat to end of shaft, excluding the point) and to overall length (point tip included) — the second always reads lower and is the number most often misquoted on forums.
• Site-wide audit, September 2026: this engine (AEFOC.build()) is now the single source for FOC across the site. The Dynamic Spine & Shaft Flex Calculator and the Arrow Build & GPI Weight Calculator, which used to each run their own separate simplified FOC approximation, both call it directly now (splitting their one combined rear-weight input into a nock/vane share via AEFOC.splitRearMass()) — see those tools’ sections for the fix.

7 Out of Scope / Limitations

• Does not model a bent or damaged shaft's actual mass distribution — assumes a straight, intact arrow.
• The 8% / 12% / 19% FOC grading bands are field-practice conventions, not physics constants — the tool says so directly rather than presenting them as a law.

8 Worked Step-by-Step Example

9 Validation & Testing

The balance-point arithmetic is exact — a physical weighted average has no calibration error, only measurement error in the inputs you provide. The FOC grading bands (low / target / hunting sweet spot / extreme) are convention, cross-checked against where target and hunting arrow manufacturers' factory-built arrows actually land, not derived from a single physics law.

10 Scientific References & Citations

FOC% = 100 × (balance point − L/2) / L is the standard formula published by the Easton Technical Products arrow-tuning literature and used industry-wide under the AMO (now ATA) measurement convention.

1 Quick Summary

Kinetic energy and momentum are exact physics — no fitting, no calibration, just unit-converted textbook formulas. Penetration depth and pass-through likelihood are a different animal: a calibrated ranking model built on broadhead type, FOC and game-animal vitals/body depth, tuned to track what bowhunters consistently report rather than derived from a single closed-form equation.

2 Inputs & Parameters

3 Constants & Static Values

4 Formulas & Mathematical Equations

5 Code Snippet (Logic Core)

// trajectory-core.js (exact) + ballistics-core.js (calibrated)
function ke(grains, fps)  { return grains*fps*fps/450240; }
function mom(grains, fps) { return grains*fps/225218; }
// ballistics-core.js — reuses trajectory-core.js's EFF_MASS=30 constant
function speedForWeight(v0, w0, w) {
  return v0 * Math.sqrt((w0 + T.EFF_MASS) / (w + T.EFF_MASS));
}

function focFactor(foc) {
  return Math.max(0.90, Math.min(1.20, 1 + (foc - 12) * 0.012));
}
function effective(grains, fps, head, foc) {
  return mom(grains, fps) * HEAD[head].pen * focFactor(foc);
}
function depth(eff, game) { return eff * game.k; }
function verdict(eff, game) {
  var d = depth(eff, game);
  if (d >= game.body)  return { label: 'Pass-through' };
  if (d >= game.vital) return { label: 'Sufficient' };
  return                      { label: 'Insufficient' };
}

6 Assumptions & Edge Cases

• Kinetic energy and momentum never change no matter what game or broadhead is selected — they are properties of the arrow alone. Only the penetration-depth estimate downstream depends on head type, FOC and target species.
• Fixed September 2026: the "what if I used a heavier/lighter arrow" comparison used to rescale speed with a flat "1 fps per 3 grains" shop rule of thumb, independently of — and inconsistent with — the virtual-mass model already validated and shipped for the Speed Calculator and Trajectory Visualizer (see the Dynamic Spine & Shaft Flex Calculator / Arrow Speed & Performance Calculator sections above). It was off by roughly 18 fps at a 400→600 gr comparison. Now reuses the same EFF_MASS=30 constant so a weight comparison explored here can't disagree with the same comparison run on those other tools.
• The FOC penetration factor is deliberately held to a modest ±20% range — the code's own comment notes the gains from FOC are real but their exact size is genuinely disputed among bowhunters, so the model does not overstate them.
• Broadhead penetration multipliers rank heads relative to each other (2-blade cut-on-contact highest, wide mechanical lowest) based on how bowhunters consistently report them performing, not from ballistic-gel testing done in-house.
• Site-wide audit, September 2026: this page's drag-coefficient table for fletching (FLETCH) used to be its own separate copy of the identical numbers already defined in trajectory-core.js. The values had not drifted, but nothing prevented them from doing so. It now reads FLETCH directly from trajectory-core.js instead of keeping a second copy — the broadhead penetration table (HEAD) stays local on purpose, since it carries penetration multipliers the trajectory model has no use for and is not a duplicate of anything.

7 Out of Scope / Limitations

• No bone-strike modeling — a hit on a scapula or major joint behaves nothing like the soft-tissue assumption behind the depth constants.
• Game vitals/body depth are broadside, average-mature-animal figures — a quartering angle or an immature animal changes the real distance the arrow has to travel.
• This is explicitly a ranking tool for comparing setups, not a promise of what will happen on a specific shot.

8 Worked Step-by-Step Example

9 Validation & Testing

The energy and momentum figures are unit-conversion arithmetic and cannot be "wrong" given correct inputs. The penetration-depth ranking is checked qualitatively against bowhunting-forum penetration reports across broadhead types and FOC ranges rather than against a single controlled experiment — it is presented on the tool page as a ranking signal, and this page repeats that framing rather than overstating precision the model does not have.

10 Scientific References & Citations

Kinetic energy and momentum constants derived from standard Newtonian mechanics (\(KE=\tfrac12 mv^2\), \(p=mv\)) using NIST's standard gravity value and the 7,000 grains-per-pound conversion. Minimum kinetic-energy guidance for game classes follows the bands published in Easton's bowhunting technical literature.

1 Quick Summary

Dynamic spine match is scored on a −100 to +100 Spine Match Index (SMI): the tool computes a "stiffness requirement" from peak bow weight, cam aggressiveness, front-of-arrow weight and cut length, compares it against a shaft's rated capacity, and scales the gap into a single index number.

2 Inputs, Constants & Formula

var front = AESpine.frontWeight(point, insert);          // point + insert (+ collar)
var requirement = 0.85 * weight * cam + ((front - 100) / 10) * 1.2
                - (29 - cutlen) * 5 + 4.4;               // AESpine.compoundRequirement()
var capacity = SPINE_CAPACITY[spine];
var smi = clamp(-(requirement - capacity) * 3.5, -100, 100);
var weak = (requirement - capacity) > 0; // positive gap = shaft too weak

3 Assumptions & Limitations

• SMI is a relative index, not a physical deflection unit — it is scaled so 0 sits at "requirement equals capacity" and ±100 are saturation bounds, not real Astatic-spine deflection.
• Draw length is not part of the stiffness arithmetic — only cut length is. Draw length is used separately as a clearance safety check against overdraw, not as a spine-matching input, because two archers with different draw lengths shooting the same cut-length arrow off the same cam load the shaft the same way at release.
• The capacity table runs from .200 to .600. The .600 anchor (27 lb-eq) was added on 29 September 2026 from the mean Requirement of every cell Easton’s 2020 chart puts in its 600 group; before that every shaft weaker than .500 was graded as a .500. Past .600 the last slope is extended, so treat anything weaker than about .700 as directional only.
• Recalibration, 29 September 2026: the draw factor, cam steps, both rates and the offset were refitted by least squares against two published compound charts at once — Easton’s 2020 Hunting Shaft Selector (FMJ & carbon, 42–84 lb) and Gold Tip’s IBO 315 split charts — across about 4,900 bow/arrow combinations, with the capacity table left untouched. Both charts put the length rate at 4.6–4.7 lb per inch; the point rate lands between Easton (1.04) and Gold Tip (1.96) at 1.19, rounded to Easton’s 1.2. Fed the shaft either chart recommends, the gauge now reads Optimal in 66–72% of cases and Dangerous in 0–4%. The previous constants (cam 1.00/1.15/1.25, 3.5 lb per 10 gr, 12 lb per inch) scored 14–22% Optimal and 25–49% Dangerous, drifting weak on long arrows and stiff on short ones. The same rates now match the recurve engine’s own point (3 lb per 25 gr) and length (5 lb per inch) terms.
• Front weight counts the point, insert and any collar — Gold Tip’s definition. Every compound tool on the site adds it up through AESpine.frontWeight(); tools that only ask for the point add a standard 16 gr insert.
• Site-wide audit, September 2026: FOC used to come from this page’s own simplified three-mass formula, which placed the whole rear-end weight (nock + fletching + wrap) at a flat 0.5in from the nock throat — not where fletching actually sits. FOC is now computed by AEFOC.build(), the same engine behind the Arrow FOC & Balance Point Optimizer, with the single rear-weight slider split into a nock share and a vane share using that engine’s own default proportions. The worked example below moved from 9.3% to 10.4% as a result.

4 Worked Example & References

Static/dynamic spine terminology follows the industry convention documented in Easton's arrow spine selection charts.

1 Quick Summary

Since 29 September 2026 both modes call shared engines. Compound mode runs the same chart-calibrated Requirement/Capacity engine as the Dynamic Spine & Shaft Flex Calculator; this page has no cam picker, so the IBO rating chooses the cam class using Easton’s own speed bands. Recurve/traditional mode runs the same engine as the Recurve Arrow Spine Calculator, recalibrated against Easton’s 2023 charts on October 19, 2026: 100 gr point reference, the hunting chart for Barebow and Traditional, the target chart for Olympic / Target. Speed comes from the site-wide virtual-mass model, the same one the Arrow Speed & Performance Calculator uses.

2 Formula & Code

var t, smi = null;
if (recurve) {
  // Traditional / Instinctive style = off-the-shelf ('trad') limbs.
  var eff = AESpine.recurveEffectiveWeight(dw, dl, style === 'traditional' ? 'trad' : 'modern', point, al).eff;
  // 'target' style reads Easton's 2023 target chart, the others the 2023 hunting chart
  t = AESpine.recurveSpineForStyle(eff, style).spine;
} else {
  var req = AESpine.compoundRequirement(dw, AESpine.CAM[AESpine.camForIbo(ibo)],
                                        AESpine.frontWeight(point, ins), al);
  t = AESpine.spineForCapacity(req);
  smi = AESpine.spineMatchIndex(req, AESpine.capacityForSpine(shaft));
}
var target = snap(t); // nearest stocked spine: 1200…150
// verdict: compound = same ±15 SMI band as the Dynamic Spine tool;
//          recurve  = ±40 spine points around the recurve target
var speed = AETV.speedFps({ bow: 'compound', ibo: ibo, dw: dw, dl: dl, aw: total });

3 Assumptions, Worked Example & References

What changed on 29 September 2026: compound mode used to run its own linear formula (320 − 7 per lb + 40 per inch of arrow under 28″, with only 35% of the insert counted). Checked against Easton’s 2020 hunting chart, it ran about 28 spine points too stiff on average at 340 and stiffer, and it disagreed with the Dynamic Spine tool for the same arrow. It now reads the shared engine, counts the whole insert, and grades the shaft on the same Spine Match Index band. Speed used the retired flat “1 fps per 3 grains” rule with an extra −8 fps; it now uses the shared virtual-mass model. The Whitetail, Elk and 3D presets were re-cut to builds the charts agree with, and the Trad preset now uses Traditional style and a 400 spine.

This tool’s recurve/traditional mode also offers the Shooting Style selector (Olympic/Target, Barebow/Stringwalking, Traditional/Instinctive) documented under the Recurve Arrow Spine Calculator above. Since October 19, 2026 it picks the table too: Olympic/Target reads Easton’s 2023 target chart, the other two the hunting chart. Traditional/Instinctive also switches the limb term to off-the-shelf, as the Recurve calculator’s limb picker does. On the Trad preset the modeled recurve target moved from 381 to 371.

Site-wide audit, September 2026: FOC is computed by AEFOC.build(), the same engine behind the Arrow FOC & Balance Point Optimizer, with the “tail” total split into a nock share and a vane share using that engine’s own default proportions (see AEFOC.splitRearMass()).

Compound constants fitted against Easton’s 2020 Hunting Shaft Selector and Gold Tip’s compound charts — see the Dynamic Spine methodology.

1 Quick Summary

A broadhead sitting at an angle to the airflow behaves like a small wing, pushing the arrow sideways for as long as launch yaw persists. This tool models that with flat-plate aerodynamics: side force from head/fletching area and dynamic pressure, a restoring moment from the fletching, and a yaw that decays as the fletching wins the argument.

2 Constants & Core Formulas

function margin(af, ah, a) { return (af*a.f) / (ah*a.h); }
function yaw(tear, len) { return Math.atan(Math.max(0, tear)/len); }
function deviation(ah, m, alpha, grains, fps, yards) {
  var q = 0.5*RHO*fps*fps, mass = grains/225218;
  var a0 = q*(ah/144)*CN*Math.sin(alpha)/mass;
  var lr = recovery(m, fps)*3, x = yards*3;
  return (a0*lr/(fps*fps)) * (x - lr*(1-Math.exp(-x/lr))) * 12; // inches
}

3 Assumptions, Worked Example & References

Ordinary flat-plate aerodynamics predicts side force well at the small angles a paper-tune yaw produces, but the recovery-distance formula (how fast the fletching wins) is calibrated, not derived — the tool's own source comment is explicit that "the shape is right… the constant is set so the outputs land on what bowhunters report." Head-area multipliers assume broadside averaging over arrow roll and do not model a specific roll phase at any single instant.

Flat-plate normal-force modeling follows standard low-speed aerodynamics (see any introductory aerodynamics reference on flat-plate lift/drag at small angles of attack).

1 Quick Summary

This is a rule-based scoring engine, not a physics model — the same distinction the tool's own "Under the hood" panel makes up front. Eight candidate causes each collect points from the answers that are real diagnostic evidence for them, direct observations (a marked arrow, a wobble on the spinner) outweigh the tear-direction inference, and a rest-move retest carries the heaviest single weight of all, because it's a result you produced, not a shape you're reading into a hole in paper.

2 Constants & Core Logic

// abridged — see papertune-core.js for the full 8-cause scoring function
if (horiz) {
  c.centershot += 30 * sizeMult;
  if (s.bow === 'compound') c.camlean += 15 * sizeMult;
}
if (s.dir !== 'clean' && s.afterMoves === 'closed') {
  var primary = horiz ? 'centershot' : (vert ? 'nockheight' : null);
  if (primary) c[primary] += 45;      // the retest result outweighs the initial tear reading
  c.spine = Math.max(0, c.spine - 20); // a tear that closes on a rest move argues against spine
}

3 Assumptions, Worked Example & References

The weights are a diagnostic ranking, not a probability — they encode how tuning technicians actually triage a tear (test before you adjust, adjust before you assume spine is wrong), which is why a clean rest-move retest can outweigh the entire initial tear reading. The engine deliberately never lets a low-confidence tear-direction guess outrank a result the archer actually produced by moving something and re-shooting.

Rest-position vs. cam-lean disambiguation follows the same rest-travel test discussed at length on Rokslide and covered in Bow International's technical breakdown of cam lean. Nock-pinch-mimicking-nocking-point-error pattern documented in a long ArcheryTalk thread on a stubborn nock-low tear.

The session log’s projection is the one piece with no published source behind it. After two or more rounds of the same adjustment with a shrinking tear, it computes closure per step = (starting size − latest size) ÷ steps logged and remaining steps = latest size ÷ that rate, rounded up. It is a straight line through the archer’s own numbers and is labeled that way on the tool.

4 Paper Distance Planner (arrow flex)

Source: arrowflex-core.js. The arrow in flight is a free-free Euler–Bernoulli beam with the point/insert as an end mass at the front and nock + fletching as an end mass at the rear, the model family Kooi and Sparenberg used for the archer’s paradox. Stiffness comes from the spine number: EI = F · S³ ÷ (48 · spine), with F = 880 g × g and S = 28 in. Mass per length comes from GPI. The first bending frequency f is the first root of the 3×3 characteristic determinant; one flex cycle covers v ÷ f, and two papers are compared by the fractional part of their separation ÷ (v ÷ f): under 0.15 or over 0.85 = same flex, 0.35–0.65 = opposite, otherwise shifted.

Second-paper suggestion: candidates are A + k·(v ÷ f) for whole k ≥ 1; the one inside 10–15 ft closest to 12 ft is shown, rounded to the nearest 3 in (a phase error under 0.05 cycle for any flex cycle over 2.5 ft). If none fits, the nearest whole-cycle distance up to 18 ft is shown and labeled as outside the band. The 10–15 ft band comes from the 2026 torqued-arrow test cited below; at that distance the flex matches paper A; the whole-arrow yaw does not.

Independent checks: James Park’s account of arrow dynamics gives 80–90 Hz for a target arrow’s first bending mode, with nodes about 50 mm from the point and 150 mm from the nock; the engine gives 77–82 Hz and nodes at 52–64 mm / 144–153 mm for X10-type target builds. A 2026 slow-motion test of torqued arrows put the whole-arrow yaw peak at 10.0–14.5 ft (11 builds, one bow, no angles reported), consistent with yaw being far slower than bending.

Not modeled: launch amplitude and phase (unknown, so results are relative to paper A), in-flight damping, higher bending modes, shaft taper. Whole-arrow yaw is left out of the chart because measured free-flight yaw on target arrows ran at 4–5.3 Hz, one swing every 35–46 ft.

1 Quick Summary

Gravity only pulls an arrow down, never along the shot's slant line, so an elevated or declined shot needs a shorter aim-point than the slant-range reading. This tool solves for the level ("true") distance whose flat-ground trajectory would produce the same drop as the actual angled shot, using the same exponential-drag model as the Trajectory Visualizer.

2 Formula & Code

function alphaReq(R, th, v, k) {
  var sp = pathLen(R, th, v, k), t = tof(sp, v, k);
  return 0.5*G*Math.cos(th)*t*t/sp;
}
function trueRange(R, th, v, k) { // bisection: alphaLevel(d) rises monotonically
  var want = alphaReq(R, th, v, k), lo = 0.4, hi = 250, mid;
  for (var i = 0; i < 60; i++) {
    mid = (lo+hi)/2;
    if (alphaLevel(mid, v, k) < want) lo = mid; else hi = mid;
  }
  return (lo+hi)/2;
}

3 Assumptions, Worked Example & References

This solves the actual trajectory equation for the equivalent level shot rather than using the popular cosine rule-of-thumb (level distance ≈ slant × cosθ) — the two agree closely at moderate angles and archery ranges, which the worked example below confirms, but the physics-based solve stays accurate at steeper angles where the cosine approximation drifts.

Angle-compensation principle documented in standard bowhunting ballistics references and rangefinder manufacturer manuals (e.g. Leupold, Vortex angle-compensating rangefinder documentation).

1 Quick Summary

The tool runs one race. The arrow flies with exponential drag; the sound of the shot travels at the local speed of sound; the animal needs a reaction time after it hears the shot. If the arrow lands after sound travel plus reaction, the animal has time to move, and the result reads MISSED / JUMPED. If the arrow lands first, it reads HIT / DEADLY.

2 Constants & Core Logic

Duck depth is min(cap, 44 in/s × max(0, ΔT)), with caps of 18 in for deer, 26 in for elk and 12 in for boar. The 44 in/s rate is a calibration to the widely quoted 2, 6 and 10+ inches of drop at 20, 30 and 40 yards; the model returns 2.1, 6.0 and 10.1 in at those distances. It is an approximation, not a physics constant.

function soundSpeed(tc){ return 331.3 * Math.sqrt(1 + tc / 273.15); }
function flightTime(dM, v0, k){ return (Math.exp(k * dM) - 1) / (k * v0); }
// distance where the arrow arrives `margin` seconds later than sound + reaction
function solveDistance(v0, k, c, reactS, margin){
  var lo = 0.05, hi = 600, f = function(d){ return flightTime(d, v0, k) - d / c - reactS - margin; };
  if (f(hi) < 0) return Infinity;
  for (var i = 0; i < 70; i++){ var m = (lo + hi) / 2; if (f(m) > 0) hi = m; else lo = m; }
  return (lo + hi) / 2;
}
var reqMs = (Math.exp(k * dM) - 1) / (k * tMove);   // speed that makes dT = 0 at this distance

3 Assumptions, Worked Example & References

Reaction times are scenario values, not a measured constant for every animal. A deer that never heard the shot, a bow that is louder or quieter than average, and wind carrying sound away all move the real number. The tool therefore flags any result within 40 ms of zero as a narrow margin, and lets you override the reaction time by hand from 30 to 250 ms.

Speed-of-sound relation from NASA Glenn's speed-of-sound reference; temperature lapse with altitude from NASA's metric Earth atmosphere model; duck-depth calibration from the Grant Woods string-jumping figures in Outdoor Life. Drag constants are shared with the trajectory visualizer above.

1 Quick Summary

Rated speed is adjusted for draw length and draw weight with the same flat per-unit coefficients used across the whole site, then scaled for real arrow-plus-string mass with a square-root mass-ratio term rather than the old "1 fps per 3 grains" flat penalty, which the tool's own source comment notes was off by 40+ fps at the heavy end.

2 Formula & Code

// estimate() now calls the site's one shared speed function directly —
// it used to run its own separate copy of this same formula.
var clamped = AETV.speedFps({ bow:'compound', ibo:st.ibo, dw:st.dw, dl:st.dl, aw:st.aw, sw:st.sw });
// (unclamped vBase*massRatio is still kept locally, only to flag the 100fps floor)

3 Assumptions, Worked Example & References

The rated-speed input is assumed to be an ATA-condition number (70 lb / 30 in / 350 gr) — an IBO number reads a few fps hot when run through this formula because IBO's own heavier draw-weight test condition already baked in extra speed the formula does not know to remove. The 30-grain "effective mass" constant represents string and cam-system inertia the bow always has to accelerate regardless of arrow weight, keeping the ratio from overstating speed gains at very light arrow weights.

Site-wide audit, September 2026: this page and the Trajectory & Sight-Pin Visualizer used to each carry their own separate copy of the same mass-ratio formula. They matched numerically, but two copies of one formula only stay identical until someone tunes one and forgets the other — the exact failure mode that split the Recurve Arrow Spine Calculator from the Arrow Build & GPI Weight Calculator earlier this month. This page's headline fps number now calls trajectory-core.js directly instead of hoping its own copy stays in sync. Verified against five preset builds spanning 280–620 grain arrows: identical output before and after, to floating-point precision.

IBO vs. ATA test conditions per the IBO's own published rules and the Archery Trade Association's ATA speed standard. Minimum 5 gr/lb safety floor is the manufacturer-published minimum used industry-wide to prevent dry-fire-equivalent limb shock.

1 Quick Summary

Wingspan divided by 2.5 is the primary read, height is a cross-check only and is never blended into the primary number, and a flat +0.5 in is added for recurve/traditional to account for a deeper anchor and more back tension.

2 Formula & Code

function estimate(span, height, bow) {
  var dlSpan = span/2.5;
  var dlHeight = (height-15)/2;
  var dl = dlSpan + (bow === 'recurve' ? 0.5 : 0);
  return { dl: dl, dlHeight: dlHeight, arrowLo: dl+1.0, arrowHi: dl+1.5 };
}

3 Assumptions, Worked Example & References

The wingspan/2.5 rule is the standard method published across the archery industry; height is included only to flag a likely bad wingspan measurement (the tool warns when the two disagree by 1 in or more) and never overrides the wingspan-based number. Arrow-cut length adds a flat 1.0–1.5 in for broadhead/riser clearance rather than modeling a specific rest and riser cutout.

Wingspan-to-draw-length method as published by Nock On Archery's draw-length fitting guide and used across archery pro-shop fitting practice.

1 Quick Summary

Total finished weight is shaft weight (direct entry, or length × GPI) plus point weight plus a fixed components preset lumping nock, vanes, wrap and insert together — a deliberately minimal three-number model for a tool built to answer one question fast.

2 Formula & Code

var COMP = { light: 20, standard: 35, heavy: 50 }; // grains
function shaftGrains(mode, length, gpi, shaft) {
  return (mode === 'lengthgpi') ? Math.round(length*gpi) : Math.round(shaft);
}
var total = shaftGrains(mode, length, gpi, shaft) + point + COMP[comp];

3 Assumptions, Worked Example & References

The Light/Standard/Heavy components preset (20/35/50 gr) lumps nock, vanes, wrap and insert into one number by design — the site's more detailed FOC & Balance Point Optimizer exists for anyone who needs each component weighed and positioned separately. This tool trades that precision for a three-input, under-a-minute answer.

Component weight ranges cross-checked against typical manufacturer-published nock, vane and insert weights (e.g. Easton's component catalog).

1 Quick Summary

Marked bow weight is adjusted for draw length, limb material, point weight and arrow length into one effective bow weight, then read against one of two recurve tables: Easton’s 2023 hunting chart for the Barebow and Traditional styles, Easton’s 2023 target chart for Olympic / Target. Neither is the compound-bow table the Carbon Arrow Spine Calculator uses, since the two diverge sharply at lower poundage.

Recalibrated against Easton’s 2023 charts on October 19, 2026. The spine bands and the point-weight reference (now 100 gr, as on Easton’s charts) follow the 2023 hunting chart; the Olympic / Target style reads the 2023 target chart, which runs weaker for the same bow. Before that date the engine measured point weight from 125 gr and used one table for every style.

2 Inputs, Constants & Formula

var drawAdj = 2 * (drawlen - 28);
var limbAdj = (limb === 'trad') ? -5 : 0;      // wood/fiberglass vs carbon/foam-core
var pointAdj = 3 * (point - 100) / 25;          // AESpine.recurvePointAdj(), 100 gr reference
var lenAdj = 5 * (arrowlen - 28);
var eff = weight + drawAdj + limbAdj + pointAdj + lenAdj;

// Barebow and Traditional styles: Easton 2023 hunting chart, 28 in, 100 gr.
// Row edges sit at the half pound (an effective weight rounds to the nearest whole lb).
var FAMILY = [
  { range: 'under 24', label: '600–700' },  { range: '24–32', label: '500–600' },
  { range: '33–46',    label: '400–500' },  { range: '47–61', label: '350–400' },
  { range: '62–78',    label: '300–350' },  { range: '79+',   label: '250–300' }
];
var band = AESpine.recurveFamilyFor(eff, style);   // style 'target' reads TARGET below

3 Assumptions & Limitations

• The point-weight rate is printed on both of Easton’s 2023 charts for recurves directly (100 gr = no adjustment, 3 lb per 25 gr either side). The −5 lb wood/glass limb rule comes from the 2023 target chart and is kept for both tables. The draw-length rate (2 lb/in) is a conservative, widely cited AMO convention — some limbs run closer to 2.5–3 lb/in, so a bow scale reading at your real draw is the way to confirm it exactly.
• The FAMILY table was first rebuilt in September 2026 off Easton’s 2020 hunting chart, but the point-weight term still measured from 125 gr while that chart is built on 100 gr points. On October 19, 2026 the bands were re-read off the 2023 hunting chart and the reference moved to 100 gr. An earlier version of this table briefly shared the Carbon Arrow Spine Calculator's compound-cam table, which reads far too soft at low poundage for recurve (a 22–26 lb recurve bow is roughly 600–700 spine on Easton's own chart, not 1000+) — the two tools now use separate, independently sourced tables.
• An effective weight goes to the nearest whole pound before a row is read (x.5 rounds up). The target chart’s “<20 lbs.” row is read as 20 lb and under.
• Under 24 lb (hunting table) and over 73 lb (target table) the charts print no row, so the tool shows the nearest band and an out-of-range warning.
• The 2023 hunting chart’s insert rule (+3 lb per 25 gr of insert over 25 gr) is not modeled, because the tool asks for point weight only.
• This is a starting-point selection model, not dynamic spine — it does not model how a specific cut shaft actually flexes in flight the way the Dynamic Spine & Shaft Flex Calculator does for compound bows.
• Single source of truth (added September 2026): the EffectiveWeight formula and FAMILY table now live in one shared file, /assets/js/ae-spine-core.js, loaded by this page, the Arrow Build & GPI Weight Calculator's recurve mode, and the Wood Arrow Spine Calculator. A previous version of the Arrow Build & GPI Weight Calculator used its own independent approximation (a flat "+120 spine units" offset for recurve/traditional) that disagreed with this table by a full spine size or more across most of the practical draw-weight range — flagged by a reader comparing the two tools directly. Both tools now call the same recurveEffectiveWeight()/recurveTargetSpine() functions, so they cannot drift apart again silently.
• Shooting style (added September 2026): this tool and the Arrow Build & GPI Weight Calculator now offer an optional Olympic/Target, Barebow/Stringwalking, or Traditional/Instinctive selector. Barebow/stringwalking archers commonly report needing a weaker spine than a generic finger-release chart suggests, and community tuning writers (including well-known barebow-specific voices) echo this — but no manufacturer or standards body publishes a validated numeric offset for it, and the primary community threads with real reported numbers sit behind logins we could not independently verify. Rather than invent a coefficient, selecting Barebow or Traditional shows a plain-language disclosure instead of silently shifting the effective-weight number. Confirm the real number with a bareshaft tune. Since October 19, 2026 the style also picks the table: Olympic / Target reads Easton’s 2023 target chart, the other two read the hunting chart. The effective weight is the same for all three.

4 Worked Example & References

The static-spine test hangs a center weight on a shaft supported about 28 in apart and reads the deflection, the same setup the ASTM F2031 spine standard describes. Point-weight rate, limb rule and the TARGET rows from the 2023 target selection chart; FAMILY bands and the 100 gr baseline from the 2023 hunting selection chart's traditional recurve rows.

1 Quick Summary

This tool runs the exact same Requirement/Capacity formula documented above for the Dynamic Spine & Shaft Flex Calculator — same cam multipliers, same front-weight and cut-length terms, same Capacity anchor table — just inverted: instead of grading one shaft's printed spine, it solves for the spine range whose Capacity falls inside the ±15 SMI Optimal Match band around your Requirement. A "starting range" here and an "Optimal Dynamic Match" reading there can never contradict each other for the same setup.

2 Inputs, Constants & Formula

var requirement = AESpine.compoundRequirement(weight, cam, front, arrowlen);
// = 0.85*weight*cam + ((front - 100) / 10) * 1.2 - (29 - arrowlen) * 5 + 4.4
var tol = 15 / 3.5;                     // Optimal-Match half-width, lbs-equivalent
var spineLo = spineForCapacity(requirement + tol);  // stiffer bound
var spineHi = spineForCapacity(requirement - tol);  // softer bound
// spineForCapacity() is the piecewise-linear inverse of the Dynamic Spine
// Calculator's own capacityForSpine() over the same CAP_ANCHORS table.

3 Assumptions & Limitations

• The Capacity table runs from .200 to .600, same as the Dynamic Spine Calculator — a build that calls for something stiffer or weaker falls outside the model and the page shows an out-of-range warning.
• Since the 29 September 2026 recalibration the point-weight rate is Easton's own (3 lb per 25 gr) and the cam steps reproduce Easton's additive 5 lb speed classes, so a result here sits within one shaft size of Easton's and Gold Tip's charts for most setups. Charts only come in whole sizes; this tool returns a continuous range.
• Recurve and wood/traditional bows have no cam, so this Requirement/Capacity model does not apply to them; the Recurve and Wood Arrow Spine Calculators above and below use their own, separately sourced tables instead.

4 Worked Example & References

Static-spine test per Easton's Making Sense of Arrow Spine. Easton's own chart and rates are published in its Arrow Shaft Selection (Hunting) chart. Full Requirement/Capacity derivation: Dynamic Spine & Shaft Flex Calculator methodology above.

1 Quick Summary

Marked bow weight is adjusted for draw length, bow style (center-shot recurve vs non-center-shot selfbow/longbow) and point weight into a floor value, then presented as an 8 lb-wide pound-rated shopping range — deliberately never converted into a carbon .300/.400-style spine number, since no solid cross-material conversion exists.

2 Inputs, Constants & Formula

// drawAdj/pointAdj/lenAdj call ae-spine-core.js. drawAdj and lenAdj are
// shared with the Recurve Arrow Spine Calculator; pointWeightAdj() keeps
// the 125 gr reference this tool's pound-rated ranges are anchored to.
var drawAdj = AESpine.drawLengthAdj(drawlen);
var styleAdj = (style === 'selfbow') ? -3 : 0;   // non-center-shot archer's-paradox adjustment, local to this tool
var pointAdj = AESpine.pointWeightAdj(point);
var lenAdj = AESpine.arrowLengthAdj(arrowlen);
var floor = weight + drawAdj + styleAdj + pointAdj + lenAdj;
var range = [Math.round(floor), Math.round(floor) + 8];

3 Assumptions & Limitations

• The 8 lb range width sits inside — but is not itself lifted from — 3Rivers Archery's documented guidance that experienced shooters run a shaft rated roughly 5–10 lb stiffer than actual draw weight; the range floor is your build-adjusted bow weight, not that guidance's own starting point.
• Wood is a natural material: grain, density and moisture content all shift a given shaft's real spine around its printed rating, which is exactly why wood shafts are sold pre-sorted into pound ranges rather than exact numbers in the first place. This tool never fabricates a carbon-equivalent number for that reason.
• No Simulation Lab tool currently models wood/traditional dynamic spine, so unlike the Carbon Arrow Spine Calculator, there is no sibling Requirement/Capacity formula for this tool to stay consistent with — its adjustment directions and magnitudes are cross-checked against 3Rivers Archery's and Easton's own recurve/traditional guidance instead.
• Site-wide audit, September 2026: the draw-length, point-weight and arrow-length adjustment terms used to be this page's own separate copy of the identical arithmetic already used by the Recurve Arrow Spine Calculator's effective-weight model. Both pages now call ae-spine-core.js for those three terms. Since October 19, 2026 the point term is split on purpose: the recurve engine measures from 100 gr, as on Easton’s 2023 charts, while this tool keeps its 125 gr reference, which its pound-rated ranges are anchored to. This tool’s output did not change. The selfbow/non-center-shot style adjustment stays local — it is not shared with any other tool's formula, so there was nothing to unify there.

4 Worked Example & References

Pound-rated wood spine convention and the 5–10 lb stiffer-than-draw-weight guidance for experienced shooters from 3Rivers Archery's published spine selection charts.

1 Quick Summary

This tool doesn't invent a new sizing system. It layers directly on the same three-class diameter taxonomy (Micro/4mm, Small/5mm, Standard/6.5mm) the Arrow Shaft Finder already uses, then maps each class to the nock letter code and bushing product name that physically fits its bore. Pick a catalogued shaft or type a measured inside diameter, and it returns the matching component names instead of a spine number.

2 Constants & Core Logic

function classifyId(inches) {
  var d = { micro: Math.abs(inches-0.1655), small: Math.abs(inches-0.204), standard: Math.abs(inches-0.245) };
  var best = 'micro', bestD = d.micro;
  ['small','standard'].forEach(function (k) { if (d[k] < bestD) { best = k; bestD = d[k]; } });
  var sorted = Object.keys(d).sort(function (a, b) { return d[a]-d[b]; });
  var ambiguous = (d[sorted[1]] - d[sorted[0]]) < 0.012; // within ~.012in of a tie
  return { key: best, ambiguous: ambiguous };
}

3 Assumptions, Worked Example & References

The 18-shaft catalog is the same list and the same dia-class bucket already assigned in the Arrow Shaft Finder — this tool deliberately does not maintain a second, independent dataset that could drift out of sync with it. Two shafts in that list (Easton FMJ 6mm and Easton 5mm FMJ Max) carry a hybrid:true flag: their aluminum-carbon "Full Metal Jacket" construction uses Easton's own HIT (Hidden Insert Technology) system and a Broadhead Alignment Ring rather than a generic bushing of their numeric class, and the tool surfaces that distinction instead of quietly recommending a part that won't seat correctly.

Bore-size-based component naming confirmed on Easton's own bushings product category page, which lists the G/X/S nock pairing directly in each bushing's product description, including the HIT and Broadhead Alignment Ring references for FMJ construction. Nock letter codes cross-checked against Feradyne's published Nockturnal nock-to-ID size chart.

1 Quick Summary

Spin is modeled in two parts. The full spin rate comes from a screw-thread baseline times a vane-engagement factor, so a 3° helical shield vane on a 0.34″ shaft settles at about 2,770 RPM at 280 fps, one turn every ~73 in. The spin-up describes how the vanes get there: the shaft leaves the string with almost no spin and approaches full rate over a distance constant of 3 yd. Twist direction never changes either number; it only flips the sign.

2 Constants & Core Logic

function revsAt(typeId, fps, yd, L) {        // AEFLETCH.revsAt()
  L = L || SPINUP_YD;                          // 3 yd
  var revPerYd = (rpm(typeId, fps) / 60) / (fps / 3);
  return revPerYd * (yd - L * (1 - Math.exp(-yd / L)));
}

twist-core.js adds the left-vs-right layer on top: the sign convention (clockwise from the nock = right), the braking-versus-bevel thread-torque ratios, and how fast vanes overwrite a bareshaft’s own spin (r₀ above). It reads L from fletching-core.js, so every page counts revolutions the same way.

3 Assumptions, Worked Example & References

The full-rate model is cross-checked against wind-tunnel and free-flight work that measured a spin parameter of 0.028–0.033 on spin-wing target arrows (aerodynamic properties of an archery arrow); the model gives 0.0315 for the same vane type. The spin-up distance is an engineering estimate with roughly a factor-of-two uncertainty, not a measurement, and one value is used for every vane family. Until October 2026 the site assumed full spin from the string, which overstated revolutions in the first 10 yards by about 40%.

1 Quick Summary

A movable sight housing sits at s(d) = a + b·tanψ(d), where ψ(d) is the angle between the arrow’s launch line and the line of sight that lands the arrow on the line of sight at distance d. ψ comes from a 2-D point-mass flight; a and b are fitted to the archer’s own measured marks by least squares. Two marks fit exactly. Three or more leave residuals and a leave-one-out check.

2 Inputs, Constants & Core Logic

This uses the same drag law as the rest of the site but integrates it in two dimensions. The older closed form in trajectory-core.js (drop = ½g·t² with drag-lengthened t) overstates drop by roughly 3–14% against the full flight with the same k in the cases tested, which is fine for a pin gap and too coarse for a millimeter tape.

3 Assumptions, Worked Example & Validation

• Level shots, still air, sea-level drag constants; the sight bar is treated as perpendicular to the arrow and the arrow’s launch point as directly below the eye.
• On a geared dial, b is sight radius times the gear ratio, so the sight-radius check is off.
• The sensitivity columns refit the tape with speed ±Δv and peep height ±Δh (user-set, defaults 10 fps and 0.25 in) and report the largest shift at each mark. They are sensitivities, not a confidence interval.

Validation: scripts/tests/sight-tape/run-tests.js compares the engine with an independently written RK4 reference (reference.py, 108 cases, worst 0.0025 mm at a 32 in radius), the hand-solved vacuum parabola, normal-equation least squares and the input checks. No field dataset of real bows and marks has been logged against it yet. Fit by ordinary least squares on a straight-line model.

1 Quick Summary

Launch speed comes from the shared bow model (AETV.speedFps) and drag from the shared fletching constants. The planner finds the launch angle that hits the aim point at the target distance, then flies a level miss (same angle, no target) and a miss that leaves high enough to clear the target top, until each comes back to the ground. A golden-section search finds the angle that throws the arrow farthest. Modeled: no wind, no skips, no deflection, so every distance is a minimum.

2 Inputs, Constants & Core Logic

3 Check

With drag set to ~0 the solver returns v₀²/g at 45° (736.5 m for 85 m/s, exact). Hunting compound preset (70 lb, 29 in, 440 gr, IBO 330, hunting vanes): 288 fps, level miss at 20 yd lands 40 yd behind the target, target-clearing miss (12 in) 55 yd behind with 52 ft·lb, farthest throw 333 yd at 38°; with k changed by ±20% the farthest throw is 302–373 yd.

1 Quick Summary

The reader brings the split they see between bare shafts and fletched arrows at 20 yards; the model shows how that split looks at other distances. Past a short settling distance the split grows in proportion to distance, the same shape the broadhead checker uses. A split counts as readable when the bare hole clears half the fletched group plus a floor of two shaft widths. The engine runs offline and writes static, modeled tables to the page; no page loads it live, and the assistant’s own decision table in bareshaft-core.js doesn’t use it.

2 Inputs, Constants & Formula

// abridged from bareshaft-distance-core.js
function shape(x, x0) { return x0 > 0 ? x - x0 * (1 - Math.exp(-x / x0)) : x; }
function splitAt(x, s20, x0) { return s20 * shape(x, x0) / shape(X20, x0); }
function groupAt(x, g20) { return g20 * x / X20; }          // groups are angular
function readable(x, s20, g20, x0, fl, nBare) {
  var n = nBare || 1;
  return splitAt(x, s20, x0) >= groupAt(x, g20) / 2 / Math.sqrt(n) + fl;
}

3 Assumptions & Limitations

• No measured bare-vs-fletched impact data by distance was found. The shape is checked against a published bare-vs-fletched model table (within about 10 mm rms out to 70 m), which is a model, not a measurement.
• Wind, form changes with distance, ground slope, flex damping and broadheads are not modeled. Groups are held to the same angle at every distance.
• At 10 yd the result depends on the settling distance more than at 20 yd and beyond. Cells marked * (split within 25% of the group’s half-angle) can swing by tens of yards with small input changes.
• The reading floor (two shaft widths), the “clears half the group” rule and the √3 for three bare shafts are definitional choices.
• Shaft length stands in for arrow length. Feathers get the vane coefficient, because no source gives one for feathers.
• The site’s fletched k (FLETCH in trajectory-core.js) appears in the height table only as an upper bound: it is calibrated, not sourced, and doesn’t depend on arrow mass.

4 Worked Example & References

Vane slope, bare and fletched drag: wind-tunnel and free-flight measurements of arrow aerodynamics. Turbulent shaft flow: air-flow study around the point of an arrow. Shaft diameters and weights: 6.5 mm hunting shaft spec table. Validation: scripts/tests/bareshaft-distance/run-tests.js and an independent Python reimplementation that recomputes every table row.