Switzerland in Minecraft: the open data pipeline

⏱️ Reading time: 16 min

A real mountain 4,634 meters tall doesn’t fit in Minecraft by default: the game cuts every block column off at the 256 it ships with out of the box. A Swiss study solved that limit to fit the entire country, 41,285 km², inside the game at 1:1 scale, one block per meter of terrain, using nothing more than open geospatial data published by the federal mapping agency.

📑 En este artículo

1. TL;DR
2. What is open geospatial data?
3. Why public geodata matters in a playable project
4. How the pipeline works: from GeoTIFF to block
   1. The input: a digital elevation model
   2. The 1:1 scale and why it simplifies everything
   3. From Swiss coordinates to Minecraft coordinates
   4. The height limit, and how Cubic Chunks breaks it
5. Practical examples: from elevation to blocks
6. Getting started: replicating the pipeline with open tools
7. Real-world use cases
8. Common mistakes and best practices
9. Tool comparison for bringing geodata into a voxel world
10. Deep Dive: what changes under the hood when the world is cubic
11. Frequently Asked Questions
    1. What open geospatial data does the Switzerland-in-Minecraft project use?
    2. Can any country replicate this pipeline with its own public geodata?
    3. Why does Minecraft need a mod instead of just generating a normal map?
    4. What hardware is needed to load an entire country with open geographic data?
    5. What happens at the edges of the area when the official DEM is missing?
    6. Is it legal to sell a product built on open geographic data?
12. References

The result is called Blocks, and behind it is a replicable pipeline: take a public elevation model, convert it into a height map, and generate it as a voxel world with a mod that removes the 256 block ceiling. This article breaks down that pipeline step by step with open source tools.

TL;DR

• Cubic Chunks removes Minecraft’s 256 block limit so a 4,634 m mountain fits entirely
• GDAL and rasterio convert an elevation GeoTIFF into a 16-bit heightmap ready for WorldPainter
• The 1:1 scale (one block, one meter) avoids any unit conversion between the geodata and the block
• swisstopo’s LV95 coordinates translate to blocks with an origin subtraction, with no reprojection needed
• The same pipeline works with any public geodata catalog that publishes a DEM in an open format

What is open geospatial data?

Open geospatial data consists of georeferenced information sets (elevation, aerial imagery, administrative boundaries, hydrography) that a government or public body releases under a free reuse license, with no payment or registration required, usually in standard formats like GeoTIFF, Shapefile, or GeoPackage.

In Switzerland that role is filled by swisstopo, the federal topography office, through its portal data.geo.admin.ch. It hosts the swissALTI3D elevation model, the SWISSIMAGE orthophoto, the swissBOUNDARIES3D boundaries, and the swissNAMES3D place names, all downloadable without requesting special permission.

The same thing exists in other countries under different names: the IGN in France, INEGI in Mexico, the national geographic institutes across much of Latin America, or the USGS’s 3DEP program in the United States. The pipeline in this article doesn’t depend on which agency publishes the data, it depends on the format being open.

The license matters as much as the format. swisstopo publishes its catalog under open use terms equivalent to free attribution: there’s no need to request authorization to use it in a commercial project like this one, just cite the source. That combination of standard format plus unrestricted license is what makes the pipeline reproducible outside Switzerland.

Why public geodata matters in a playable project

Rebuilding a country in Minecraft doesn’t teach anything new about cartography, but it does demonstrate something almost nobody tests in practice: that data published by a state agency for land registry or planning purposes can serve, without asking permission or paying a license, a product completely different from the one that motivated its publication.

For a mapping agency, publishing data under an open license isn’t a symbolic gesture: it means third parties (companies, universities, hobbyists) build products the agency never would have budgeted for, from mountain route apps to, in this case, a Minecraft world sold by subscription.

Denmark did something similar more than a decade ago, when its geodata agency rebuilt the entire country in Minecraft from its own open catalog. A decade later, the availability of high-resolution elevation models and mods that overcome the game’s original limitations makes the same exercise far more faithful to the real terrain.

That’s why this project matters as a case study: it shows how open geospatial data ends up, without insurmountable legal or technical friction, turned into a world anyone can walk through.

