Skip to main content

How to Create a Simple Stopwatch Timer in a Batch Script

Creating a stopwatch is a classic programming exercise that demonstrates how to handle time, user input, and screen updates. While batch scripting is not a high-precision language, it is fully capable of creating a simple and functional stopwatch that can be used to time tasks or events directly from the command line.

This guide will teach you how to build a stopwatch using the %TIME% variable to capture the start and end times, and then perform the necessary calculations to find the elapsed duration in seconds. You will learn the crucial logic of converting time components into a single, comparable unit.

note

NOTE: This script is for simple, manual timing. Its precision is limited by the cmd.exe environment and is not suitable for high-accuracy scientific or performance measurements.

The Core Logic: Capturing and Calculating​

The logic for a stopwatch is straightforward:

  1. Wait for the user to start: Pause the script and record the start time when the user presses a key.
  2. Wait for the user to stop: Pause again and record the end time when the user presses another key.
  3. Calculate the difference: Convert both the start and end times into a total number of seconds from the beginning of the day.
  4. Subtract: Subtract the start seconds from the end seconds to get the elapsed duration.
  5. Display the result: Show the final elapsed time to the user.

The Key Tools: SET /P, %TIME%, and SET /A​

  • SET /P: We will use this command with a null prompt to create a "Press any key to continue" effect that doesn't add extra text. SET /P "=Press Enter to Start..."
  • %TIME%: The built-in dynamic variable that provides the current time (e.g., 10:30:15.75). We will parse this string to get the hours, minutes, and seconds.
  • SET /A: The arithmetic command, which we will use to convert the time components into total seconds and to perform the final subtraction.

The Script: A Full Stopwatch Timer​

This script implements the full stopwatch logic.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

:MainMenu
CLS
ECHO --- Simple Batch Stopwatch ---
ECHO.
SET /P "=Press Enter to START the timer..."

REM --- Capture Start Time ---
SET "StartTime=%TIME%"
SET "Start_H=%StartTime:~0,2%"
SET "Start_M=%StartTime:~3,2%"
SET "Start_S=%StartTime:~6,2%"
REM Handle leading space for hours < 10
IF "%Start_H:~0,1%"==" " SET "Start_H=0%Start_H:~1,1%"

CLS
ECHO --- Timer is RUNNING ---
ECHO Start time: %StartTime%
ECHO.
SET /P "=Press Enter to STOP the timer..."

REM --- Capture End Time ---
SET "EndTime=%TIME%"
SET "End_H=%EndTime:~0,2%"
SET "End_M=%EndTime:~3,2%"
SET "End_S=%EndTime:~6,2%"
IF "%End_H:~0,1%"==" " SET "End_H=0%End_H:~1,1%"

ECHO Stop time:  %EndTime%
ECHO.
ECHO --- Calculating elapsed time... ---

REM --- Convert both times to total seconds from midnight ---
SET /A "StartTotalS = (%Start_H% * 3600) + (%Start_M% * 60) + %Start_S%"
SET /A "EndTotalS = (%End_H% * 3600) + (%End_M% * 60) + %End_S%"

REM --- Calculate the difference ---
SET /A "ElapsedS = %EndTotalS% - %StartTotalS%"

REM Handle midnight rollover
IF %ElapsedS% LSS 0 SET /A "ElapsedS = 86400 + %ElapsedS%"

ECHO.
ECHO ============================
ECHO  ELAPSED TIME: %ElapsedS% seconds
ECHO ============================
ECHO.

CHOICE /C RN /M "Reset (R) or Exit (N)?"
IF ERRORLEVEL 2 GOTO :EOF
IF ERRORLEVEL 1 GOTO :MainMenu

How the script works:

  1. Start: The script waits for the user to press Enter. The moment they do, it captures %TIME% into StartTime.
  2. Parse Start Time: It immediately uses substring extraction (%StartTime:~0,2%) to get the hour, minute, and second components from the time string.
  3. Stop: The script waits again. When the user presses Enter, it captures %TIME% into EndTime and parses it.
  4. Convert to Seconds: This is the core calculation. SET /A is used to convert both the start and end times into a single, large number representing the total seconds that have passed since midnight.
    • Hours * 3600 (seconds in an hour)
    • Minutes * 60
    • Seconds
  5. Subtract: SET /A "ElapsedS = %EndTotalS% - %StartTotalS%" performs the final, simple subtraction to get the duration.
  6. Midnight Rollover: If the timer was started before midnight and stopped after, EndTotalS will be smaller than StartTotalS, resulting in a negative number. The line IF %ElapsedS% LSS 0 SET /A "ElapsedS = 86400 + %ElapsedS%" corrects this by adding the total number of seconds in a day.

Common Pitfalls and How to Solve Them​

  • %TIME% Format: The script assumes a HH:MM:SS.ss format. This can change based on regional settings. A more robust script would query WMIC to get a fixed-format time.
  • Leading Space in Hour: The %TIME% variable has a leading space for hours less than 10 (e.g., 9:05...). The script handles this with the line IF "%Start_H:~0,1%"==" " SET "Start_H=0%Start_H:~1,1%", which replaces the space with a 0.
  • Precision: The script only uses whole seconds. The centiseconds (.ss) are ignored. For higher precision, a PowerShell script would be necessary.

The Superior PowerShell Alternative​

A PowerShell script can do this far more elegantly by working with [datetime] objects, which removes all the manual parsing and calculation.

@ECHO OFF
ECHO --- PowerShell Stopwatch ---
ECHO.
SET /P "=Press Enter to START..."
powershell -Command "$global:StartTime = Get-Date"

ECHO Timer is running...
SET /P "=Press Enter to STOP..."
powershell -Command "$global:EndTime = Get-Date; $elapsed = $global:EndTime - $global:StartTime; Write-Host ('Elapsed: {0:f2} seconds' -f $elapsed.TotalSeconds)"

This hybrid script is much shorter and more accurate, as it can handle fractional seconds.

Conclusion​

Creating a stopwatch is a great way to practice core batch scripting skills like user input, string parsing, and arithmetic.

  • The pure-batch solution relies on capturing the %TIME% variable at two points.
  • You must parse the time string into hours, minutes, and seconds.
  • The core logic is to convert both times to total seconds, perform a subtraction, and display the result.
  • While functional, the batch method is complex. For a simpler and more precise timer, delegating the calculation to PowerShell is the recommended modern approach.

Table of Contents