1 Introduction↩︎

Procedural terrain generation underpins the creation of virtual worlds, from open-world games to planetary simulations. For nearly four decades, procedural noise functions such as Perlin noise [1], [2] have defined this field. They offer three properties that make them indispensable for procedural worlds: seamless infinite extensibility, seed-consistency, and constant-time random access. A single random seed can deterministically produce a boundless landscape without storing vast datasets, providing an elegant foundation for procedural worlds.

Yet these procedural methods are inherently limited. Their patterns are smooth and lack the hierarchical organization of real geography. Continents, mountain ranges, and river basins emerge in nature from structured, multi-scale processes that simple noise cannot capture. As a result, worlds built from procedural noise often appear plausible but not real.

Recent advances in generative modeling, particularly diffusion models [3], [4], have transformed image synthesis by learning to reproduce natural structure with remarkable realism and control, but these methods are typically confined to smaller bounded domains. Recent work has explored infinite or large-scale generation capabilities, but these approaches generally lose one or more of the core properties that make procedural noise valuable in interactive applications.

We address these limitations through InfiniteDiffusion, a generalization of MultiDiffusion [5] for infinite inference. Our framework retains the functional utility of noise: seamless infinite extensibility, seed-consistency, and constant-time random access, while leveraging diffusion models for realism far beyond the reach of procedural noise. We first validate InfiniteDiffusion on standard text-to-image models before applying it as the foundation for Terrain Diffusion. We further provide an open-source infinite-tensor framework for constant-memory streaming and composable manipulation of infinite tensors with arbitrary functions.

Finally, we introduce Terrain Diffusion, the first practical learned procedural terrain generator, capable of streaming an entire planet in real time on consumer GPUs. A hierarchical diffusion stack unifies global and local structure through a coarse planetary model that establishes continental structure, refined by higher-resolution models that introduce mountain ranges, valleys, and local relief. A novel elevation encoding further stabilizes training and inference across the full dynamic range of Earth’s terrain, and few-step consistency distillation [6], [7] enables rapid inference.

Together, these components demonstrate that diffusion models can serve as a practical foundation for robust infinite worlds that can be explored interactively and without restrictions.

2 Related Works↩︎

Procedural noise. Procedural terrain traditionally relies on procedural noise such as Perlin or Simplex noise [1], [2], often combined with fractal Brownian motion (fBm) [8]. These methods remain popular for their controllability, speed, seed-consistency, and infinite extent, but they lack the large-scale structure of real landscapes. Procedural noise with fBm can produce fractal-like structures that mimic general mountainous terrain, but requires heavy post-processing to approach realism. Even then, complex features like erosion, rivers, canyons, and volcanoes remain notoriously difficult to generate convincingly, particularly while retaining procedural utility. One Noise to Rule Them All [9] expands on the capabilities of procedural noise by learning to unify existing algorithms, but remains bounded and generally restricted to the distribution of predefined procedural noises. In contrast, InfiniteDiffusion supports arbitrary pixel or voxel-based diffusion models, enabling arbitrary distributions of tensors to be generated and queried like procedural noise.

Diffusion and consistency models. Denoising diffusion models [3], [4] generate samples by iteratively refining noise and are widely used for high-fidelity synthesis. Consistency models [6] approximate denoised diffusion outputs in one or a few steps, and continuous variants [7] achieve throughput competitive with GANs while retaining most of the quality of full diffusion sampling, enabling interactive use cases.

Learned terrain generation. GAN-based terrain models [10]–[14] can generate convincing local relief, but they operate on fixed crops and do not tile, limiting them to bounded worlds. Diffusion-based synthesis [15]–[17] further improves fidelity and control, but also assumes finite canvases and requires relatively significant compute. Jain et al. [18] offers infinite terrain generation by sampling diffusion-based tiles and blending them with a Perlin-based kernel. Tiles are generated independently and the kernel has no awareness of broader context, so structure remains tied to perlin noise rather than the learned model. In contrast, Terrain Diffusion couples all tiles through a shared global context and fuses tiles through a fully learned, context-aware mechanism. Procedural noise is used only for defining continental layouts, where data is sparse and simple enough that more complex alternatives would provide little benefit while reducing user control.

MultiDiffusion and unbounded generation. Several works extend generative models beyond image bounds seen in training. InfinityGAN [19] and TileGAN [20] produce infinite images with GANs but do not extend to diffusion models, limiting scalability. MultiDiffusion [5] and Mixture of Diffusers [21] generate images larger than the training canvas but still assume a bounded final extent. Auto-regressive methods such as BlockFusion [22] and WorldGrow [23] generate worlds by conditioning each tile on its neighbors, producing continuous worlds but without seed consistency, since outputs depend on sampling order. Additionally, tiles must be produced sequentially, preventing efficient random access. In contrast, we define a seed-consistent InfiniteDiffusion algorithm whose outputs are order invariant and allow constant-time random-access generation over an infinite domain.

3 InfiniteDiffusion: Unbounded Generation Across Planetary Scales↩︎

MultiDiffusion [5] provides a simple and effective way to extend diffusion sampling beyond a model’s native resolution by averaging predictions from overlapping windows. This enables synthesis across larger images, as local predictions fuse into a seamless image. However, in its standard form, MultiDiffusion remains confined to bounded domains: all windows must lie within a fixed finite canvas, limiting its applicability to unbounded worlds or continuously streamed environments.

We introduce InfiniteDiffusion, an extension of MultiDiffusion that lifts this constraint. By reformulating the sampling process to operate over an infinite domain, InfiniteDiffusion supports seamless, consistent generation at scale. The remainder of this section reviews the principles of MultiDiffusion, and formalizes its extension to unbounded domains. We present the definitions in \(\mathbb{Z}^2\) for clarity, but all results extend to \(\mathbb{Z}^d\) with minimal modification.

3.1 A Review of MultiDiffusion↩︎

MultiDiffusion extends standard diffusion sampling by averaging overlapping windows, producing consistent outputs from local predictions. Each denoising step aggregates the predictions of overlapping patches, enforcing continuity across window boundaries and allowing generation of regions much larger than a model’s input size. The process begins with a pretrained diffusion model \(\Phi\), operating on images in \(\mathcal{I} = \mathbb{R}^{H \times W \times C}\). The diffusion process generates a sequence of images \[I_T, I_{T-1}, \dots, I_{0} \quad \text{s.t.} \quad I_{t-1} = \Phi(I_t \mid y)\] that refines the original noisy image \(I_T\) into a fully denoised version \(I_0\), under conditioning vector \(y\). MultiDiffusion defines a new model \(\Psi\) that generates in a different image space \(\mathcal{J} = \mathbb{R}^{H' \times W' \times C}\), producing a new sequence of images \[J_T, J_{T-1}, \dots, J_{0} \quad \text{s.t.} \quad J_{t-1} = \Psi(J_t \mid z).\]

