Free Online Stopwatch

Keyboard Shortcuts

• Space · Start / Stop the stopwatch
• L · Record a lap time
• R · Reset the stopwatch

Features

• Millisecond precision with smooth display updates
• Unlimited lap times with best/worst highlighting
• Copy all lap times to clipboard for easy sharing
• Keyboard shortcuts for hands-free operation
• Works offline · no internet needed after loading

How It Works

1. Start timing. Click Start (or press Space) to begin. The display updates 10 times per second using requestAnimationFrame for smooth, GPU-aligned rendering.
2. Record laps. Press Lap (or L) to record split times without stopping the main timer. Each lap shows both the lap interval (time since the previous lap) and the cumulative total.
3. Stop, reset, copy. Stop ends the run; Reset clears everything. Use Copy All to export the full lap list as plain text, paste into a spreadsheet, training log or sports report.

A Short History of the Stopwatch

The mechanical chronograph (the ancestor of every modern stopwatch) was invented by Louis Moinet in 1816. Moinet built his "Compteur de Tierces" to time the apparent motion of stars across the sky for astronomical observation; it could measure to 1/60th of a second, an extraordinary precision for the era. The first commercial chronograph followed five years later: Nicolas Mathieu Rieussec demonstrated his "ink-spotting" chronograph at the Paris Champ de Mars horse races on 1 September 1821, then patented it in 1822. Rieussec's design used a tiny ink reservoir at the tip of the timing hand; pressing the button at start dropped a spot of ink at the start position, pressing again at stop dropped a second spot, and the distance between spots gave the elapsed time. Adolphe Nicole patented the split-second (rattrapante) chronograph in 1844, allowing two split times to be measured simultaneously, a critical innovation for races where multiple competitors finished within seconds. Heuer's Mikrograph (1916) brought 1/100th of a second precision to mechanical chronographs in time for the 1920 Antwerp Olympics, where it was used as the official timekeeper. The quartz revolution arrived with Seiko's Astron in December 1969 (the first commercial quartz wristwatch); through the 1980s Casio's G-Shock (1983) and F-91W (1989) made quartz stopwatches cheap, durable and ubiquitous. Modern atomic clocks like NIST-F1 (1999) and NIST-F2 (2014) achieve precision of roughly one second in 300 million years, far beyond anything a wristwatch needs, but the standard against which all civilian time is calibrated.

JavaScript Timing, Date.now() vs performance.now() vs requestAnimationFrame

Browsers expose three different APIs for measuring time, each with different guarantees. Date.now() returns Unix milliseconds since 1 January 1970, millisecond resolution, but the system clock can jump (manual time changes, NTP corrections, daylight saving time crossings) which makes it unreliable for elapsed-time measurement. performance.now() returns the time since the page started, in milliseconds with sub-millisecond fractional precision; it's monotonic (never goes backward, immune to system clock changes), which is exactly what a stopwatch needs. After Spectre/Meltdown disclosures in early 2018, browsers reduced performance.now()'s default precision from sub-microsecond to 100 microseconds (some browsers up to 1 millisecond) to mitigate timing-side-channel attacks; cross-origin-isolated pages can still get 5-microsecond resolution if the site opts in via Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers. For a stopwatch, the post-Spectre default precision is more than enough, humans can't perceive timing differences finer than about 50ms in a UI context. requestAnimationFrame isn't a clock per se, it's a callback the browser fires once per display refresh (typically 60 times per second on a 60Hz monitor, 120 on a 120Hz). For a stopwatch UI, requestAnimationFrame is what drives the smooth display update; the elapsed time itself comes from performance.now(). The standard pattern: capture startTime = performance.now() on Start, then on each animation frame compute elapsed = performance.now() - startTime and re-render the display.

The Tab-Throttling Problem