How the pipeline works: from GeoTIFF to block

The full pipeline has four fixed steps: download the geodata, process it into a format the game engine understands, generate the world, and decide when that world actually gets built. None of the four depend on the country being Switzerland: the data source changes, not the logic.

The input: a digital elevation model

The heart of the pipeline is an elevation raster: a grid where each cell stores the terrain height in meters above sea level. swissALTI3D covers the entire territory with resolution of up to 0.5 meters in populated areas and 2 meters in alpine zones, published as a GeoTIFF downloadable by region from swisstopo.

That file has no texture or color, only numbers. The texture arrives separately, from SWISSIMAGE, the aerial photography mosaic that swisstopo updates every three years and that the pipeline uses to paint each block with the actual color of the terrain it represents.

The 1:1 scale and why it simplifies everything

Minecraft already solves part of the problem without the author having to invent anything: its smallest unit, the block, measures one cubic meter. That means a DEM in meters translates directly to blocks with no scale factor at all: a cell that reads 2,300 in the raster becomes a terrain column 2,300 blocks tall, with no odd rounding or conversion tables.

import rasterio
import numpy as np

with rasterio.open("swissalti3d_sector.tif") as src:
    elevacion = src.read(1)  # meters above sea level, one value per cell

altura_bloques = np.round(elevacion).astype(np.int32)
print(altura_bloques.max())

With a sector that includes the Dufourspitze, this script prints 4634: the raster’s maximum height value is already, directly, the number of blocks that column needs in the world.

From Swiss coordinates to Minecraft coordinates

swisstopo publishes its data in the LV95 reference system (EPSG:2056), where each point has an easting and a northing measured in meters from a fixed origin. Since Minecraft also uses integer coordinates in meters (X and Z), the conversion is a subtraction, not a reprojection.

def lv95_a_minecraft(este, norte, origen_este=2485000, origen_norte=1075000):
    bloque_x = int(este - origen_este)
    bloque_z = int(origen_norte - norte)  # Z increases southward, LV95-northing increases northward
    return bloque_x, bloque_z

print(lv95_a_minecraft(2600000, 1200000))

The function returns (115000, -125000): those two subtractions are all it takes to go from a Swiss geographic point to a block coordinate, with no projection matrices or heavy geospatial libraries.

The height limit, and how Cubic Chunks breaks it

Vanilla Minecraft divides the world into 16×16 block columns that, up through version 1.17, topped out at a height of 256. A 4,634 meter mountain doesn’t fit there, it gets cut to less than a sixth of its real height. Cubic Chunks solves this by changing the generation unit: instead of one continuous column, the world is built from independent 16x16x16 cubes stacked with no ceiling.

flowchart LR
    A["Open data portal (swisstopo)"] --> B["swissALTI3D elevation model (GeoTIFF)"]
    A --> C["SWISSIMAGE orthophoto"]
    A --> D["Hydrography and glaciers (vector)"]
    B --> E["GDAL and rasterio processing"]
    C --> E
    D --> E
    E --> F["Heightmap and per-block texture"]
    F --> G["Cubic Chunks world generator"]
    G --> H["Explorable voxel world in Minecraft"]

flowchart TD
    A["Vanilla Minecraft column"] --> B["Fixed ceiling: 256 blocks (0 to 255)"]
    C["Cubic Chunks column"] --> D["16x16x16 cubes stacked with no ceiling"]
    B --> E["The Dufourspitze (4634 m) doesn't fit entirely"]
    D --> F["The Dufourspitze mapped to 4634 full blocks"]

Practical examples: from elevation to blocks

The same principle applies to texture. SWISSIMAGE provides a pixel at 10 centimeters of resolution; the pipeline resamples it to one pixel per block (one meter) and looks, for each RGB color, for the Minecraft block whose average color most closely matches it.

paleta = {
    (85, 107, 47): "minecraft:grass_block",
    (139, 137, 137): "minecraft:stone",
    (240, 240, 245): "minecraft:snow_block",
    (70, 130, 180): "minecraft:water",
}

def distancia(c1, c2):
    return sum((a - b) ** 2 for a, b in zip(c1, c2))