To accomplish this, MultiDiffusion defines \(n\) windows indexed by \(i \in [n]\). In the finite setting, a region \(R\) is any rectangular subset of the \(H' \times W'\) coordinate grid, while a window region has a fixed size \(H \times W\). In MultiDiffusion, each window \(i\) is assigned a window region \(R_i\). For an image \(J \in \mathcal{J}\), we write \(J[R]\) for the values of \(J\) on the coordinates in \(R\).

Each window also has a weight matrix \(W_i \in \mathbb{R}^{H \times W}\) that specifies the relative contribution of each pixel in the pretrained diffusion model’s output. Let \(U_i(x)\) denote the \(H' \times W'\) image that places an \(H \times W\) tensor \(x\) in the region \(R_i\) with zeros elsewhere. With these definitions, the closed form MultiDiffusion update for direct pixel or latent-space samples is \[\Psi(J_t \mid z) = \frac{ \sum_{i=1}^{n} U_i(W_i \otimes \Phi(J_t[R_i] \mid y_i)) }{ \sum_{j=1}^{n} U_j(W_j) } \label{eq:multidiff}\tag{1}\] where \(\otimes\) denotes the Hadamard product. This expression represents a weighted average of all local denoising predictions, where each window contributes according to its weight map. The result is a global update that reconciles all overlapping diffusion paths into a single image.

Although MultiDiffusion elegantly unifies local diffusion paths, it remains constrained to bounded domains: the process assumes a finite number of windows and requires the pretrained diffusion model to be evaluated at all windows to complete one step. Extending the same principle to infinite domains therefore requires reformulating \(\Psi\) so that it operates locally and independently of global window layouts, a key step towards the InfiniteDiffusion algorithm introduced next.

3.2 From MultiDiffusion to InfiniteDiffusion↩︎

We now seek to extend MultiDiffusion beyond finite image domains. We first redefine the MultiDiffusion image space as an unbounded image, \(\mathcal{J} = \mathbb{R}^{\mathbb{Z} \times \mathbb{Z} \times C}\), so that generation produces an infinite output. Consequently, we now define a region to be any rectangular subset of \(\mathbb{Z}^2\). Since generation is now over an infinite domain, window indices must now range over a countably infinite set \(S\).

For all applications shown in this work, we take \(S = \mathbb{Z}^2\), so each window is indexed by \((i, j)\), and each window region \(R_{ij}\) is defined as a square sliding window with side length \(H = W\) and stride \(s\) on both axes. \(s\) is typically proportional to \(H\) and \(W\). Concretely, \(R_{ij} = [is,\, is + H) \times [js,\, js + W)\). This particular layout is not essential to the InfiniteDiffusion formulation and serves only as an implementation choice for the experiments.

With an infinite number of windows, the MultiDiffusion update becomes intractable, and computation requires an infinite sum to produce the final image. Instead, we seek to generate the image lazily, by only evaluating particular regions \(R\). To achieve this, we define \(\kappa\) to be the function mapping a region to the set of window indices that overlap it. We assume \(|\kappa(R)|\) is always finite. We provide \(\kappa\) for the sliding-window case in Appendix  12. This enables the InfiniteDiffusion update

\[\Psi(J_t \mid z)[R] = \left( \frac{ \sum_{i \in \kappa(R)} U_i(W_i \otimes \Phi(J_t[R_i] \mid y_i)) }{ \sum_{j \in \kappa(R)} U_j(W_j) } \right)[R], \label{eq:infinidiff}\tag{2}\]

which is the MultiDiffusion update with only the windows intersecting \(R\) evaluated. In the finite setting, the full image \(J_t\) can be generated in advance, making each \(J_t[R_i]\) effectively free. In the infinite setting, precomputing \(J_t\) is impossible, so evaluating \(J_t[R_i]\) requires recursively invoking the same update. A naive implementation would therefore incur exponentially growing compute.

3.3 Practical Querying of InfiniteDiffusion↩︎

To make queries practical, we avoid recomputing the same window updates across recursive calls. Instead, for each image \(J_t\) we maintain two corresponding sparse infinite tensors: \(A_t\), which stores the numerator in Eq.  2 , and \(B_t\), which stores the denominator. When a query \(J_t[R]\) occurs, we identify all the windows required to generate the region, and process all previously unprocessed windows, populating the desired regions of \(A_t\) and \(B_t\). Then \(J_t[R] = A_t[R] / B_t[R]\). Final generation proceeds as a recursive process that begins by sampling \(J_T\) as Gaussian noise. \(J_0[R]\) is obtained by recursively applying the query routine at all earlier steps. In summary, Algorithm  2 below computes \(J_t[R]\) by evaluating only the windows that overlap \(R\), and caching each window’s contribution in \(A_t\) and \(B_t\). The tensors \(A_t\), \(B_t\), and the set of processed windows \(P_t\) are mutated in-place. See Figure  1 for a visualization.

To keep storage bounded, we store each infinite tensor as a set of per-window contributions \((i, x_i)\), where \(x_i = W_i \otimes \Phi(J_{t+1}[R_i] \mid y_i)\) for \(A_t\), and \(x_i=W_i\) for \(B_t\). Evaluating \(\mathcal{T}_t[R]\) accumulates each \(x_i\) with \(i \in \kappa(R)\) into an output buffer. Algorithm 2 guarantees that all required pairs are present before evaluation occurs. This representation supports a lightweight in-memory LRU cache: evicting a pair \((i, x_i)\) is safe as long as \(i\) is simultaneously removed from \(P_t\), causing that window to be treated as unprocessed and recomputed on the next query.

3.4 Tractability via Truncated \(T\)↩︎

There is one final but critical barrier in making InfiniteDiffusion practical. Each query \(J_t[R]\) typically requires a region of \(J_{t+1}\) larger than \(R\) itself, as pixels near the edge of \(R\) are generated by windows that extend beyond \(R\), making large \(T\) prohibitively expensive, particularly for the first query. For traditional MultiDiffusion, which relies on continuously fusing diffusion paths over dozens of steps, this complexity renders infinite generation effectively impossible.

To overcome this, we redefine \(\Phi\) as an arbitrary denoising function, such as a few-step consistency model, or a sequence of standard diffusion steps, rather than a single atomic step. This insight decouples \(T\) from the internal diffusion schedule, which may be much longer. We find that our framework retains coherence even when \(T\) is aggressively truncated. To quantify this, we apply InfiniteDiffusion to a standard text-to-image model: Stable Diffusion.