A famous source of bugs in browser-based stopwatches is background tab throttling. When a tab loses focus (you switch to another tab or window), browsers reduce the rate at which setTimeout, setInterval and requestAnimationFrame callbacks fire, typically clamping to 1 second between calls regardless of the requested interval. Chrome 88 (January 2021) introduced an even more aggressive "intensive throttling" mode that reduces to 1-minute intervals after the tab has been backgrounded for 5+ minutes, to save battery on laptops. This breaks any stopwatch that increments a counter on each interval, the counter falls behind. The correct stopwatch implementation, used here, is to compute elapsed time as performance.now() - startTime on every render rather than incrementing a counter on every interval, the difference between two timestamps is always accurate regardless of how often the render fires. The display will look frozen on a backgrounded tab (because the render isn't firing), but when you return to the tab the elapsed time is correctly computed and the display jumps to the right value. For genuinely accurate background timing, the Web Worker pattern (running the timer in a worker thread, which is throttled less aggressively than the main thread) is the standard solution; this tool's stopwatch is foreground-focused so the basic performance.now() approach is sufficient.

Lap Time vs Split Time, The Distinction Olympic Officials Care About

Two related but distinct concepts get confused in everyday speech. A lap time is the duration of a single lap (the time elapsed since the previous lap marker. A split time is the cumulative total at a checkpoint) the time elapsed since the very start. In a 4×400m relay, each runner's lap time is what they personally ran; the split times tell you how the team's cumulative position evolved across handoffs. In a marathon, the 5K split times tell you the runner's pace at each checkpoint, while the lap-by-lap intervals would tell you their pace consistency. Olympic timing systems display both side by side. This stopwatch records both: each lap entry shows the lap interval (this lap only) in one column and the cumulative total (split since start) in another, so you can compare consistency or absolute progress depending on what you care about. The Lap button records the marker; pressing it multiple times during a single run produces an unlimited list of intervals.

Common Use Cases

• Workout and exercise timing. Sprint intervals, plank holds, rest periods between sets, HIIT circuits. The lap function records each work interval; export to a fitness log.
• Cooking and baking timing. A cleaner alternative to phone alarms when you need timing rather than alerting. Lap times are useful for multi-stage recipes (pasta in 8 minutes, sauce reducing for 12, pasta water for 4).
• Productivity tracking. Pomodoro-style work sessions (the Pomodoro Timer is purpose-built for this), but also general "how long did this task take" measurements for time-budgeting.
• Classroom games and tests. Teachers timing student answers, debate-club rebuttal periods, exam phases.
• Public-speaking practice. Rehearsal timing for talks and presentations, most conferences enforce strict time limits and rehearsing with a real stopwatch is essential.
• Recreational sports timing. Pickup games where someone needs to track a quarter or period; informal track meets; backyard races.
• Science experiments. Reaction durations, drop-time measurements, simple physics demos; the lap function captures repeated trials cleanly.

Honest Accuracy Bounds

A browser stopwatch is accurate to about 10 milliseconds when running in the foreground on modern hardware, fine for workouts, cooking, presentations, classroom games and recreational sports. It is not a substitute for: certified athletics chronometry (which uses photo-finish cameras and dedicated electronic timing systems with sub-millisecond accuracy and audit trails); GPS-synchronised lap timing (motorsport, cycling); wireless Bluetooth-paired race timing systems; or anything where the time becomes a regulated official record. The web platform's timing precision was deliberately reduced after Spectre/Meltdown to mitigate side-channel attacks; for stopwatch use this is invisible (humans can't perceive the difference) but for benchmark microsecond-level measurements you need cross-origin-isolated headers. For long-duration timing where the tab might lose focus, expect the display to "freeze" on backgrounded tabs but show the correct elapsed time when you return, the calculation uses timestamp deltas, not accumulated intervals.

Keeping the Screen On, Wake Lock API

