NaNDL Precision Calculator

Read off the precision needed to average a target-time completion — from a frame-window histogram, or from an exact list of timed inputs.

Setup

Frame rate (fps)

1 frame = 1/fps seconds

Level length (seconds)

total level time; also used for % positions

Target time (hours)

precision is solved for this expected time

Input mode

Total inputs: 0 · evenly spread across the level

Add each input with its position and window. Ordering & gaps come straight from your list.

Time in

Time (s)	Window (frames)	ms

Total inputs: 0

Run / segment — score just a slice of the level as its own run

Calculate a run only inputs between from and to are scored, re-based to start at 0 — like 23.2 - 81.8

Range (s)

Off — the whole level is scored.

Modifiers — off by default; constants are placeholders (the site does not publish them)

Nerveλ = e^(−k·t): later inputs (in seconds) are shakier

k_t (per sec)

FatigueBROKEN?λ = e^(−k·i): later inputs (by index) degrade

k_u (per input)

CPSBROKEN?λ = (4 / max(1, 2c))^k: fast clicking hurts precision

k_c (exponent)

Required Precision L*

—

Enter a level length and at least one input.

Per-input breakdown

Each input at L*: its pass probability p, the chance of reaching it alive reach, and — since a run is scored on its own — times shown in both seconds and % of the scored length. The weakest inputs (lowest p) are where the level fights back.

#	Time (s)	Time (%)	Window	ms	p (pass)	reach

How it works & assumptions

Each input i has a window of Nₕ frames, so its duration is wₕ = Nₕ / fps seconds. A player with precision L (bigger = sharper; L = 1/σ of their timing error in seconds) clears that input if their timing lands inside the half-window, giving pₕ = erf( (½·wₕ·L) / √2 ).

Level metrics

Completion probability P(C) = ∏ pₕ. Reach probability rₕ = ∏₃₂ₓₖ p₋. Expected time per attempt E[T₉] = tₙ·P(C) + ∑ tₕ·rₕ·qₕ (qₕ=1−pₕ, tₙ = level length), and expected time to complete E[T╕] = E[T₉] / P(C). The tool bisects on L for L*, where E[T╕] equals your target time. It also shows σ = 1/L* in milliseconds.

Two input modes

Histogram — you give counts per frame-window size; the tool assumes inputs are evenly spaced across the level and evenly interleaved by difficulty (no clustering). With modifiers off, the result depends only on the histogram, level length and target.

Manual list — you give each input's exact time and window, so ordering, gaps and per-input positions are taken directly from your data (nothing is scattered evenly). The Seconds / % switch reads times either as seconds or as a percentage of the level length, where % grows evenly across the level (50% = halfway in time).

Run / segment

Turn on Calculate a run and give a range like 23.2 - 81.8 to score only the inputs inside it. The slice is treated as its own level: its inputs are re-based so the run starts at 0 and its length becomes to − from. The range is read in whatever the Seconds / % switch is set to.

Modifiers

Each enabled modifier multiplies an input's effective window before the probability is taken: Nerve e^(−k·tₕ), Fatigue e^(−k·i), CPS (4/max(1,2c))^k where c is the local clicks/sec from the gap to the previous input. Fatigue and CPS are marked BROKEN? and all three are off by default; the constants are tunable placeholders because the NaNDL site does not publish its calibrated values.

Import format

A plain .txt file, one input per line, written as time - window:

1.5 - 3
2.1 - 5
2.9 - 15
5.1 - 8
5.5 - 8
8.1 - 11
10 - 4

time is the input's position and window is its size in frames. Separate them with a dash, a tab, or spaces — 1.5 - 3, 1.5-3, and tab/space-separated pairs pasted from a spreadsheet (e.g. 0.55 3) all work.

Time is read in whatever the Seconds / % switch is set to at import — so the same file loads as absolute seconds in Seconds mode, or as percentages of the level length in % mode. Export .txt writes the current list back out in this same format.

Blank lines and anything that isn't a number - number pair are skipped. Importing replaces the current list.