Table  1 compares the FID of InfiniteDiffusion with \(T=1\) and \(T=2\) to bounded MultiDiffusion (effectively \(T=50\)) on a reference dataset generated with Stable Diffusion across 8 distinct prompts. Fig.  [fig:infinite95diffusion95comparison] shows side-by-side comparisons. \(T=1\) retains overall structure but introduces artifacts in many cases, while \(T=2\) effectively saturates FID and eliminates most artifacts. In Appendix  14, we provide additional samples and runtime comparisons, and show that \(T=5\) eliminates practically all artifacts across every scenario tested, with diminishing overhead for larger regions.

3.5 Properties of InfiniteDiffusion↩︎

Formal proofs for all properties are provided in Appendix  12.

3.5.0.1 Seed consistency.

A central property of InfiniteDiffusion is that the entire infinite output is completely determined by the input seed. Once a seed is fixed, the initial noise \(J_T\) is fully determined. Since every subsequent step is a deterministic function of the previous one, every region \(J_t[R]\) becomes a deterministic function of the seed alone, independent of query order or the status of the cache.

3.5.0.2 Constant-time random access.

Assuming \(|\kappa(R)| \leq M\), with \(M\) depending only on the size of the region, not its location, InfiniteDiffusion guarantees constant-time random access. In particular, for any fixed-size region \(R\), the query \(J_0[R]\) is \(O(1)\), independent of query location or previous evaluations. Combined with seed-consistency, this makes InfiniteDiffusion functionally stateless: any region can be efficiently queried independently, at any time, in any order, and the result is guaranteed to be identical regardless of what has been queried before.

3.5.0.3 Parallelization.

InfiniteDiffusion also admits parallel evaluation of window updates. For any fixed timestep \(t\), each evaluation of \(\Phi\) is independent, so they can be batched and executed in parallel.

3.6 An Open Source Infinite Tensor Framework↩︎

To support the creation, storage, and manipulation of infinite tensors without exceeding memory limits, we introduce the Infinite Tensor framework, a Python library that enables sliding window computation over tensors with infinite dimensions. The framework allows querying of implicitly infinite tensors as if they were standard PyTorch tensors while keeping only the visible region and a bounded transient cache in memory. Each operation is performed through a fixed-sized sliding window that dynamically loads, evicts, or deletes data as sampling progresses. Tiled disk usage is also supported for space-efficient persistent storage. Additional details on this framework are in Appendix  13.

This abstraction lets diffusion and consistency models operate directly on infinite images without manual data management. Windows can overlap to provide context and blend results, and multiple infinite tensors can depend on one another to form hierarchical pipelines. The framework serves as the runtime layer that links local model inference with practical infinite synthesis.

Next, we introduce Terrain Diffusion, which builds on this foundation by combining these capabilities with large-scale real-world training data, hierarchical modeling, and a task-specific architecture.

4 A Global Terrain Dataset↩︎

To enable truly global generation, we construct a seamless global elevation dataset merging land topography from the 90m MERIT DEM [24] and ocean bathymetry from ETOPO1 [25], supplemented by climatic data from WorldClim [26]. We process this data into equal-area tiles by dynamically stretching longitude based on latitude; this ensures that pixel sizes represent a consistent physical area, allowing the diffusion model to learn features with minimal polar distortion. The dataset is split into 2048\(\times\)​2048 tiles, with 80% randomly assigned to the training set, and the reamining 20% left for validation. Specific details on coastline smoothing, bathymetric merging, and sampling heuristics are provided in Appendix  16.

5 Hierarchical Modeling & Stabilization↩︎

This section outlines the hierarchical architecture and data representation underlying our pipeline, which together enable coherent, high-fidelity, and multi-scale terrain generation.

5.1 Signed Square-Root Transform↩︎

Terrain tiles vary significantly in elevation range. Under a fixed noise distribution, this leads to uneven effective SNR: low-relief regions behave as though exposed to stronger noise, while high-relief terrain is affected much less. In the raw elevation space, tiles with higher absolute elevations exhibit larger variance. To reduce this variation, we apply a signed square-root transform \(z \mapsto \mathrm{sign}(z)\sqrt{|z|}\). The transform compresses high-relief values and distributes variance across tiles more uniformly, decreasing the correlation between the mean and log standard deviation of tiles from \(0.66\) to \(0.31\). In practice, this allows us to train with a more focused noise distribution and enhances the visibility of small features, especially coastlines. Additional details in Appendix  17.

5.2 Stabilization Via Laplacian Encodings↩︎

Due to normalization, the large dynamic range of Earth elevations make model errors deceptively large in absolute units. Even relatively small errors of \(\sigma=0.01\) can correspond to \(\pm25\)m noise after denormalization. To mitigate this, we predict a Laplacian-based representation comprising a low-frequency component, obtained by downsampling and blurring the original image, and a residual/high-frequency component given by subtracting the upsampled low frequency component from the original image.

Residual errors are over \(30\times\) smaller in magnitude due to their lower variance. To clean the low-frequency channel after generation, we decode the noisy low- and high-frequency components \((L + H)\) into a provisional heightmap, then downsample and blur it to re-extract a denoised low-frequency \(\hat{L}\), with any high-frequency noise redirected to the residual \(\hat{H}\). Final synthesis uses \(\hat{L} + H\), so low-frequency errors vanish while high-frequency detail is preserved. In practice, \(L \approx \hat{L}\) even under strong synthetic noise, confirming that re-extraction cleanly isolates low-frequency structure. In this work, we downsample \(8\times\) followed by a \(\sigma=5\) blur. Our Laplacian denoising step reduces the FID [27] of the untiled core diffusion model (introduced next) from \(21.51\) to \(8.11\), and the corresponding consistency model, which powers our final pipeline, from \(75.15\) to \(12.72\).

5.3 A Hierarchical Model↩︎

Planetary terrain spans several orders of magnitude in scale, from continental structure to meter-level detail, making one-pass generation infeasible. Several previous works [28]–[32] have shown that MultiDiffusion produces repetitive results when poorly conditioned, a problem that InfiniteDiffusion inherits. We therefore organize generation into a small hierarchy of models operating at progressively finer resolutions. Each stage refines and conditions on the one above, maintaining large-scale coherence while producing realistic local detail. All models share a common EDM2 [33] backbone with the modifications proposed in sCM [7]. The hierarchy begins with a coarse planetary model, which generates the basic structure (23km/pixel) of the world from a rough, procedural or user-provided layout. The next stage is the core latent diffusion model [34], which transforms that rough structure into realistic 46km tiles in latent space. Finally, a consistency decoder expands these latents into a high-fidelity elevation map. All models are trained on random crops to learn a nearly translation-invariant representation, reflecting the fact that generation should be independent of absolute location. We visualize the coarse-to-fine pipeline in Figure  3.