def bloque_mas_cercano(rgb):
    mejor = min(paleta, key=lambda c: distancia(c, rgb))
    return paleta[mejor]

print(bloque_mas_cercano((72, 128, 183)))

For a bluish pixel like (72, 128, 183), the result is minecraft:water: the palette only needs a handful of reference colors to cover terrain, rock, snow, and water with acceptable accuracy at the distance Minecraft is played.

The edges between forest, rock, and snow are rarely a clean cut in reality, and they shouldn’t be in the generated world either. A common practice is blending altitude (more snow the higher up) with the orthophoto’s actual color instead of relying on a single criterion: that way a retreating glacier, where the aerial photo already shows bare rock under what the old map marked as ice, gets drawn with the current color instead of the outdated data.

Lakes, rivers, and glaciers don’t come from the elevation model but from separate vector layers: polygons that define where there’s water or ice. The pipeline uses them to decide, column by column, whether that position gets filled with minecraft:water, with minecraft:ice, or with the solid terrain the elevation indicates.

Getting started: replicating the pipeline with open tools

This doesn’t reproduce the full world of Switzerland, that 24 GB package is a closed product, but it does reproduce the same technical pipeline applied to any slice with open data. Dependencies before starting: Java 8 for Minecraft Forge 1.12.2, Python 3 with rasterio and numpy, GDAL, and the Forge installer.

1. Install GDAL on Windows with winget install OSGeo.GDAL. On macOS: brew install gdal. On Linux (Debian/Ubuntu): sudo apt install gdal-bin.
2. Download a GeoTIFF elevation model clip from your country’s open viewer; for Switzerland, the swisstopo viewer lets you clip swissALTI3D by region.
3. Convert the GeoTIFF to a 16-bit heightmap:

   gdal_translate -ot UInt16 -scale 0 4634 0 65535 -of PNG dem_recorte.tif heightmap.png

   Expected output: Input file size is 2000, 2000 followed by 0...10...20...30...40...50...60...70...80...90...100 - done., and two new files, heightmap.png and heightmap.png.aux.xml, in the same folder.
4. Import heightmap.png into WorldPainter (File > Import > Height map), setting the scale to one block per meter.
5. Install Minecraft Forge 1.12.2 and copy the Cubic Chunks .jar into the mods folder; without this step the world exported by WorldPainter stays capped at 256 blocks just like a vanilla one.
6. Open the world with the Forge profile active and confirm that cubic generation is enabled (see the Deep Dive section).

Real-world use cases

Beyond this specific project, the same pattern (open DEM plus heightmap plus a world engine with no height limit) shows up in evacuation simulators, educational visualizations of glacier retreat, and city digital twins that use Minecraft: Education Edition as an accessible interface for students with no GIS training.

A flood hydrology model and a playable Minecraft world literally start from the same file: an elevation grid that shows where water runs. The difference lies in what each system does with that grid, not in the source data, which explains why a mapping agency’s open geodata infrastructure ends up reused in domains nobody anticipated when designing the catalog.

Common mistakes and best practices

The list of typical failures repeats in almost any attempt to bring real geodata into a game engine, not just this project:

• Mixing datums without noticing: a DEM in LV95 and a vector layer in WGS84 produce lakes shifted several meters from the real terrain; reproject everything to a single system before cross-referencing layers.
• 8-bit heightmap: an 8-bit PNG only stores 256 height values, not enough for a range of 0 to 4,634 meters; always use 16 bits.
• Underestimating RAM: generating terrain on demand, as this project does, requires memory available at the exact moment a player enters a new region, not just when loading the world.
• Ignoring the edge of the clip: outside the area covered by the national DEM, any viewer falls back to a lower-resolution global model, and the terrain noticeably flattens out in that strip.

⚠️ Heads up: the Swiss project itself documents that its full package needs 16 GB of RAM because the world is built while you walk, not all at once; a small clip (like the 2,400 km² UNESCO area) is the right way to test the pipeline before scaling it to an entire country.

Tool comparison for bringing geodata into a voxel world

Deep Dive: what changes under the hood when the world is cubic

