Skip to main content

How to Create a Progress Bar in Batch Script

When you have a batch script that performs a long-running task, like processing a large number of files or waiting for a network operation, the command prompt can appear frozen, leaving the user wondering if the script is still working. A progress bar provides crucial visual feedback, showing that the script is making progress and giving an estimate of how much work is left to do.

This guide will explain the clever "pure-batch" trick used to create a simulated, text-based progress bar on a single, updating line. You will learn how to use a loop, the carriage return character, and the <nul set /p command to build this effect. We will also cover the far superior modern alternative using PowerShell's Write-Progress cmdlet.

The Challenge: No Native Progress Bar and a Scrolling Console​

The Windows command prompt (cmd.exe) has no built-in PROGRESSBAR command. The main obstacle is that the console is a scrolling terminal: every ECHO command prints a new line, pushing the previous content up. To create a progress bar, we need a way to:

  1. Print a line of text without moving to the next line.
  2. Move the cursor back to the beginning of that same line to overwrite it in the next update.

The Core Method (Pure Batch): The Carriage Return Trick​

This method combines several advanced batch scripting techniques to create the illusion of an updating progress bar.

The logic

  1. Get a Carriage Return Character: We need a way to move the cursor to the start of the line. The best way to capture this special character into a variable is with a FOR loop over a prompt command.
  2. Start a Loop: Use a FOR /L loop to represent the progress from 0% to 100%.
  3. Build the Bar: Inside the loop, build a string of block characters ( █ ) to represent the completed portion of the bar.
  4. Print Without Newline: Use the <nul set /p command to print the bar string, the percentage, and the carriage return character, all without moving to the next line.
  5. Pause: Add a small delay so the user can see the progress.

For any modern system, calling PowerShell is a vastly better solution. The Write-Progress cmdlet creates a real, graphical progress bar window with a status message. It is smoother, faster, and much more professional.

Syntax (called from Batch)​

powershell -Command "for ($i=1; $i -le 100; $i++) { Write-Progress -Activity 'Processing Files' -Status ('%d%% Complete:' -f $i) -PercentComplete $i; Start-Sleep -m 50 }"

Basic Example: A Simple Text-Based Progress Bar​

This script implements the "pure-batch" method to draw a simple progress bar from 0 to 100%.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

ECHO --- Simulating a Long Task ---
ECHO.

REM --- Get a carriage return character (a backspace) into a variable ---
FOR /F %%a IN ('prompt $H ^& for %%b in (1) do rem') DO (
    SET "CR=%%a"
)

SET "ProgressBar="
FOR /L %%i IN (1,1,50) DO (
    SET "ProgressBar=!ProgressBar!█"
    SET /A "percent = %%i * 2"
    
    REM --- The core output command ---
    <nul set /p "=Progress: [!ProgressBar!] !percent!%% !CR!"
    
    REM --- Simulate work with a short delay ---
    TIMEOUT /T 1 /NOBREAK > NUL
)

ECHO.
ECHO.
ECHO --- Task complete ---
ENDLOCAL

How the Batch Script works:

  • SETLOCAL ENABLEDELAYEDEXPANSION: Absolutely essential for this script, as the ProgressBar and percent variables change in every iteration of the loop.
  • FOR /F %%a IN ('prompt $H ...'): This is a standard, albeit strange, trick. prompt $H generates a backspace character. We capture this character into the CR variable. In the console, a backspace followed by new text effectively acts like a carriage return.
  • SET "ProgressBar=!ProgressBar!█": In each loop, we append another block character to our bar string.
  • <nul set /p "=...": This is the magic print command.
    • <nul: Provides no input to the set /p command.
    • set /p "=...": Prints the string that follows the = as a prompt without a newline character.
    • !CR!: At the end of the string, we print our captured carriage return character, which moves the cursor back to the beginning of the line, ready for the next update.
  • ECHO. (after the loop): After the loop finishes, the cursor is still on the same line as the progress bar. We need to print a couple of new lines to move past it cleanly.

Common Pitfalls and How to Solve Them​

Problem: The Script is Slow and Flickers​

The pure-batch method is very slow due to the overhead of string manipulation in a loop. The constant redrawing can also cause a noticeable flicker in the console window.

Solution: This is an inherent limitation of the method. For a smooth and fast progress bar, use the PowerShell Write-Progress method.

Problem: Forgetting Delayed Expansion​

If you do not use SETLOCAL ENABLEDELAYEDEXPANSION and the ! syntax, the script will not work. It will print the same (empty) progress bar and percentage in every iteration because the % variables will be expanded only once before the loop starts.

Solution: This is non-negotiable. Delayed expansion is required for this effect.

Practical Example: A "Processing Files" Loop​

This script uses the progress bar to show the status of a simulated file processing task.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

REM Create a list of dummy files to process
SET "FileList=file1.txt file2.txt file3.txt file4.txt file5.txt"
SET "FileCount=5"
SET "processed=0"

FOR /F %%a IN ('prompt $H ^& for %%b in (1) do rem') DO SET "CR=%%a"

ECHO --- Processing %FileCount% files ---
FOR %%F IN (%FileList%) DO (
    SET /A "processed+=1"
    
    ECHO Processing file %%F...
    TIMEOUT /T 2 /NOBREAK > NUL
    
    REM --- Update the progress bar ---
    SET /A "percent = processed * 100 / FileCount"
    SET "bar="
    SET /A "bar_len = percent / 2"
    FOR /L %%b IN (1,1,!bar_len!) DO SET "bar=!bar!█"
    
    <nul set /p "=Progress: [!bar!] !percent!%% !CR!"
)

ECHO.
ECHO.
ECHO --- All files processed ---
ENDLOCAL

Conclusion​

While batch scripting has no built-in progress bar, you can create a functional text-based simulation for providing feedback during long-running tasks.

Key takeaways:

  • The pure-batch method relies on a FOR loop to build the bar and the <nul set /p command combined with a carriage return to print on a single, updating line.
  • This method is a clever trick, but it is slow and can flicker.
  • The PowerShell Write-Progress cmdlet is the overwhelmingly superior and recommended best practice. It creates a real, smooth, and professional-looking progress bar window and is much more efficient.

Table of Contents