The core latent diffusion model synthesizes \(512 \times 512\) patches at a 90m resolution in signed-sqrt space, corresponding to 46km tiles. It predicts a 64x64 low-frequency elevation channel and latent map that compactly represents the corresponding \(512 \times 512\) image. To supply the latent codes, we train a separate VAE-style autoencoder that shares the same U-Net backbone but omits diffusion-specific components and skip connections. The model is optimized using L1 and LPIPS losses with a weak KL term to prevent overfitting. After training, the encoder processes each 2048×2048 tile in the dataset as a whole, and the resulting latent image is precomputed and stored alongside the tile. To maximize local quality, the imprecise VAE decoder is discarded, and a diffusion decoder learns to expand these latents into realistic and high-resolution residuals. Conditioning in the diffusion decoder is implemented by concatenating nearest-neighbor interpolated latents to the noisy input image at each diffusion step.

To facilitate long-range global coherence, the core model is conditioned on \(4 \times 4\) patches of elevation data. Each pixel of the patch is about 23km, with the model prediction corresponding to the \(2 \times 2\) interior. Each patch contains 3 channels: the mean elevation of the pixel, the 5th percentile elevation of the pixel, and a binary mask indicating which pixels have data available. We also provide the model with the tile’s mean temperature, temperature variation, annual precipitation, and precipitation seasonality for additional coherence and user control. Since climatic data is not available in the ocean, we replace missing values with a standard gaussian, ensuring the model accepts any combination of climatic variables in ocean regions. These values are injected into the model as a flattened vector alongside the noise embedding.

5.4 Real-Time Planetary Scale Synthesis↩︎

The coarse diffusion model facilitates this hierarchy by producing the conditioning variables required by the core latent model. The user provides initial maps for this model using hand-drawn sketches or procedural noise, which we found works as well as purely learned methods while providing additional control. During inference, these inputs are corrupted with gaussian noise according to the user’s preference on a per-channel basis, and concatenated against the usual diffusion inputs. The model follows the EDM2 design but with no downsampling or upsampling operations. This limits the receptive field by design, preventing the model from drifting toward the massive continental structures present in Earth data and avoiding conflicts where global priors override user guidance while still allowing strong local corrections.

To enable real-time streaming, all diffusion models, except the coarse model, are distilled into continuous-time consistency models [7]. To improve fidelity further, we apply the guidance scheme proposed in AutoGuidance [35]. Combined, these stages form a complete generation pipeline, from planetary context to local detail, capable of on-demand, real-time synthesis.

6 Results↩︎

We evaluate Terrain Diffusion’s visual fidelity and latency using a single NVIDIA RTX 3090 Ti. The core consistency model uses two-step generation (stride 32, batch size 16). The coarse and decoder stages use one-step generation (\(T=1\), batch size 1), with the decoder employing size \(512\) windows with stride \(384\). We use a separable linear weight window (decaying from 1 at the center to \(\epsilon\) at the boundary) which improves FID from \(19.32\) to \(14.78\) compared to a constant map.

6.1 Visual Fidelity↩︎

We perform internal ablations to isolate the effects of our proposed architecture. We calculate FID [27] for (1) non-tiled diffusion samples, (2) non-tiled consistency samples, and (3) tiled samples generated with InfiniteDiffusion¹. This isolates base fidelity, the effect of consistency distillation, and the effect of tiling.

We also compare to Perlin blending [18], where tiles are blended with perlin noise, and naive tiling, where tiles are simply concatenated without blending. To investigate the effect of latent blending, we evaluate InfiniteDiffusion with \(T = 1\) and \(T = 2\) (i.e. blending once or twice in the latent space). We also evaluate ‘naive InfiniteDiffusion’ (\(T = 0\)), which combines the typically separate latent model and decoder into a single stage. Table  [tbl:tab:fid] shows our results.

Perlin blending yields a high FID of 186.70, confirming that procedural blending techniques fail to approximate the statistical distribution of natural topography. Naive InfiniteDiffusion, without blending in the latent space, is able to achieve good quality, which we attribute primarily to guidance from the hierarchy preserving structure. InfiniteDiffusion with \(T=1\) closes the fidelity gap with the base model further. Most notably, InfiniteDiffusion with \(T=2\) preserves the fidelity of the base consistency model with remarkable accuracy (14.78 vs. 12.72), successfully maintaining perceptual and spatial continuity, and scaling from finite training crops to infinite worlds with little degradation in quality.

6.2 Qualitative Analysis↩︎

Figure 4 shows 20 1024\(\times\)​1024 tiles from Terrain Diffusion, all from the same seed used for Fig.  [fig:teaser]. The model produces sharp ridges, visually coherent river basins, smooth transitions, and varied landscapes. No visible tiling artifacts confirm the effectiveness of InfiniteDiffusion. See Appendix  11.2 (Fig.  8) for examples of Perlin Blending.

To demonstrate the practical utility of this approach, we integrate Terrain Diffusion into the Minecraft engine by replacing the native world generator. Elevation and biome queries are routed through our model, and climatic outputs are mapped to Minecraft biomes using a lightweight rule set. The system streams terrain in real time and handles arbitrary traversal, with runtime dominated by Minecraft’s own generation logic rather than our model. Figure 5 shows representative in-game terrain. For these interactive visualizations, we apply bilinear interpolation to upsample the heightmaps \(4 \times\).

6.3 Latency: Time to First and Second Tile↩︎

Because generation of any fixed-size region has bounded cost, generating a contiguous n-length strip is \(O(n)\). But neighboring tiles reuse cached context, so the cost for querying the first region is larger than for subsequent regions.

Motivated by these facts, we measure end-to-end latency as the time to first tile (TTFT) and time to second tile (TTST) across resolutions. TTFT denotes the delay from model initialization to the first \(512\times512\) tile becoming available, reflecting initial setup cost or a full cache miss, such as from teleportation. TTST measures the time to generate a neighboring tile thereafter, reflecting a lower bound on interactive exploration performance: performance improves further with more nearby cached tiles. While both metrics are bounded, they vary with the specific region location because the number of intersecting windows differs across positions. To account for this, we perform 1000 runs at random locations and report the average and standard deviation. Our results are reported in Table  3.

