Top 7 Python Libraries for Progress Bars

Photo by author

# Introduction Loading…

Progress bars make the wait more bearable. They show how much work has been completed, how much remains, and whether a loop is still running or has stopped. This simple visual feedback improves clarity when executing long-running scripts.

Progress bars are particularly useful in data processing, model training, and machine learning workflows, where tasks can take several minutes or even hours to complete. Instead of waiting without feedback, developers can track progress in real time and better understand execution behavior.

In this article, we explore the top seven Python libraries for progress bars. Each library includes example code so you can quickly integrate it into your projects with minimal setup.

# 1. tqdm

tqdm is one of the most popular Python libraries for adding progress bars to loops and iterable-based workflows. It’s lightweight, easy to integrate, and works out of the box with minimal code changes.

The library automatically adapts to a variety of environments, including terminals, notebooks, and scripts, making it a reliable choice for data processing and machine learning tasks where visibility into execution progress is critical.

Key Features:

• Automated progress tracking for any iteration with minimal code changes
• High performance with very little overhead, even for large loops
• Clear and informative output, including iteration speed and estimated time remaining

Example code:

# pip install tqdm
from tqdm import tqdm
import time

records = range(1_000)

for record in tqdm(records, desc="Cleaning records"):
    time.sleep(0.002)

Output:

Cleaning records: 100%|██████████| 1000/1000 (00:02<00:00, 457.58it/s)

# 2. Rich

rich is a modern Python library designed to create visually appealing and highly readable terminal output, including advanced progress bars. Unlike traditional progress bar libraries, Rich focuses on presentation, making it ideal for applications where clarity and aesthetics are important, such as developer tools, dashboards, and command-line interfaces.

Progress bars support rich text formatting, dynamic descriptions, and smooth animations. This makes it especially useful when you want progress indicators that are informative and visually appealing without adding complex logic to your code.

Key Features:

• Visually rich progress bar with colors, styling and smooth animations
• Simple API to track progress on iterators
• Seamless integration with other rich components such as tables, logs and panels

Example code:

# pip install rich
from rich.progress import track
import time

endpoints = ("users", "orders", "payments", "logs")

for api in track(endpoints, description="Fetching APIs"):
    time.sleep(0.4)

Output:

Fetching APIs ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:01

# 3. Live development

Living development is a Python library focused on creating dynamic and visually engaging progress bars for terminal applications. It stands out by providing smooth animations and dynamic gestures that make long-running tasks easier to monitor and more pleasant to watch.

This library is suitable for scripts where user experience is important, such as training loops, batch jobs, and command line tools. It offers a flexible API that allows developers to customize themes, styles, and behaviors while keeping implementation straightforward.

Key Features:

• Smooth animated progress bar with dynamic indicators
• Flexible customization for titles, styles and refresh behavior
• Clear performance metrics including elapsed time and processing speed.

Example code:

# pip install alive-progress
from alive_progress import alive_bar
import time

epochs = 10

with alive_bar(epochs, title="Training model") as bar:
    for _ in range(epochs):
        time.sleep(0.6)
        bar()

Output:

Training model |████████████████████████████████████████| 10/10 (100%) in 6.0s (1.67/s) 

# 4. Hello

hello is a Python library designed to display beautiful spinner animations in the terminal. Rather than showing progress as a percentage or bar, Halo provides visual indicators that indicate an ongoing process, making it ideal for tasks where progress cannot be easily quantified.

This library is typically used for startup routines, network calls, and background operations where a simple status indicator is more appropriate than a traditional progress bar. Its clean API and custom spinners make it easy to add polished feedback to command-line tools.

Key Features:

• Lightweight spinner animations for undefined tasks
• Simple and intuitive API with start, success, and failure states
• Multiple built-in spinner styles with custom text

Example code:

# pip install halo
from halo import Halo
import time

spinner = Halo(text="Starting database", spinner="line")
spinner.start()
time.sleep(3)
spinner.succeed("Database ready")

Output:

| Starting database
✔ Database ready

# 5. ipywidgets

ipywidgets is a Python library that enables interactive user interface components in Jupyter notebooks, including progress bars, sliders, buttons, and forms. Unlike terminal-based libraries, ipywidgets present development prompts directly in the notebook interface, making them particularly useful for exploratory data analysis and interactive experiments.

Progress bars built with ipywidgets integrate seamlessly with notebook workflows, allowing users to monitor long-running tasks without cluttering the output. This makes it a strong choice for machine learning experiments, parameter tuning, and iterative research conducted in the Jupyter environment.

Key Features:

• Local progress bar rendering within a Jupyter notebook
• Interactive UI components beyond tracking progress
• Fine control over progress updates and display behavior

Example code:

# pip install ipywidgets
import ipywidgets as widgets
from IPython.display import display
import time

progress = widgets.IntProgress(value=0, max=5, description="Experiments")
display(progress)

for _ in range(5):
    time.sleep(1)
    progress.value += 1

Output:

# 6. Development

Development is a lightweight Python library that provides a simple and classic progress bar for terminal-based applications. It focuses on minimalism and readability, making it a good choice for scripts where clarity is more important than modern styling or animation.

The library offers a variety of development indicators, including bars, spinners, and counters, allowing developers to choose the format that best fits their use case. Its straightforward API makes it easy to integrate into existing scripts with minimal changes.

Key Features:

• Simple and clean terminal progress bar
• Multiple progress indicators such as bars and spinners
• Minimal dependencies and easy integration

Example code:

# pip install progress
from progress.bar import Bar
import time

files = ("a.csv", "b.csv", "c.csv")

bar = Bar("Uploading files", max=len(files))
for _ in files:
    time.sleep(0.7)
    bar.next()
bar.finish()

Output:

Uploading files ████████████████████████████████ 100%

# 7. Click

click There is a Python library for creating command line interfaces that includes built-in support for progress bars. Unlike standalone progress bar libraries, Click integrates progress tracking directly into CLI commands, making it ideal for tools that are distributed and used from a terminal.

The progress bar provided by Click is designed to be simple, reliable, and work seamlessly with its command system. This is especially useful when building data pipelines, automation scripts, or developer tools where progress feedback must be part of the command execution flow.

Key Features:

• Built-in progress bars designed specifically for command-line interfaces.
• Seamless integration with click command decorators and options
• Reliable output handling for terminal-based tools

Example code:

# pip install click
import time
import click

@click.command()
def main():
    items = list(range(30))

    # Progressbar wraps the iterable
    with click.progressbar(items, label="Processing items") as bar:
        for item in bar:
            # Simulate work
            time.sleep(0.05)

    click.echo("Done!")

if __name__ == "__main__":
    main()

Output:

Processing items  (####################################)  100%          
Done!

Comparison of Python progress bar libraries

The table below provides a simple comparison of the Python progress bar libraries covered in this article, focusing on where they work best and how they are commonly used.

Abid Ali Awan (@1abidaliawan) is a certified data scientist professional who loves building machine learning models. Currently, he is focusing on content creation and writing technical blogs on machine learning and data science technologies. Abid holds a Master’s degree in Technology Management and a Bachelor’s degree in Telecommunication Engineering. His vision is to create an AI product using graph neural networks for students struggling with mental illness.