Use a remote environment before downloading it.

3.9x smaller. 4.6x less network. 1.4x faster.

One dev environment (Ubuntu, Go, Node, Python and a Go repository with its module cache), stored two ways. Each ran go build ./... on a fresh EC2 host with nothing cached.

As a plain EROFS image, the environment takes 2.38 GB in S3. As a Range artifact, it takes 613 MB. The artifact moves a fifth of the bytes and still finishes first.

Against container lazy loaders on one host with the same build: SOCI took 9.23 s and eStargz with prioritized files 7.59 s and 101 MB. Range took 7.33 s and 89 MB cold, and 2.88 s with a learned profile.

The bars replay the measured time at 3x speed. Measured 23 September 2026 on an m6i.2xlarge in us‑east‑1. Every run was cold. Bytes come from the host network counters. Each value is a median of five.

What you wait for today

A machine that needs a large environment downloads all of it, every time, to use a small part.

CI pulls a whole image to run one test

The next commit pulls it again.

Fifty eval workers pull the same toolchain fifty times

All fifty download it in parallel, from the same bucket.

One changed dependency means a new image

You rebuild it, distribute it and roll it out before any worker can use it.

Range reads only the blocks each machine touches. It records them, and the next machine fetches them before it asks.

Pre-baking is fast until something moves

One dependency added to a Go workspace, then shipped to five fresh EC2 workers in two ways.

The workers boot a 30 GB image with no environment on it. Each one read the new artifact from S3, was ready in 0.48–0.79 s and moved 90 MB. Range's own build took 54.5 s of the 71.4 s, and publishing took 2.2 s.

A changed environment no longer means rebuilt workers.

Time to shell

The public demo, golang:1.23 as a 278 MB artifact, published as a GitHub release asset and as an S3 object. Time to shell is a signal sent from inside the environment just before your command runs.

A cold start moves 6.01 MB in 24 requests. The whole artifact is 278 MB.

Measured 27 September 2026. Laptop rows are medians of three, EC2 rows (m7g.large and m6i.large) medians of five. Your latency will differ. The byte counts will not.

One abstraction, and nothing above it

ReadAt(offset, length) -> bytes. Range does not interpret its bytes, so it works on anything that a byte offset can address.

Reads become range requests

Range caches fixed 1 MiB blocks on local disk. Concurrent reads of one block share one request. Adjacent misses merge, and sequential reads prefetch ahead.

The artifact is compressed, sparse and content-addressed

One object: a 64-byte header, 1 MiB chunks compressed one by one with zstd, and an index. Zero chunks take no space and identical chunks are stored once. Range checks every chunk against its SHA-256 on read. A 2.1 GB environment is a 613 MB file.

A shell is that, with a filesystem on top

artifact -> block device -> read-only EROFS -> writable overlay -> namespaces. The base never changes. Writes stay local, and one artifact serves every machine at once.

It learns the working set

Each session records which blocks it needed, and when. The next session fetches them in the background as the shell starts. A real read always goes first.

Install

A release archive for macOS or Linux, x86-64 or arm64:

$ curl -fsSL https://github.com/andreygrehov/range/releases/latest/download/range_$(uname -s)_$(uname -m).tar.gz | tar -xz

Or from source, with Go 1.25 or newer:

$ git clone https://github.com/andreygrehov/range && cd range && make install

Then build an environment, publish it, and open a shell in it:

$ range build --from-oci golang:1.23 -o go.range
$ range publish go.range s3://<your-bucket>/go.range
$ range shell s3://<your-bucket>/go.range
$ range run s3://<your-bucket>/go.range -- go test ./...

Linux runs environments natively. macOS runs them in a Lima VM that Range creates itself. Windows works through WSL2, untested.