With our highest quality configuration, an F-35, one of the fastest conventional aircraft in service at roughly 550 m/s, would traverse a 512×512 tile at 90 m resolution in about 84 seconds. In that time, Terrain Diffusion can produce 130 additional tiles. In a 1:15 miniature world, where a vehicle at highway speeds (60mph) effectively encounters terrain at 405 m/s, the system maintains a 170\(\times\) performance buffer. Even at the theoretical extreme of orbital velocity (\(\approx 7,700\) m/s), generation remains 9\(\times\) faster than traversal.

InfiniteDiffusion with \(T = 1\) is moderately faster than \(T = 2\) in TTFT, but performs similarly in TTST, demonstrating that the effect of larger \(T\) is most impactful for the first query. Naive InfiniteDiffusion performs poorly despite using fewer blending steps, since the decoder must use a stride of 256 instead of 384 to align with the latent model. Independent tiling is about 3x faster than InfiniteDiffusion, roughly aligning with our stride choices of \(50\%\) in the latent model (4x overhead) and \(75\%\) in the decoder (1.78x overhead). A minimal cache (\(\approx\) 10MB) achieves optimal TTFT and TTST performance by only memoizing the windows needed for the previous query, though we typically use a larger cache to achieve superior performance for each additional tile.

7 Discussion↩︎

7.0.0.1 Limitations.

For more ambiguous prompts, InfiniteDiffusion with \(T = 2\) can introduce some artifacts. While a few additional blending steps (\(T=5\)) typically resolves this, this can limit the use of two-step models and adds some overhead, particularly for TTFT. A second limitation is that, unlike point-wise procedural noise, InfiniteDiffusion generates in windows, making queries for significantly smaller regions inefficient if uncached. This primarily impacts scattered point queries, leaving Minecraft features reliant on long-range biome searches (namely /locate biome and explorer maps) unsupported. Finally, while InfiniteDiffusion effectively supports deep cascades of diffusion models, enabling immense scale, acquiring training data at the coarsest layer remains a challenge. Synthetic data offers a promising avenue for many applications, effectively distilling any other model or simulation into an approximate procedural counterpart.

7.0.0.2 As a procedural noise.

Although Terrain Diffusion retains the formal guarantees of procedural noise, it fundamentally diverges in fidelity and computational cost. By leveraging deep generative models, our method captures complex structure that noise functions only approximate as stationary textures. While this comes at the cost of raw throughput compared to the microsecond-level latency of noise, our warmup time of 1.72 seconds and steady-state generation time of 0.66 seconds remain highly practical. Future applications may distill complex but established physical simulations into practical procedural approximations that inherit both the realism of simulation and the functional utility of noise.

8 Future Work↩︎

For Terrain Diffusion, adding features to the hierarchy is a natural next step. Either as outputs, conditioning, or both. The coarse model, the base model, or both could incorporate additional variables such as soil properties, other climatic variables, or satellite imagery, enhancing control and enabling additional downstream applications. The InfiniteDiffusion algorithm could also be applied to additional dimensions, venturing into voxel-based methods for 3D synthesis.

InfiniteDiffusion also scales favorably with cascade depth. Existing approaches to ultra-high-resolution generation face a fundamental trade-off: MultiDiffusion scales exponentially in compute, while cropping-based methods scale linearly but discard context at every step, limiting exploration. InfiniteDiffusion resolves this through lazy evaluation: a user can zoom into any region of an implicitly ultra-high-resolution image while computing only the queried region.

After the first query, further navigation becomes even cheaper. Because panning by \(S\) pixels at the finest layer requires moving only \(S/a\) pixels at the next coarser layer, \(S/a^2\) at the one above, and so on, cached computations at coarser layers remain almost entirely valid between queries. The amortized cost per \(S \times S\) region is therefore \[O(S^2)\left(1 + \frac{1}{a} + \frac{1}{a^2} + \cdots\right) = O(S^2) \cdot \frac{a}{a-1},\] independent of cascade depth, and just \(\frac{4}{3} \approx 1.33\times\) the cost of a single layer for \(4\times\) super-resolution at infinite depth. In other words, adding unlimited resolution to an already infinite world is nearly free.

9 Conclusion↩︎

We have presented InfiniteDiffusion, an algorithm for lazily sampling diffusion models across unbounded domains with seed-consistency and constant-time random-access. We further introduce Terrain Diffusion, a framework for practical learned procedural terrain generation with unprecedented realism. Together, these components position diffusion models as a practical foundation for learned procedural worldbuilding and infinite generation in general.

10 Compute Statement↩︎

Almost all training was performed on an RTX 3090 Ti, and all experiments fit within 24 GB of VRAM. Training the entire pipeline end-to-end takes approximately two weeks on an RTX 3090 Ti, or one week with an RTX 5090.

11 Extended Results And Methodology↩︎

11.1 Additional Qualitative Samples↩︎

In Figure  6, we showcase twenty additional 1024 by 1024 regions from Terrain Diffusion. Samples are uncurated, except for automatically excluding regions with more than 50% ocean in the coarse map. We include additional details on overall elevation range, and climate variables, in the top left of each sample.

11.2 Additional Details on FID Calculations↩︎

FID calculations use raw elevation values, with images normalized by centering each tile and scaling by the larger of its value range or 255, ensuring that images are not expanded beyond the native precision of the data. In Algorithm  9, we provide pseudocode for the normalization scheme used to convert arbitrary elevation values to the 0-255 range required for FID calculation.

For Perlin blending [18], our implementation differs from the reference method, which targets a zero-centered dataset. To ensure a fair comparison, we adapt the algorithm to our data: rather than applying Perlin noise with a static distribution, we employ an adaptive distribution centered on the mean and scaled by the standard deviation of surrounding elevation tiles (weighted by linear interpolation). Figure  8 provides representative samples.

11.3 Decoder FID↩︎

We measure the decoder’s standalone rFID at \(512 \times 512\) resolution. rFID measures FID between original images and their reconstructions. The one step variant obtains an rFID of \(2.83\), while the two step variant reaches \(1.07\). Tiling only increases the one-step FID to \(2.99\).

11.4 Additional Performance Metrics↩︎

In addition to the latency metrics provided in the main text, we also report peak VRAM usage and additional latency metrics for varying region sizes. Our results are in Table  [tab:performance95appendix]. For all performance calculations, we initially compile the models with torch.compile(), and use full-precision inference (fp32), since it provided the best performance. VRAM usage reduces to 1846 MB with half-precision floats. We measure latency end-to-end as observed through the same API exposed to applications, including all system overhead.

11.5 Extended Visual Comparison↩︎