Browsers automatically dim and eventually turn off the screen on mobile devices after a period of inactivity, which is unhelpful when you're using the stopwatch to time a workout and the screen blanks mid-run. The W3C Screen Wake Lock API lets a web page request that the screen stay on while the page is in use, supported in Chrome since 84 (July 2020), Edge, Opera, and Safari since 16.4 (March 2023), with Firefox added in 126 (May 2024). For a stopwatch, the typical pattern is to acquire the wake lock when the timer starts and release it when the timer stops or the page loses visibility; this prevents the screen blanking during long runs without permanently overriding the user's display settings. Mobile-first stopwatches benefit substantially from the Wake Lock integration; this tool's foreground use case rarely needs it, but the option is worth knowing about for self-built stopwatches.

Features

• Centisecond precision display (1/100th second), updated 10 times per second using requestAnimationFrame + performance.now() for smooth, monotonic timing.
• Unlimited lap splits: record both per-lap intervals and cumulative totals; best/worst lap can be highlighted at a glance.
• Start, Stop, Pause and Reset: full playback control without losing recorded laps until you explicitly reset.
• Keyboard shortcuts: Space to start/stop, L to record a lap, R to reset. Hands-free operation for sports and cooking use.
• Copy lap list: export all split times as plain text for pasting into a spreadsheet, training log or report.
• Works offline: once the page loads, the tool runs entirely in your browser with no further network access.

Frequently Asked Questions

How precise is the timing?

The display updates 10 times per second (centisecond precision) and the underlying calculation uses performance.now(), which is monotonic and accurate to about 100 microseconds in modern browsers (1 millisecond on some configurations after Spectre/Meltdown mitigations). For workouts, cooking, presentations and recreational sports this is more than enough, humans can't perceive timing differences finer than about 50ms in a UI context. Not a substitute for regulated athletics chronometry, GPS-synchronised motorsport timing, or anything that becomes an official record.

Why does the display freeze when I switch tabs?

Browser tab throttling. When a tab loses focus, browsers reduce the rate at which requestAnimationFrame and timer callbacks fire, typically clamping to 1 second between calls, and Chrome 88+ (January 2021) further reduces to 1 minute after 5 minutes of inactivity to save battery. The display can't update without a fired callback. The good news: the elapsed time itself is computed correctly because this tool uses timestamp deltas (performance.now() - startTime) rather than accumulated intervals, when you return to the tab, the display jumps to the correct elapsed time. For genuinely accurate background timing, a Web Worker pattern is the standard solution.

How do lap times work?

Pressing Lap records two values: the lap interval (time since the previous lap, or since start if it's the first lap) and the cumulative total (time since start, also called a "split"). Both are shown side-by-side in the lap table. The distinction matters in athletics: lap interval tells you per-segment pace consistency, cumulative total tells you absolute progress against a target time. Press Lap as many times as you need; there's no limit.

Can I pause without losing the elapsed time?

Yes, Stop pauses the timer at the current value; click Start again to resume from where you stopped. Reset clears everything (elapsed time and all lap records) and returns to zero. The lap table persists across stop-and-resume cycles so you can review and export laps from a multi-segment timing session.

Can I keep the screen on during a long workout?

For long-duration sports timing on a phone, browser default behaviour is to dim and eventually turn off the screen, which is unhelpful mid-workout. The W3C Screen Wake Lock API (Chrome 84+ July 2020, Safari 16.4+ March 2023, Firefox 126+ May 2024) lets a web page request the screen stays on while in use. This stopwatch doesn't currently invoke Wake Lock automatically, for now, the workaround is to manually adjust your phone's screen-sleep timeout, or to use the device's native stopwatch app for long-duration sports use.

Is my timing data sent anywhere?

No. The stopwatch runs entirely in your browser. Your timing data (start time, lap times, current elapsed value) never crosses the network. Verify in DevTools' Network tab while the stopwatch runs, or take the page offline (airplane mode) after it loads and the stopwatch still works perfectly. Useful for any timing context where confidentiality matters: closed-track sports trials, internal performance benchmarking, etc.

Related Tools