ApertureLab Open the appsign-in required
← ApertureLab

Six thousand square meters of seafloor, 2.5 cm pixels, eight minutes, about a dime.

ApertureLab scenes run unchanged on cloud GPU instances: the same YAML that renders on a workstation becomes a batch of self-managing spot instances, one machine per scene. A ten-scene set finishes in roughly the time of one. This page covers what a scene is and what it costs, how a batch runs, and the tooling that keeps spend as disciplined as the physics.

Scale, speed, cost

Full survey-patch scenes, in minutes, for well under a dollar.

The unit of work is a complete scene, simulated and beamformed at production fidelity; not a crop, not a preview.

60 m × 100 m
scene footprint at 2.5 cm pixel resolution: roughly 145 million scatterers focused into a 25 megapixel image.
~8 min
wall clock per scene, submit to delivered product, including instance boot. Scenes run on parallel machines, so a whole batch finishes in roughly the time of one.
0.13 hr
billed instance time for that scene, which is at most $0.13 even at the on-demand rate; these runs go to spot, which is cheaper again.

Measured 2026-09-13 on one scene: 60 m along track by 100 m in range, 2.5 cm pixels, Fourier-wavefield backend, delivered as a 4000 by 2449 pixel image. Numbers on this page are single measurements from a real run rather than modelled estimates, and they keep moving; this scene was roughly three times slower before the September 2026 optimization pass, and roughly ten times slower before the FFT rewrite of the echo-accumulation kernel. A point-scatterer run of the same scene costs more, and scales with scatterer density; the Fourier-wavefield backend does not.

The mechanism

How a batch runs.

One command submits a batch: python -m cloud run <scene>.yaml, or the Run on AWS button in the GUI. Code ships content-addressed; a given version uploads once, not once per job, so submitting fifty scenes moves fifty small scene files and zero redundant copies of the codebase. From there each job is on its own.

  1. Launch

    Each job gets its own spot GPU instance. A launch loop fills however many quota slots exist, hunts across availability zones for spot capacity cheapest-zone-first, and retries transient capacity droughts indefinitely; a batch submitted into a dry market simply waits and fills as capacity appears.

  2. Boot

    The machine image arrives with the worker container already baked in, so there is nothing to pull; the instance boots and unpacks the content-addressed code snapshot for the submitted version. Cold boot to first work is 33 seconds, down from 110 before a failing system unit that was holding networking for 83 seconds was masked out of the image.

  3. Simulate and beamform

    The full pipeline runs on the instance's GPU: acoustic simulation to complex IQ, then time-domain back-projection to a focused, georeferenced image, identical to a local run of the same scene file.

  4. Deliver and terminate

    Products upload to S3 and the instance terminates itself. Results stream back to the CLI or GUI exactly as a local run would; closing the GUI does not kill the job.

Every image carries its provenance: a watermark records the instance type and whether it ran on spot or on-demand capacity, so cloud-generated imagery is always identifiable as such and traceable to the hardware that produced it.

Setup

One command, once, in your own account.

Setup is a single idempotent command: python -m cloud init creates the storage bucket, the worker role, and the network configuration in your own AWS account, everything tagged so it can be found and removed as a unit. The worker container image is public. After that, a scene runs from one CLI command or from the Run on AWS button next to Run in the GUI; progress, logs, and products land in the same panels as a local run.

Monitoring

Watch every job, and every dollar.

Elastic compute is only useful if it cannot surprise you. The cloud path treats cost the way the simulator treats physics: measured, bounded, and checked at every step rather than assumed.

The AWS tab in the workbench: a job list with per-job status and live cost estimates, and a month-to-date account spend readout behind a Refresh button

The AWS tab in the workbench: per-job status and live cost estimates while jobs run, with month-to-date billed spend one click away.

The rigor applied to the acoustics is applied to the invoice; both are part of making synthetic SAS data cheap enough to treat as an AI modality.

The shape of it

One scene, one GPU job.

Nothing about the batch is a scheduler in the usual sense. A scene set is split across as many instances as there are quota slots, each instance takes exactly one scene, and each terminates itself when its products are uploaded.

A four-step panel: design a scene in the browser, fan the scene set out to a queue, simulate at scale with one GPU per scene, and deliver one labeled dataset

Design, fan out, simulate, deliver. One scene is one GPU job, so a hundred scenes finish in about the time of one.

Preflight

Proof the scene locally; spend only when it's right.

Before a batch launches, the scene's heightmap renders locally in about 30 seconds, for free: seafloor zones, ripple fields, and object placement on the exact geometry the simulator will trace. Approve it, then let the cloud make the real image. The six tiles below each pair one seafloor type's preflight with its finished render; each crossfades between its local heightmap preflight and the cloud-rendered SAS image. The geometry is identical, so the two fade into alignment.

Cloud-rendered SAS image of a flat sand seafloor Local heightmap preflight of the same flat sand scene Sand
Cloud-rendered SAS image of a fine-rippled sand seafloor Local heightmap preflight of the same fine-ripple scene Fine ripple
Cloud-rendered SAS image of a coarse-rippled sand seafloor Local heightmap preflight of the same coarse-ripple scene Coarse ripple
Cloud-rendered SAS image of a smooth mud seafloor Local heightmap preflight of the same mud scene Mud
Cloud-rendered SAS image of a fractal-relief seafloor Local heightmap preflight of the same fractal-relief scene Fractal
Cloud-rendered SAS image of a rocky seafloor Local heightmap preflight of the same rocky scene Rocky

Six seafloor types, each proofed as a free 30-second local heightmap before its 20-minute cloud render. Pixel registration between the pairs is exact; what you approve is what the physics images.