Figure  7 visualizes terrain outputs across decreasing noise levels (T=2 to T=1 to T=0). While differences appear subtle in 2D visualization, each stage shift corresponds to elevation changes of \(\pm100\)m geologically. While all methods produce plausible terrain with no obvious artifacts, which we attribute to our hierarchical architecture, potentially significant differences emerge across timesteps.

12 Formal Properties of InfiniteDiffusion↩︎

For reference, we include the InfiniteDiffusion algorithm from the main text.

12.1 Preliminaries and Notation↩︎

We first make precise the InfiniteDiffusion framework used in the main text.

12.1.0.1 Infinite image space.

Let the spatial domain be the integer lattice \(\mathbb{Z}^d\), and let \[\mathcal{J} \mathrel{\vcenter{:}}= \mathbb{R}^{\mathbb{Z}^d \times C}\] denote the space of infinite images with \(C\) channels. We write \(J \in \mathcal{J}\) as a function \(J : \mathbb{Z}^d \to \mathbb{R}^C\) over pixel coordinates. For the following sections, we write \(\Omega\) as shorthand for the index-set \([H_1] \times \cdots \times [H_d]\).

12.1.0.2 Regions and windows.

A (rectangular) region is any subset of the form \[R = [a_1, b_1) \times \cdots \times [a_d, b_d) \subset \mathbb{Z}^d\] with integers \(a_k < b_k\). The set of window indices is a countable set \(S\) (e.g.\(S = \mathbb{Z}^d\)). For each \(i \in S\) we are given a window region \(R_i \subset \mathbb{Z}^d\), a weight map \(W_i \in \mathbb{R}^{\Omega}\), and a conditioning vector \(y_i\). We assume the window layout is such that for every finite region \(R\), only finitely many windows intersect \(R\):

Assumption 1 (Finite window overlap). For every finite region \(R\), \[\kappa(R) \mathrel{\vcenter{:}}= \{ i \in S \;:\; R_i \cap R \neq \emptyset \}\] is finite.

This assumption is true in the sliding window case. We include the algorithm for computing \(\kappa\) in the sliding window case in Algorithm  11 below.

12.1.0.3 Embedding operator.

For any tensor \(x \in \mathbb{R}^{\Omega \times C}\), the operator \(U_i(x) \in \mathcal{J}\) denotes the infinite image obtained by placing \(x\) on \(R_i\) and zero elsewhere.

12.1.0.4 Pretrained diffusion model.

Let \(\Phi\) denote a fixed pretrained denoising network acting on window-sized images. We formalize it as a deterministic function \[\Phi : \mathbb{R}^{\Omega \times C} \times \mathcal{Y} \to \mathbb{R}^{\Omega \times C},\] where \(\mathcal{Y}\) is the space of conditioning vectors.

12.1.0.5 InfiniteDiffusion update.

For a given noisy image \(J_t \in \mathcal{J}\), the InfiniteDiffusion update at step \(t \to t-1\) is defined, for any finite region \(R\), by \[\Psi(J_t \mid z)[R] = \left( \frac{ \sum_{i \in \kappa(R)} U_i\bigl(W_i \otimes \Phi(J_t[R_i] \mid y_i)\bigr) }{ \sum_{j \in \kappa(R)} U_j(W_j) } \right)[R], \label{eq:infinitediff-formal}\tag{3}\] where \(\otimes\) denotes the Hadamard (elementwise) product and the division is also elementwise. For this update, we adopt the convention that any division by zero is defined to be zero. By Assumption 1, both sums are finite on any finite \(R\), so 3 is well-defined. \(z\) is a (possibly infinite) vector from which the \(y_i\) are computed.

12.1.0.6 Seeds and initial noise.

Let \(\mathcal{X}\) be a set of seeds. A seed \(s \in \mathcal{X}\) deterministically selects an initial infinite noise image \(J_T^{(s)} \in \mathcal{J}\), and a conditioning vector \(z^{(s)} \in \mathcal{Z}\). Formally, there are deterministic functions \[G : \mathcal{X} \times \mathbb{Z}^d \to \mathbb{R}^C, \qquad H : \mathcal{X} \to \mathcal{Z}, \qquad \Lambda: \mathcal{Z} \times S \to \mathcal{Y}\] such that \[J_T^{(s)}(p) = G(s,p), \qquad z^{(s)} = H(s), \qquad y_i^{(s)} = \Lambda(z^{(s)}, i).\]

12.1.0.7 Definition of \(J_t^{(s)}\).

For a fixed seed \(s\), we define the entire trajectory \((J_t^{(s)})_{t=0}^T\) recursively by:

• \(J_T^{(s)}\) is given by \(G\).

• For \(t = T, T-1, \dots, 1\), define \(J_t^{(s)}\) via 3 with \(J_t = J_t^{(s)}\) and \(y_i = y_i^{(s)}\).

Because \(T\) is finite and each update uses only finite sums on any finite region, the infinite images \(J_t^{(s)}\) are well-defined for all \(t \in \{0,\dots,T\}\).

12.1.0.8 Lazy evaluation algorithm.

Algorithm 10 efficiently computes 3 . At level \(t < T\) it maintains infinite images \(A_t, B_t \in \mathcal{J}\) and a processed set \(P_t \subseteq S\). To answer a query \(J_t[R]\), it performs:

For each window \(i \in \kappa(R) \setminus P_t\): \[\begin{align} A_t[R_i] &\gets A_t[R_i] + W_i \otimes \Phi(J_{t+1}[R_i], y_i),\\ B_t[R_i] &\gets B_t[R_i] + W_i. \end{align}\] Add each such \(i\) to \(P_t\). The result is \[J_t[R] = A_t[R] / B_t[R].\]

Where the division is performed elementwise. New windows are evaluated recursively by querying \(J_{t+1}[\cdot]\) in the same way at level \(t+1\), until reaching \(J_T^{(s)}\), which is given by the seed. At intialization, \(A_t = \boldsymbol{0}\), \(B_t = \boldsymbol{0}\), and \(P_t = \emptyset\).

We now formalize and prove the three properties stated in the main text.

12.2 Seed Consistency↩︎

Informally, seed consistency says that once the seed is fixed, every finite region \(J_t[R]\) is a deterministic function of the seed and the region alone, and is independent of the order in which regions are queried.

We show that InfiniteDiffusion, as defined in  3 , is seed-consistent.

Lemma 1 shows that InfiniteDiffusion has a well-defined deterministic output for a fixed seed. We now show that the lazy query algorithm is consistent with this definition, and is therefore also seed-consistent.

We now show that Algorithm  10 is consistent with the formal definition in  3 .

We can now state the main seed consistency result.

