Reusable templates

Register an image or upload a Dockerfile; it is pinned by digest.

docs-confirmed “A template is a named image, plus (optionally) the port its main service listens on.” Source↗

Deploy from a Dockerfile image, or fork a snapshot.

docs-confirmed “It is also possible to build your own [custom images](https://docs.blaxel.ai/Sandboxes/Templates.md) to create sandboxes with a consistent, customized set of tools, configurations, or entrypoint scripts.” Source↗

Save a disk under a name, then start as many machines from it as you like.

docs-confirmed “Use a saved snapshot as a template: install your tools one time, then start many sandboxes from it.” Source↗

A snapshot is the template: make as many machines from it as you want.

docs-confirmed “Each machine gets its own name, URL, and SSH port, and comes up exactly where the snapshot was taken. Make as many as you want from the same snapshot.” Source↗

Build a snapshot from an image or Dockerfile, then create sandboxes from it.

docs-confirmed “define the base operating system, language runtimes, packages, and project-level setup in an image or Dockerfile, and Daytona builds it into a snapshot you can use to create sandboxes” Source↗

Templates are built from a Dockerfile or from another template.

docs-confirmed “We call this sandbox snapshot a *sandbox template*.” Source↗

Set a machine up once, save it, and start new ones from it.

docs-confirmed “Save a machine once, start new ones from it.” Source↗

There is a fixed catalogue of base templates, and your own saved snapshots act as templates.

docs-confirmed “A snapshot holds the same, and you can restore it after the source sandbox is gone.” Source↗

Images built from a Dockerfile or from code are the template.

docs-confirmed “Since Filesystem Snapshots are [Images](/docs/sdk/py/latest/modal.Image), you can create multiple Sandboxes from the same snapshot.” Source↗

A snapshot is the template every instance starts from.

docs-confirmed “They serve as templates for starting instances.” Source↗

Images can be built from a package list, a Dockerfile, or a public image.

docs-confirmed “**Custom images** from a package list, any public or private image, or a Dockerfile (multi-stage, with versions and tags).” Source↗

A named snapshot starts as many new sandboxes as you want.

docs-confirmed “**Named snapshots** (templates)” Source↗

Images and snapshots are the two starting points for a new sandbox.

docs-confirmed “This means you can snapshot an ephemeral sandbox before it ends, then restore that state into a new sandbox much later.” Source↗

A sandbox boots a managed image, your own image, or a saved snapshot.

docs-confirmed “This microVM boots an Ubuntu 26.04 image, a custom image from VCR, or a saved snapshot.” Source↗

The catch: You can start any number of machines from an image you build, but saving a running machine as a reusable template only works through snapshots, which are in beta, keep files only, and expire after 30 days.

The docs describe a snapshot being restored into the next instance, not starting several machines from one.

docs-confirmed “A Durable Object saves the filesystem of a sandbox as a Container snapshot, stores the snapshot ID, and starts the next instance from the snapshot.” Source↗

No documented way to start a new Sprite from a checkpoint.

inferred “A checkpoint snapshots the writable filesystem overlay” Source↗