---
id: parallelbar
version: "2.5"
license: MIT
license_treatment: permissive
maintenance: active
---

# parallelbar — Parallel processing with progress bars

License: permissive · Maintenance: active · Downloads: 100.0K/mo

## What it is and what it does

Parallelbar is a thin wrapper around Python's standard multiprocessing.Pool that adds live progress bars to parallel map operations. It sits on top of tqdm and colorama to display task completion and handles exceptions and timeouts that occur in worker processes, capturing their tracebacks and returning them in the result list alongside successful outputs.

You use it by replacing calls to pool.map() or pool.imap() with progress_map() or progress_imap(), specifying the number of CPU cores and optionally a timeout per task. The package supports exception handling (exceptions are caught and returned in-place), task timeouts (with automatic process restart), and decorators for adding progress to nested function calls within workers.

Use it for:

- Parallelize CPU-intensive batch processing (e.g., image resizing, data transformation) and watch progress in real time.
- Run parameter sweeps or hyperparameter searches across multiple cores with live feedback on completion.
- Process large datasets with starmap to unpack argument tuples while monitoring progress and catching per-task errors.
- Add timeout protection to worker tasks to prevent hung processes from blocking the entire pool.
- Debug parallel code by capturing exception tracebacks from worker processes instead of losing them to the pool.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Parallelbar wraps Python's multiprocessing Pool methods (map, starmap, imap, imap_unordered) to display live progress bars and handle exceptions and timeouts across worker processes.

Yes. Low install friction, active maintenance, permissive license, and no known vulnerabilities. Use it if you need live progress feedback on multiprocessing.Pool operations or want built-in exception and timeout handling for parallel tasks. Skip it only if you prefer raw Pool performance without monitoring overhead or use async/concurrent.futures instead of multiprocessing.

## Install

pip install parallelbar
uv add parallelbar
poetry add parallelbar

## Installing parallelbar

Before you install: Low friction: pure Python wheel with only two runtime dependencies (tqdm and colorama). Actively maintained with recent releases; last commit 2026-07-13.

License in practice: MIT license is permissive; you can use, modify, and distribute this package freely in commercial and private projects with minimal restrictions.

Quickstart:

from parallelbar import progress_map
from multiprocessing import cpu_count

def task(x):
    return x * 2

if __name__ == '__main__':
    results = progress_map(task, range(100), n_cpu=cpu_count())

On Windows, functions decorated with @add_progress must accept a worker_queue parameter; on UNIX systems this is optional.

Verify before relying:

- Whether the package works with modern Python versions (requires_python is unspecified in metadata)
- Performance overhead of progress tracking relative to raw Pool operations
- Compatibility with nested multiprocessing or process pools within worker functions

## Package facts

- License: MIT (permissive)
- Python support: unspecified
- Install friction: low
- Maintenance: active
- Downloads: 100.0K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

parallel map with progress bar, multiprocessing progress tracking, tqdm parallel processing, pool progress bar, parallel task monitoring, concurrent map with exceptions, multiprocessing exception handling, multiprocessing, progress-bar, parallel-execution

[View on SkillFed](https://skillfed.io/packages/parallelbar) · [View on PyPI](https://pypi.org/project/parallelbar/)