Theorem 1 formalizes the informal argument in the main text: once a seed is fixed, the entire trajectory \((J_t^{(s)})_{t=0}^T\) is fully determined, and the lazy querying and caching scheme merely memoizes a deterministic computation without affecting its outcome. In particular, querying regions in different orders or repeating a query for the same region cannot change the result.

12.3 Constant-Time Random Access↩︎

We now formalize the claim that accessing the value on any window-sized region has constant computational cost, independent of the absolute location in the infinite domain. We measure cost in terms of the number of evaluations of \(\Phi\), which dominate runtime in practice. Let \(C_t(R)\) denote the worst-case number of \(\Phi\)-calls required by the lazy algorithm to answer a query for \(J_t[R]\), starting from an empty cache at all timesteps.

Assumption 2 (Uniform overlap bound). There exists a finite constant \(M\) such that \(|\kappa(R_i)| \leq M\) for every window region \(R_i\). In words, each window region overlaps the regions of at most \(M\) windows.

We treat the total number of diffusion steps \(T\) and the window shape as fixed hyperparameters of the model.

For any window index \(i\), Theorem 2 gives a uniform bound \(C_0(R_i) \le K\) on the number of calls to \(\Phi\) needed to answer a query for \(J_0[R_i]\), starting from an empty cache. This bound depends only on \(T\) and \(M\), which are constants, and not on \(i\) or any regions previously processed. In standard algorithmic notation, this means that the time complexity of a query \(J_0[R]\) is \(O(1)\), when \(R\) is a window region. Queries typically cost far less than \(K\), but this is not required for the asymptotic guarantee.

Combined with seed consistency, Theorem  2 formally justifies the claim that users can jump to arbitrary locations in the infinite world and query any window region efficiently, without needing to generate intermediate tiles and without affecting the content of the regions.

12.4 Parallelization↩︎

Finally, we formalize the statement that InfiniteDiffusion admits parallel evaluation of window updates at any fixed timestep.

Recall that, at fixed \(t\) and seed \(s\), the numerator and denominator images for the update \(J_{t+1}^{(s)} \mapsto J_t^{(s)}\) are \[\begin{align} A_t^{(s)} &= \sum_{i \in S} U_i\bigl( W_i \otimes \Phi(J_{t+1}^{(s)}[R_i] \mid y_i^{(s)})\bigr),\\ B_t^{(s)} &= \sum_{i \in S} U_i(W_i), \end{align}\] The updated image is then \[J_t^{(s)} = A_t^{(s)} / B_t^{(s)}.\]

We treat calls to \(\Phi\) as the only expensive operation, and all other operations (additions, multiplications, divisions and updates to \(A_t,B_t\)) as free. In this work, a computation is parallelizable if there exists an algorithm in which all calls to \(\Phi\) can be partitioned into a constant number of rounds so that within each round the calls are independent and can be executed simultaneously.

We first note that, at a fixed timestep, once the inputs \(J_{t+1}^{(s)}[R_i]\) are known, all required model evaluations can be done in parallel.

We now show that answering any finite collection of region queries at any timestep admits a parallel schedule of model evaluations.

Theorem 3 shows that for any fixed seed \(s\), timestep \(t\) and finite collection of regions \(\mathcal{R}\), the recursive computation of \(\{J_t^{(s)}[R] : R \in \mathcal{R}\}\) admits a bounded-depth parallel schedule of diffusion model evaluations. Combined with seed consistency, this formalizes the claim in the main text that all diffusion model evaluations required to serve any finite batch of queries \(J_t^{(s)}[R]\) can be performed in parallel, up to the intrinsic sequential dependence across diffusion steps.

13 The Infinite Tensor Framework↩︎

To support the computational requirements of InfiniteDiffusion, specifically the need for bounded-memory operations on unbounded domains, we developed infinite-tensor. This open-source Python library² abstracts the management of sliding windows, caching, persistence, and dependency chaining, allowing the implementation of diffusion models to remain focused on mathematical operations rather than memory management.

13.1 Core Abstractions↩︎

The framework treats an infinite tensor \(\mathcal{T}\) not as a stored array of data, but as a lazily evaluated, immutable object defined by a deterministic generator function \(f\). For context, we typically store the accumulators \(A_t\) and \(B_t\) from Section 3.3 as one infinite tensor with an extra channel for the weights \(B_t\).

• Infinite Tensors: A tensor is defined by a shape \((S_1, \dots, S_d)\), where any dimension \(S_i\) may be infinite (represented as None). The tensor is backed by a generator function \(f\) rather than raw memory, and also declares a dtype and device.

• Windows: \(f\) operates on fixed-size windows. For a \(k\) dimensional tensor, a window is defined by its size \((W_1, \dots, W_k)\), stride \(s\in \mathbb{Z}^k\), and offset \(o \in \mathbb{Z}^k\).

• TileStore: Each tensor is backed by a TileStore, which handles caching and storage. Repeated access to the same spatial region reuses cached results rather than re-triggering computation, and dependencies between tensors are tracked automatically. The framework defaults to an in-memory MemoryTileStore.

13.2 Caching and Persistence↩︎

The framework exposes two storage backends.

13.2.0.1 In-memory caching (Default)

This backend stores computed windows in a shared LRU (Least Recently Used) cache. Conceptually, if \(\mathcal{T}[R_i] \gets \mathcal{T}[R_i] + x\) for each processed window region \(R_i\), then a requested region \(\mathcal{T}[R]\) is reconstructed from the cached window outputs intersecting \(R\). Users may bound memory usage directly, for example by specifying a cache-size limit in bytes or in number of windows. This mode is appropriate for transient inference where persistent storage is undesirable. This mode is used in all applications in the main text.

13.2.0.2 Persistent tiled storage (Optional)

This backend accumulates overlapping window outputs into fixed-size storage tiles in a user-provided storage device. Compared with storing each window independently, this uses storage more efficiently because overlapping regions share the same underlying tiles. This mode is appropriate for long-running workflows where results should persist across sessions. A default implementation is provided for HDF5.

13.3 Dependency Chaining and DAGs↩︎

The framework supports the construction of directed acyclic graphs (DAGs) of infinite tensors. A tensor \(\mathcal{T}_{child}\) can declare a dependency on \(\mathcal{T}_{parent}\). When a region of \(\mathcal{T}_{child}\) is requested: 1. The framework calculates the required covering region of \(\mathcal{T}_{parent}\). 2. The parent region is fetched (triggering upstream generation if necessary). 3. The parent data is sliced and passed to the child’s generator function \(f\).

This allows for the construction of complex hierarchical pipelines (e.g., Coarse Model \(\rightarrow\) Latent Model \(\rightarrow\) Decoder) where each stage is an infinite tensor depending on the previous one.

14 Additional Panorama Details↩︎