A vanilla Minecraft world stores terrain in Anvil format: a region of 32×32 columns, each with 16 vertical sections of 16x16x16 blocks, up to a fixed height of 256 (or 384 in recent versions). Cubic Chunks replaces that structure with its own format where each 16x16x16 cube is an independent unit that can exist at any Y coordinate, positive or negative, without the rest of the column needing to exist.

That has a direct consequence on how the world is generated: instead of computing a full column the first time someone approaches, the engine only generates the cubes near the player in all three dimensions, not just X and Z. That’s the same reason the Swiss project warns that the world is built while you play: every time someone walks toward a valley nobody has visited before, the engine has to read that area’s heightmap and generate the cubes in real time.

sequenceDiagram
    participant J as Player
    participant M as Minecraft
    participant W as Preprocessed world package
    J->>M: moves toward a new region
    M->>W: requests the blocks for that column
    W-->>M: responds with heights and textures from the heightmap
    M-->>J: renders the newly generated terrain
    Note over M,W: generation happens on demand, not all at once

💡 Tip: before cross-referencing an elevation model with a vector layer (boundaries, hydrography), confirm both declare the same EPSG in their metadata; gdalinfo archivo.tif prints it on the first screen of output.

Confirming cubic generation is active is simple: with Cubic Chunks installed, descending in creative mode below Y=0 (or ascending well above Y=256) without hitting an invisible limit confirms the world stopped using fixed columns. In a vanilla world, that same attempt gets cut off abruptly at the world’s edge ceiling or floor blocks.

The boundary between the area covered by the official DEM and the rest of the planet is, in practice, the most fragile point in the pipeline: where swisstopo stops having authority, the terrain comes from another source, usually a lower-detail global model like Copernicus GLO-30, which gives one point every 30 meters instead of every half meter. The resolution jump is noticeable: the terrain flattens out abruptly as soon as the administrative boundary is crossed.

Your next step: download a 2×2 km clip of your own national elevation model in GeoTIFF and run this article’s gdal_translate -ot UInt16 -scale command to see your first 16-bit heightmap in under five minutes.

Frequently Asked Questions

What open geospatial data does the Switzerland-in-Minecraft project use?

It uses the swissALTI3D elevation model, the SWISSIMAGE orthophoto, the swissBOUNDARIES3D administrative boundaries, and the swissNAMES3D place names, all four published by swisstopo on its data.geo.admin.ch portal.

Can any country replicate this pipeline with its own public geodata?

Yes, as long as an elevation model exists in an open format like GeoTIFF: processing with GDAL, importing into WorldPainter, and generating with Cubic Chunks don’t depend on which agency published the data.

Why does Minecraft need a mod instead of just generating a normal map?

Because the vanilla world format fixes each column’s height at 256 blocks (320 in recent versions); a real mountain range exceeds that limit several times over, and only a mod like Cubic Chunks changes the world’s internal structure to allow it.

What hardware is needed to load an entire country with open geographic data?

The Swiss project documents having tested its full package on a PC with 32 GB of RAM and on a MacBook Pro with 64 GB, and recommends a minimum of 16 GB because the terrain is generated while exploring, not all at once when loading the world.

What happens at the edges of the area when the official DEM is missing?

The terrain starts coming from a lower-resolution global model, like Copernicus GLO-30, with one point every 30 meters, so the relief looks noticeably flatter as soon as you cross the boundary of the area covered by the national catalog.

Is it legal to sell a product built on open geographic data?

Yes, as long as the source’s attribution license is respected: swisstopo allows commercial use of its open catalog, and the Blocks project itself charges for downloadable access even though the underlying data is free, which is common in products built on public geodata.

References

• blocks.manifold3d.ch: project page for the rebuild of all of Switzerland in Minecraft at 1:1 scale.
• swisstopo: Swiss federal topography office, source of the elevation models and orthophotos used in the pipeline.
• data.geo.admin.ch: official download portal for the Swiss government’s open geodata.
• WorldPainter: open source Minecraft world editor with direct height map import.
• GDAL: open source library for reading, converting, and reprojecting raster and vector geospatial data.

📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Featured image: Foto de Yifu Wu en Unsplash