ProgressMeter.jl

The @showprogress macro is a convenient way to wrap loops or functional programming constructs to display a progress bar. It supports for loops, comprehensions, @distributed loops, and map/pmap/reduce calls, provided the iterable implements length.

If the computation is too fast to require updates, no output is displayed. For @distributed loops without a reducer, an @sync is implied.

using Distributed
using ProgressMeter

# For loops
@showprogress dt=1 desc="Computing..." for i in 1:50
    sleep(0.1)
end

# pmap
@showprogress pmap(1:10) do x
    sleep(0.1)
    x^2
end

# reduce
@showprogress reduce(1:10) do x, y
    sleep(0.1)
    x + y
end

# Distributed loops
@showprogress @distributed for i in 1:10
    sleep(0.1)
end

# Distributed loops with reducer
result = @showprogress desc="Computing..." @distributed (+) for i in 1:10
    sleep(0.1)
    i^2
end

To install ProgressMeter.jl, run the following command within a Julia REPL:

using Pkg; Pkg.add("ProgressMeter")

For more granular control, or when the progress increment is not constant (e.g., reading files where progress depends on byte position), use the Progress type and its update methods.

• next!(p): Increments the progress by one step.
• update!(p, value): Sets the progress to a specific value (useful for non-monotonic increments or variable step sizes).

using ProgressMeter

# Standard manual increment
function my_long_running_function(filenames::Array)
    n = length(filenames)
    p = Progress(n; dt=1.0)
    for f in filenames
        next!(p)
    end
end

# Variable increment (e.g., file reading)
function readFileLines(fileName::String)
    file = open(fileName,"r")
    seekend(file)
    fileSize = position(file)
    seekstart(file)

    p = Progress(fileSize; dt=1.0)
    while !eof(file)
        line = readline(file)
        update!(p, position(file))
    end
end

You can extend @showprogress support to custom functions (like tmap from ThreadTools.jl) by defining ProgressMeter.ncalls. This tells the macro how to extract the iteration count from the function call.

using ThreadTools, ProgressMeter

# Define how to find the number of calls for tmap
ProgressMeter.ncalls(::typeof(tmap), ::Function, args...) = ProgressMeter.ncalls_map(args...)
ProgressMeter.ncalls(::typeof(tmap), ::Function, ::Int, args...) = ProgressMeter.ncalls_map(args...)

# Now @showprogress works with tmap
@showprogress tmap(abs2, 1:10^5)

You can disable a progress meter using the enabled keyword argument. This is useful for:

1. Disabling output in CI/CD environments.
2. Preventing nested progress bars (e.g., disabling an inner loop's progress bar when an outer loop is already tracking progress).

using ProgressMeter

# Disable via environment variable
const SHOW_PROGRESS_BARS = parse(Bool, get(ENV, "PROGRESS_BARS", "true"))

# Disable inner loop to avoid clutter
for i in 1:m
    my_awesome_slow_loop(i; show_progress=false)
    next!(p)
end

# Automatically disable in non-TTY or CI environments
function is_logging(io)
    return !isa(io, Base.TTY) || (get(ENV, "CI", nothing) == "true")
end

p = Progress(n; output = stderr, enabled = !is_logging(stderr))

When a task terminates based on a target threshold (e.g., an optimization algorithm reaching a specific tolerance) rather than a fixed number of steps, use ProgressThresh(threshold).

using ProgressMeter

prog = ProgressThresh(1e-5; desc="Minimizing:")
for val in exp10.(range(2, stop=-6, length=20))
    update!(prog, val)
    sleep(0.1)
end

To include the average time per iteration (e.g., 12.34 s/it) in the output, set showspeed=true in the constructor of Progress, ProgressUnknown, or ProgressThresh.

using ProgressMeter

x, n = 1, 10
p = Progress(n; showspeed=true)
for iter in 1:10
    x *= 2
    sleep(0.5)
    next!(p)
end

Jupyter notebooks/lab handle cell output differently than standard terminals. To control whether progress bars append to the output or clear the cell output, use ProgressMeter.ijulia_behavior():

• ProgressMeter.ijulia_behavior(:append): Restores the behavior of printing progress bars repeatedly (standard behavior in older versions).
• ProgressMeter.ijulia_behavior(:clear): Clears the cell output (default in newer versions).

You can display metadata (like iteration counts or current error values) below the progress bar using the showvalues keyword in next!().

Performance Tip: To avoid evaluating the metadata every time the loop runs (even if the progress bar isn't being updated to the screen), pass a zero-argument function as a callback. This ensures the values are only computed when necessary.

using ProgressMeter

x, n = 1, 10
p = Progress(n)

# Method 1: Direct values (evaluated every iteration)
for iter in 1:10
    x *= 2
    next!(p; showvalues = [("iteration count", iter), ("x", x)])
end

# Method 2: Callback function (evaluated only when necessary)
generate_showvalues(iter, x) = () -> [("iteration count", iter), ("x", x)]
for iter in 1:10
    x *= 2
    next!(p; showvalues = generate_showvalues(iter, x))
end