14.1 Methodology of Table 1↩︎

We provide representative samples of both InfiniteDiffusion and MultiDiffusion on various prompts applied to Stable Diffusion in Table 1 in the main text. FID is calculated by first generating 2000 images with Stable Diffusion for 8 prompts, resulting in 16000 total reference images. We first generate a second version of this dataset in the exact same way, and calculate the FID on both versions. This produces the Stable Diffusion baseline FID. We calculate the MultiDiffusion FID by generating 16000 \(512 \times 2048\) panoramas with the same prompts, and choose random \(512 \times 512\) crops. For InfiniteDiffusion, we draw the random crops from an infinite panorama, also from random \(512 \times 512\) regions, with widths entirely in the range [0, 2048]. For both InfiniteDiffusion and MultiDiffusion, we use a linear kernel, and a stride of 32 (out of 64). MultiDiffusion blends tiles after every iteration, while InfiniteDiffusion with \(T = 2\) uses just one intermediate blending step at \(t_{inter} = 800\) (from 1-999), which we found worked well, though we did not perform a complete ablation. InfiniteDiffusion with \(T = 1\) performs blending in the latent space only after generation. InfiniteDiffusion also tiles the decoder with a stride of 384 (out of 512), while MultiDiffusion simply decodes the entire panorama simultaneously.

We use the following 8 prompts:

1. A photo of a city skyline at night

2. A photo of the dolomites

3. A photo of lush forest with a babbling brook

4. A photo of a forest with a misty fog

5. A photo of mountain range at twilight

6. Cartoon panorama of spring summer beautiful nature

7. A photo of a snowy mountain peak with skiers

8. Natural landscape in anime style illustration

14.2 Additional Samples↩︎

In Figure 15 (c) through Figure 17 we include uncurated samples of Stable Diffusion panoramas created using MultiDiffusion and InfiniteDiffusion with \(T=1\), \(T=2\), and \(T=5\). We find that \(T=1\) or \(T=2\) are sufficient for many tasks, while \(T=5\) resolves practically all artifacts in every case we tested. Generally, InfiniteDiffusion with minimal \(T\) seems to work best for the same types of images where MultiDiffusion itself consistently produces high quality outputs.

We used the same prompts as the FID computation. For \(T=5\) we blend 4 times at (\(400\), \(600\), \(750\), \(900\)). Both methods use DDIM with 50 sampling steps. We did not perform an exhaustive search for blending timesteps; these values were chosen qualitatively.

14.3 Performance for T↩︎

We also investigate how compute scales with \(T\). For \(T=1,2,5\), we measure the number of diffusion steps required to process an \(ns \times ns\) region (2D) and an \(ns \times 1\) region (1D), where \(s\) is the window size and stride is 50%. Each window’s cost is weighted by its fraction of the diffusion schedule. For example, a window starting at \(t=1000\) and blended at \(t=800\) accounts for 20% of the schedule. Results are shown in Tables 12 and 13. \(T=2\) adds minimal overhead over \(T=1\), while \(T=5\) is more costly but remains manageable.

Unlike MultiDiffusion, InfiniteDiffusion supports an infinite window layout. Measured on an RTX 3090 Ti, this incurs a fixed initialization overhead of 8s on the first query, regardless of region size, due to windows straddling the query boundary. Subsequent queries are cost-comparable to MultiDiffusion (e.g. 14s for a 512×2048 panorama). For reference, Stable Diffusion takes 2.5s per image.

15 Additional Implementation Details↩︎

An overview of our architecture with hyperparameters is provided in Table  ¿tbl:tab:hyperparameters?.

The generative components of Terrain Diffusion are built upon the EDM2 architecture [33]. We modify the base architecture, following sCM  [7], by implementing pixel-norm on embedding vectors and substituting Fourier embeddings with Positional embeddings. To incorporate auxiliary conditioning, we utilize a magnitude-preserving linear layer to project flattened conditioning inputs

15.0.0.1 Fidelity Optimization.

For both the core latent and decoder models, we optimize fidelity using AutoGuidance [35]. Hyperparameter sweeps are conducted via Optuna, minimizing Kernel Inception Distance (KID) [36] calculated over 1,000 samples. We terminate the sweeps after 300 runs, or once KID improvement saturates.

15.0.0.2 Consistency Distillation.

The core latent model and decoder are distilled into continuous-time consistency models (sCM). We perform post-hoc sweeps for the EMA parameter (\(\sigma_{\text{rel}}\)) and the optimal stopping iteration. This prevents fidelity degradation observed during late-stage training.

15.0.0.3 Training Speed

The entire pipeline can be trained from scratch on a top-tier consumer-grade GPU (e.g., RTX 5090) in approximately one week, enabling practical retraining on custom datasets. If the decoder is reused, fine tuning the base model can be completed in about a day.

4pt

16 Dataset Details↩︎

Our dataset combines multiple global sources to provide consistent coverage of both land and ocean. Land elevations are drawn from the 3-arc-second MERIT DEM [24], while ocean bathymetry is taken from the 30-arc-second ETOPO dataset [25]. Since ETOPO’s resolution is lower, it is blurred and upsampled to match MERIT’s resolution before merging. To ensure smooth coastal transitions, we measure the distance of each ocean pixel from the nearest coastline and linearly interpolate elevation from 0 m at the shore to the local ocean depth 100 pixels offshore. To support climatic conditioning, we supplement elevation with 30-arc-second WorldClim [26] data for temperature and precipitation.

For efficient processing, data is downloaded and stored in contiguous \(2048\times2048\) tiles, each covering equal surface area at approximately 90m resolution. To maintain uniform ground resolution, tiles are stretched in longitude so that each pixel represents roughly the same area regardless of latitude. This equal-area tiling ensures consistent scale across training and allows all models to train on data without distortion. We also exclude tiles beyond 60 (absolute) degrees of latitude to focus on higher quality data at mid latitudes. Finally, 80% of the tiles are randomly assigned to the train set, and the remainder are withheld for validation.

All models are trained on random crops drawn from random tiles, with sampling biased so that 99% of tiles contain at least 1% land, as ocean regions are simpler and lower priority. Each crop is randomly flipped and rotated in 90 degree increments to reflect our goal of generating infinite, directionless terrain. We include scripts for reproducing the dataset in our open-source repository.

17 Signed Square-Root Transform↩︎

The signed square-root transform applies the function \[f(x)= \text{sign}(x)\sqrt{|x|}\] to each pixel of the dataset. After inference, we undo this operation with \[f^{-1}(x) = \text{sign}(x)x^2.\] The statistical effects of this transform are visualized in Figure  14.

References↩︎