Batch Stitching in Hugin: PTBatcherGUI & hugin_executor Guide

Quick answer: Prepare each panorama as a saved Hugin project (.pto), add the projects to the PTBatcherGUI queue, and start the queue: it stitches them one after another, unattended, reporting success or failure per job. For scripted or repeated work, hugin_executor does the same job from the command line — it can run a project file to completion, and can also run the Assistant workflow on a set of images. Batch stitching turns Hugin from an interactive tool into a render farm of one.

Why batch at all

Interactive stitching is fast for one panorama and wasteful for twenty: every render keeps you at the keyboard answering the same dialogs while the CPU does the real work in bursts. Real workloads are bursty in the other direction — a day of shooting virtual tours, a season of real-estate sets, a gigapixel grid that renders for hours. The batch pattern separates deciding from rendering: you align and approve every project while you are fresh, save them all, and let the queue render them overnight. It is also the safer pattern for big jobs, because a render that fails at 3 a.m. fails as one queue entry with a status message, not as a lost afternoon.

Prepare projects the queue can trust

PTBatcherGUI stitches project files, not loose photos, so the preparation step is: build each panorama in Hugin as usual — Assistant or Advanced — check the preview carefully, set the output in the Stitcher tab, and save the .pto project into the folder where the render should land. Everything the render needs is frozen into that file: photos, control points, projection, canvas size, output format. The rule of batch work is that the queue renders exactly what you approved, including your mistakes: a tilted horizon renders tilted, at scale. Preview discipline from our step-by-step tutorial matters more here, not less. One practical habit: render one representative project interactively first, confirm the output settings and file sizes are what you expect, then clone that pattern across the rest.

Run the queue in PTBatcherGUI

Open PTBatcherGUI — it installs alongside Hugin and PT stands for Panorama Tools — and add your saved projects to its list. The queue processes projects sequentially: for each one it runs the full stitch (remapping with nona, blending with Enblend) using the settings stored in the project, writes the output next to the project or as configured, and marks the entry with its outcome before moving on. You can add projects while it works, remove ones that have not started, and leave it running with the machine unattended. Sequential processing is deliberate: a single render can already saturate CPU and disk, so parallel renders would mostly contend for the same resources. When you return, the queue is your report — completed entries, and failures flagged per project rather than discovered one panorama at a time.

hugin_executor: the command-line route

Everything the queue does can also be driven from a terminal with hugin_executor, Hugin’s command-line stitching tool. Its two modes cover the whole batch story: give it a project file and it stitches that project exactly as PTBatcherGUI would; give it a set of image files and it runs the Assistant on them — loading, aligning and producing a rendered panorama from the photos directly. That second mode powers scripted pipelines: a shell script that walks a folder tree of the day’s shoots, runs the Assistant per folder, and leaves rendered drafts waiting for review in the morning. Command-line runs also log what they did, which makes failures diagnosable after the fact: the log shows which stage (control points, optimization, remapping, blending) a scripted job died in. Exact options are documented in the tool’s own help and the Hugin manual; start with the project-file mode, which mirrors the GUI queue, before automating Assistant runs.

Overnight renders without babysitting

  • Disk first: batch jobs multiply intermediate files. Keep several times the expected output size free, on the drive the projects live on — running dry mid-queue fails every remaining job, not just the current one.
  • Power and sleep: disable system sleep for the render machine, or the queue pauses politely until morning and so does your deadline.
  • Order matters: put the most important or most uncertain project first, so if anything goes wrong it goes wrong early and visibly.
  • Draft then master: for review-heavy work, batch a set of small draft renders first, approve them on screen, then queue the full-resolution renders of the approved projects only.

Draft queues: the pattern for review-heavy work

The most useful batch habit is two-stage rendering. First, queue every project at a small draft size and let the machine produce a complete set of previews overnight. Review the drafts on screen in the morning — this is where tilted horizons, missed frames and bad nadirs are cheap to catch — and fix only the projects that need it. Then queue the approved projects at full size for the following night. The draft pass costs a fraction of one full render and routinely saves several. This pattern is how tour and real-estate shooters keep a day of shooting from becoming a week of rendering: the computer, not the photographer, spends the hours, and the photographer’s judgement is spent once, on finished-looking drafts, instead of repeatedly on settings dialogs.

Keep the queue’s world tidy: one folder per job, projects and their renders side by side, source photos untouched after alignment. Batch rendering punishes improvisation — a renamed folder breaks a dozen queued projects at once — and rewards boring, consistent file management more than any cleverness.

When a queued job fails

A failed entry usually repeats a failure you can reproduce interactively in a minute: open that project in Hugin and run the Assistant’s steps by hand. The usual causes are mundane — a moved or renamed source photo, a full disk, control points that never covered one frame, or an output path that no longer exists. Fix the project, re-add it to the queue, and move on; do not re-queue its neighbours, which rendered fine. Persistent failures on very large projects point at memory and temp space, and the cache and disk guidance in our gigapixel guide applies directly.

FAQ

What is PTBatcherGUI?

It is the batch queue program that ships with Hugin. You add saved project files to its list and it stitches them one after another, unattended, marking each job’s outcome. It renders the settings stored in each project file.

Can Hugin stitch a folder of photos without opening the GUI?

Yes, with hugin_executor from the command line: in its Assistant mode it loads a set of images, aligns them and renders a panorama. In its project mode it stitches a saved .pto file exactly like the batch queue does.

Should I run several batch jobs in parallel to finish sooner?

Generally no. One render already loads the CPU and disk heavily; parallel renders compete for the same resources and can run slower overall, as well as multiplying temp-disk pressure. The queue’s sequential processing is the efficient pattern.

Why did my queued render fail overnight?

The common causes are a full disk (batch intermediates are large), a source photo that moved, or a project whose alignment was never sound. Open the project interactively — the same failure usually reproduces immediately and points at its cause.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *