diff --git a/.run/basemap-dem.run.xml b/.run/basemap-dem.run.xml
new file mode 100644
index 000000000..0b345455d
--- /dev/null
+++ b/.run/basemap-dem.run.xml
@@ -0,0 +1,17 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="basemap-dem" type="Application" factoryName="Application">
+    <option name="MAIN_CLASS_NAME" value="org.apache.baremaps.cli.Baremaps" />
+    <module name="baremaps-cli" />
+    <option name="PROGRAM_PARAMETERS" value="dem serve --path $USER_HOME$/Downloads/gebco_2024.tif" />
+    <projectPathOnTarget name="projectPathOnTarget" value="/app" />
+    <target name="@@@LOCAL@@@" />
+    <extension name="software.aws.toolkits.jetbrains.core.execution.JavaAwsConnectionExtension">
+      <option name="credential" />
+      <option name="region" />
+      <option name="useCurrentConnection" value="false" />
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/baremaps-cli/pom.xml b/baremaps-cli/pom.xml
index 7003b2c62..825f6248f 100644
--- a/baremaps-cli/pom.xml
+++ b/baremaps-cli/pom.xml
@@ -43,6 +43,10 @@ limitations under the License.
       <groupId>org.apache.baremaps</groupId>
       <artifactId>baremaps-core</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.baremaps</groupId>
+      <artifactId>baremaps-dem</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.apache.baremaps</groupId>
       <artifactId>baremaps-server</artifactId>
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/Baremaps.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/Baremaps.java
index 3a0aee76e..abe4dfee0 100644
--- a/baremaps-cli/src/main/java/org/apache/baremaps/cli/Baremaps.java
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/Baremaps.java
@@ -25,6 +25,7 @@
 import java.util.concurrent.Callable;
 import org.apache.baremaps.cli.Baremaps.VersionProvider;
 import org.apache.baremaps.cli.database.Database;
+import org.apache.baremaps.cli.dem.DEM;
 import org.apache.baremaps.cli.geocoder.Geocoder;
 import org.apache.baremaps.cli.iploc.IpLoc;
 import org.apache.baremaps.cli.map.Map;
@@ -42,7 +43,14 @@
     name = "baremaps",
     description = "A toolkit for producing vector tiles.",
     versionProvider = VersionProvider.class,
-    subcommands = {Workflow.class, Database.class, Map.class, Geocoder.class, IpLoc.class},
+    subcommands = {
+        Workflow.class,
+        Database.class,
+        Map.class,
+        Geocoder.class,
+        IpLoc.class,
+        DEM.class
+    },
     sortOptions = false)
 @SuppressWarnings("squid:S106")
 public class Baremaps implements Callable<Integer> {
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/DEM.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/DEM.java
new file mode 100644
index 000000000..25373ecf4
--- /dev/null
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/DEM.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.cli.dem;
+
+
+
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+
+/**
+ * A command group that contains commands for processing digital elevation models (DEMs).
+ */
+@Command(name = "dem", description = "Digital Elevation Models (DEMs) processing",
+    subcommands = {
+        Serve.class,
+        VectorTileContours.class
+    },
+    sortOptions = false)
+@SuppressWarnings("squid:S106")
+public class DEM implements Runnable {
+
+  @Override
+  public void run() {
+    CommandLine.usage(this, System.out);
+  }
+}
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/Serve.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/Serve.java
new file mode 100644
index 000000000..91d27f089
--- /dev/null
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/Serve.java
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.cli.dem;
+
+import static org.apache.baremaps.utils.ObjectMapperUtils.objectMapper;
+
+import com.linecorp.armeria.common.*;
+import com.linecorp.armeria.server.Server;
+import com.linecorp.armeria.server.annotation.JacksonResponseConverterFunction;
+import com.linecorp.armeria.server.cors.CorsService;
+import com.linecorp.armeria.server.docs.DocService;
+import com.linecorp.armeria.server.file.HttpFile;
+import java.nio.file.Path;
+import java.util.concurrent.Callable;
+import org.apache.baremaps.dem.ElevationUtils;
+import org.apache.baremaps.server.BufferedImageResource;
+import org.apache.baremaps.server.VectorTileResource;
+import org.apache.baremaps.tilestore.raster.*;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+
+/**
+ * A command that starts a tile server to preview elevation data. The server serves raster tiles for
+ * elevation and hillshade data, and vector tiles for contour and hillshade data.
+ */
+@Command(name = "serve", description = "Start a tile server to preview elevation data.")
+public class Serve implements Callable<Integer> {
+
+  @Option(names = {"--host"}, paramLabel = "HOST", description = "The host of the server.")
+  private String host = "localhost";
+
+  @Option(names = {"--port"}, paramLabel = "PORT", description = "The port of the server.")
+  private int port = 9000;
+
+  @Option(names = {"--path"}, paramLabel = "PATH",
+      description = "The path of a digital elevation model (DEM) file in the geotiff format.")
+  private Path path;
+
+  @Override
+  public Integer call() throws Exception {
+    // Initialize the tile stores
+    var geoTiffReader = new GeoTiffReader(path);
+    var rasterElevationTileStore = new TerrariumTileStore(geoTiffReader);
+    var rasterHillshadeTileStore =
+        new RasterHillshadeTileStore(
+            geoTiffReader,
+            ElevationUtils::terrariumToElevation);
+    var vectorHillshadeTileStore =
+        new VectorHillshadeTileStore(
+            geoTiffReader);
+    var vectorContourTileStore =
+        new VectorContourTileStore(geoTiffReader);
+
+    // Initialize the server
+    var objectMapper = objectMapper();
+    var jsonResponseConverter = new JacksonResponseConverterFunction(objectMapper);
+    var serverBuilder = Server.builder();
+    serverBuilder.http(port);
+
+    // Register the services
+    serverBuilder.annotatedService(
+        "/raster/elevation",
+        new BufferedImageResource(() -> rasterElevationTileStore),
+        jsonResponseConverter);
+    serverBuilder.annotatedService(
+        "/raster/hillshade",
+        new BufferedImageResource(() -> rasterHillshadeTileStore),
+        jsonResponseConverter);
+    serverBuilder.annotatedService(
+        "/vector/contour",
+        new VectorTileResource(() -> vectorContourTileStore),
+        jsonResponseConverter);
+    serverBuilder.annotatedService(
+        "/vector/hillshade",
+        new VectorTileResource(() -> vectorHillshadeTileStore),
+        jsonResponseConverter);
+
+    var index = HttpFile.of(ClassLoader.getSystemClassLoader(), "/dem/index.html");
+    serverBuilder.service("/", index.asService());
+
+    serverBuilder.decorator(CorsService.builderForAnyOrigin()
+        .allowAllRequestHeaders(true)
+        .allowRequestMethods(
+            HttpMethod.GET,
+            HttpMethod.POST,
+            HttpMethod.PUT,
+            HttpMethod.DELETE,
+            HttpMethod.OPTIONS,
+            HttpMethod.HEAD)
+        .allowCredentials()
+        .exposeHeaders(HttpHeaderNames.LOCATION)
+        .newDecorator());
+
+    serverBuilder.serviceUnder("/docs", new DocService());
+
+    serverBuilder.disableServerHeader();
+    serverBuilder.disableDateHeader();
+    var server = serverBuilder.build();
+
+    var startFuture = server.start();
+    startFuture.join();
+
+    var shutdownFuture = server.closeOnJvmShutdown();
+    shutdownFuture.join();
+
+    return 0;
+  }
+}
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/VectorTileContours.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/VectorTileContours.java
new file mode 100644
index 000000000..9328dd796
--- /dev/null
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/dem/VectorTileContours.java
@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.cli.dem;
+
+
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.Callable;
+import org.apache.baremaps.maplibre.tileset.Tileset;
+import org.apache.baremaps.maplibre.tileset.TilesetLayer;
+import org.apache.baremaps.openstreetmap.stream.ProgressLogger;
+import org.apache.baremaps.openstreetmap.stream.StreamUtils;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileEntry;
+import org.apache.baremaps.tilestore.TileStoreException;
+import org.apache.baremaps.tilestore.pmtiles.PMTilesStore;
+import org.apache.baremaps.tilestore.raster.*;
+import org.apache.baremaps.workflow.WorkflowException;
+import org.apache.baremaps.workflow.tasks.ExportVectorTiles;
+import org.locationtech.jts.geom.Envelope;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+
+@Command(name = "vector-contours", description = "Generate vector contours from a DEM.")
+@SuppressWarnings({"squid:S106", "squid:S3864"})
+public class VectorTileContours implements Callable<Integer> {
+
+  @Option(names = {"--path"}, paramLabel = "PATH", description = "The path of a geoTIFF file.")
+  private Path path;
+
+  @Option(names = {"--repository"}, paramLabel = "REPOSITORY", description = "The tile repository.",
+      required = true)
+  private Path repository;
+
+  @Option(names = {"--format"}, paramLabel = "FORMAT",
+      description = "The format of the repository.")
+  private ExportVectorTiles.Format format = ExportVectorTiles.Format.FILE;
+
+
+  @Override
+  public Integer call() throws Exception {
+    var contourLayer = new TilesetLayer();
+    contourLayer.setId("contours");
+
+    var tileset = new Tileset();
+    tileset.setName("contours");
+    tileset.setMinzoom(2);
+    tileset.setMaxzoom(10);
+    tileset.setCenter(List.of(0d, 0d, 1d));
+    tileset.setBounds(List.of(-180d, -85.0511d, 180d, 85.0511d));
+    tileset.setVectorLayers(List.of(contourLayer));
+
+    // Initialize the tile stores
+    try (var geoTiffReader = new GeoTiffReader(path);
+        var sourceTileStore = new VectorContourTileStore(geoTiffReader);
+        var targetTileStore = new PMTilesStore(repository, tileset);) {
+
+      var envelope = new Envelope(-180, 180, -85.0511, 85.0511);
+      var count = TileCoord.count(envelope, 0, 10);
+
+      var tileCoordIterator =
+          TileCoord.iterator(envelope, 2, 10);
+      var tileCoordStream =
+          StreamUtils.stream(tileCoordIterator).peek(new ProgressLogger<>(count, 1000));
+
+
+      var bufferedTileEntryStream = StreamUtils.bufferInCompletionOrder(tileCoordStream, tile -> {
+
+        try {
+          return new TileEntry<>(tile, sourceTileStore.read(tile));
+        } catch (TileStoreException e) {
+          throw new WorkflowException(e);
+        } finally {
+          System.out.println("Processing tile " + tile);
+        }
+      }, 8);
+
+      var partitionedTileEntryStream = StreamUtils.partition(bufferedTileEntryStream, 8);
+      partitionedTileEntryStream.forEach(batch -> {
+        try {
+          targetTileStore.write(batch);
+        } catch (TileStoreException e) {
+          throw new WorkflowException(e);
+        }
+      });
+      return 0;
+    }
+  }
+}
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Dev.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Dev.java
index 13b37356c..9e81c4e56 100644
--- a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Dev.java
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Dev.java
@@ -27,6 +27,7 @@
 import com.linecorp.armeria.server.file.FileService;
 import com.linecorp.armeria.server.file.HttpFile;
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
@@ -37,8 +38,8 @@
 import org.apache.baremaps.maplibre.tileset.Tileset;
 import org.apache.baremaps.server.ChangeResource;
 import org.apache.baremaps.server.StyleResource;
-import org.apache.baremaps.server.TileResource;
 import org.apache.baremaps.server.TilesetResource;
+import org.apache.baremaps.server.VectorTileResource;
 import org.apache.baremaps.tilestore.TileStore;
 import org.apache.baremaps.tilestore.postgres.PostgresTileStore;
 import org.apache.baremaps.utils.PostgresUtils;
@@ -96,7 +97,7 @@ public Integer call() throws Exception {
       }
     };
 
-    var tileStoreSupplier = (Supplier<TileStore>) () -> {
+    var tileStoreSupplier = (Supplier<TileStore<ByteBuffer>>) () -> {
       var tileJSON = tilesetSupplier.get();
       return new PostgresTileStore(datasource, tileJSON);
     };
@@ -116,7 +117,8 @@ public Integer call() throws Exception {
     var jsonResponseConverter = new JacksonResponseConverterFunction(objectMapper);
     serverBuilder.annotatedService(new ChangeResource(tilesetPath, stylePath),
         jsonResponseConverter);
-    serverBuilder.annotatedService(new TileResource(tileStoreSupplier), jsonResponseConverter);
+    serverBuilder.annotatedService("/tiles", new VectorTileResource(tileStoreSupplier),
+        jsonResponseConverter);
     serverBuilder.annotatedService(new StyleResource(styleSupplier), jsonResponseConverter);
     serverBuilder.annotatedService(new TilesetResource(tilesetSupplier), jsonResponseConverter);
 
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/MBTiles.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/MBTiles.java
index 9628169d3..a6f52e6a2 100644
--- a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/MBTiles.java
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/MBTiles.java
@@ -28,6 +28,7 @@
 import com.linecorp.armeria.server.docs.DocService;
 import com.linecorp.armeria.server.file.FileService;
 import com.linecorp.armeria.server.file.HttpFile;
+import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
@@ -36,9 +37,9 @@
 import org.apache.baremaps.maplibre.style.Style;
 import org.apache.baremaps.maplibre.tilejson.TileJSON;
 import org.apache.baremaps.server.*;
-import org.apache.baremaps.tilestore.TileCache;
 import org.apache.baremaps.tilestore.TileStore;
 import org.apache.baremaps.tilestore.mbtiles.MBTilesStore;
+import org.apache.baremaps.tilestore.vector.VectorTileCache;
 import org.apache.baremaps.utils.SqliteUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -83,8 +84,8 @@ public Integer call() throws Exception {
 
     var datasource = SqliteUtils.createDataSource(mbtilesPath, true);
     try (var tileStore = new MBTilesStore(datasource);
-        var tileCache = new TileCache(tileStore, caffeineSpec)) {
-      var tileStoreSupplier = (Supplier<TileStore>) () -> tileCache;
+        var tileCache = new VectorTileCache(tileStore, caffeineSpec)) {
+      var tileStoreSupplier = (Supplier<TileStore<ByteBuffer>>) () -> tileCache;
 
       var style = objectMapper.readValue(configReader.read(stylePath), Style.class);
       var styleSupplier = (Supplier<Style>) () -> style;
@@ -96,7 +97,8 @@ public Integer call() throws Exception {
       serverBuilder.http(port);
 
       var jsonResponseConverter = new JacksonResponseConverterFunction(objectMapper);
-      serverBuilder.annotatedService(new TileResource(tileStoreSupplier), jsonResponseConverter);
+      serverBuilder.annotatedService("/tiles", new VectorTileResource(tileStoreSupplier),
+          jsonResponseConverter);
       serverBuilder.annotatedService(new StyleResource(styleSupplier), jsonResponseConverter);
       serverBuilder.annotatedService(new TileJSONResource(tileJSONSupplier), jsonResponseConverter);
 
diff --git a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Serve.java b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Serve.java
index fc6c648de..591ee2a1a 100644
--- a/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Serve.java
+++ b/baremaps-cli/src/main/java/org/apache/baremaps/cli/map/Serve.java
@@ -28,6 +28,7 @@
 import com.linecorp.armeria.server.docs.DocService;
 import com.linecorp.armeria.server.file.FileService;
 import com.linecorp.armeria.server.file.HttpFile;
+import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
@@ -39,10 +40,10 @@
 import org.apache.baremaps.server.SearchResource;
 import org.apache.baremaps.server.StyleResource;
 import org.apache.baremaps.server.TileJSONResource;
-import org.apache.baremaps.server.TileResource;
-import org.apache.baremaps.tilestore.TileCache;
+import org.apache.baremaps.server.VectorTileResource;
 import org.apache.baremaps.tilestore.TileStore;
 import org.apache.baremaps.tilestore.postgres.PostgresTileStore;
+import org.apache.baremaps.tilestore.vector.VectorTileCache;
 import org.apache.baremaps.utils.PostgresUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -95,9 +96,9 @@ public Integer call() throws Exception {
 
     try (
         var tileStore = new PostgresTileStore(datasource, tileset);
-        var tileCache = new TileCache(tileStore, caffeineSpec)) {
+        var tileCache = new VectorTileCache(tileStore, caffeineSpec)) {
 
-      var tileStoreSupplier = (Supplier<TileStore>) () -> tileCache;
+      var tileStoreSupplier = (Supplier<TileStore<ByteBuffer>>) () -> tileCache;
 
       var style = objectMapper.readValue(configReader.read(stylePath), Style.class);
       var styleSupplier = (Supplier<Style>) () -> style;
@@ -109,7 +110,8 @@ public Integer call() throws Exception {
       serverBuilder.http(port);
 
       var jsonResponseConverter = new JacksonResponseConverterFunction(objectMapper);
-      serverBuilder.annotatedService(new TileResource(tileStoreSupplier), jsonResponseConverter);
+      serverBuilder.annotatedService("/tiles", new VectorTileResource(tileStoreSupplier),
+          jsonResponseConverter);
       serverBuilder.annotatedService(new StyleResource(styleSupplier), jsonResponseConverter);
       serverBuilder.annotatedService(new TileJSONResource(tileJSONSupplier), jsonResponseConverter);
       serverBuilder.annotatedService(new SearchResource(datasource), jsonResponseConverter);
diff --git a/baremaps-core/pom.xml b/baremaps-core/pom.xml
index 2684e792e..d546fd49e 100644
--- a/baremaps-core/pom.xml
+++ b/baremaps-core/pom.xml
@@ -82,6 +82,10 @@ limitations under the License.
       <groupId>org.apache.baremaps</groupId>
       <artifactId>baremaps-data</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.baremaps</groupId>
+      <artifactId>baremaps-dem</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.apache.baremaps</groupId>
       <artifactId>baremaps-flatgeobuf</artifactId>
@@ -126,6 +130,18 @@ limitations under the License.
       <groupId>org.apache.lucene</groupId>
       <artifactId>lucene-spatial-extras</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.sis.storage</groupId>
+      <artifactId>sis-geotiff</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.sis.storage</groupId>
+      <artifactId>sis-sqlstore</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.sis.storage</groupId>
+      <artifactId>sis-storage</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.graalvm.js</groupId>
       <artifactId>js</artifactId>
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java
index 93d02efba..096bc160f 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java
@@ -19,15 +19,14 @@
 
 
 
-import java.nio.ByteBuffer;
 import java.util.function.Consumer;
 
 /** A channel that conveys tiles from a source to a target. */
-public class TileChannel implements Consumer<TileCoord> {
+public class TileChannel<T> implements Consumer<TileCoord> {
 
-  public final TileStore source;
+  public final TileStore<T> source;
 
-  public final TileStore target;
+  public final TileStore<T> target;
 
   public final boolean deleteEmptyTiles;
 
@@ -37,7 +36,7 @@ public class TileChannel implements Consumer<TileCoord> {
    * @param source the source
    * @param target the target
    */
-  public TileChannel(TileStore source, TileStore target) {
+  public TileChannel(TileStore<T> source, TileStore<T> target) {
     this(source, target, false);
   }
 
@@ -48,7 +47,7 @@ public TileChannel(TileStore source, TileStore target) {
    * @param target the target
    * @param deleteEmptyTiles deletes empty tiles
    */
-  public TileChannel(TileStore source, TileStore target, boolean deleteEmptyTiles) {
+  public TileChannel(TileStore<T> source, TileStore<T> target, boolean deleteEmptyTiles) {
     this.source = source;
     this.target = target;
     this.deleteEmptyTiles = deleteEmptyTiles;
@@ -58,9 +57,9 @@ public TileChannel(TileStore source, TileStore target, boolean deleteEmptyTiles)
   @Override
   public void accept(TileCoord tileCoord) {
     try {
-      ByteBuffer blob = source.read(tileCoord);
-      if (blob != null) {
-        target.write(tileCoord, blob);
+      T tile = source.read(tileCoord);
+      if (tile != null) {
+        target.write(tileCoord, tile);
       } else if (deleteEmptyTiles) {
         target.delete(tileCoord);
       }
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java
index 6e3d2f9e1..192dd891a 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java
@@ -191,6 +191,42 @@ public TileCoord parent() {
     return new TileCoord(x / 2, y / 2, z - 1);
   }
 
+  /**
+   * Returns the tile coordinate at the left of the current tile.
+   *
+   * @return the left tile
+   */
+  public TileCoord left() {
+    return new TileCoord(x - 1, y, z);
+  }
+
+  /**
+   * Returns the tile coordinate at the right of the current tile.
+   *
+   * @return the right tile
+   */
+  public TileCoord right() {
+    return new TileCoord(x + 1, y, z);
+  }
+
+  /**
+   * Returns the tile coordinate at the top of the current tile.
+   *
+   * @return the top tile
+   */
+  public TileCoord top() {
+    return new TileCoord(x, y - 1, z);
+  }
+
+  /**
+   * Returns the tile coordinate at the bottom of the current tile.
+   *
+   * @return the bottom tile
+   */
+  public TileCoord bottom() {
+    return new TileCoord(x, y + 1, z);
+  }
+
   /**
    * Returns the envelope of the tile coordinate.
    *
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java
index 58333c7a7..192e156fa 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java
@@ -17,23 +17,22 @@
 
 package org.apache.baremaps.tilestore;
 
-import java.nio.ByteBuffer;
 
-public class TileEntry {
+public class TileEntry<T> {
 
   private final TileCoord tileCoord;
-  private final ByteBuffer byteBuffer;
+  private final T tileValue;
 
-  public TileEntry(TileCoord tileCoord, ByteBuffer byteBuffer) {
+  public TileEntry(TileCoord tileCoord, T tileValue) {
     this.tileCoord = tileCoord;
-    this.byteBuffer = byteBuffer;
+    this.tileValue = tileValue;
   }
 
   public TileCoord getTileCoord() {
     return tileCoord;
   }
 
-  public ByteBuffer getByteBuffer() {
-    return byteBuffer;
+  public T getTileValue() {
+    return tileValue;
   }
 }
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java
index e7f34b11a..fd9c1fca1 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java
@@ -19,12 +19,11 @@
 
 
 
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 
 /** Represents a store for tiles. */
-public interface TileStore extends AutoCloseable {
+public interface TileStore<T> extends AutoCloseable {
 
   /**
    * Reads the content of a tile.
@@ -33,7 +32,7 @@ public interface TileStore extends AutoCloseable {
    * @return the content of the tile
    * @throws TileStoreException
    */
-  ByteBuffer read(TileCoord tileCoord) throws TileStoreException;
+  T read(TileCoord tileCoord) throws TileStoreException;
 
   /**
    * Reads the content of a list of tiles.
@@ -42,8 +41,8 @@ public interface TileStore extends AutoCloseable {
    * @return the content of the tiles
    * @throws TileStoreException
    */
-  default List<ByteBuffer> read(List<TileCoord> tileCoords) throws TileStoreException {
-    var blobs = new ArrayList<ByteBuffer>();
+  default List<T> read(List<TileCoord> tileCoords) throws TileStoreException {
+    var blobs = new ArrayList<T>();
     for (var tileCoord : tileCoords) {
       blobs.add(read(tileCoord));
     }
@@ -57,7 +56,7 @@ default List<ByteBuffer> read(List<TileCoord> tileCoords) throws TileStoreExcept
    * @param blob the content of the tile
    * @throws TileStoreException
    */
-  void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException;
+  void write(TileCoord tileCoord, T blob) throws TileStoreException;
 
   /**
    * Writes the content of a list of tiles.
@@ -65,9 +64,9 @@ default List<ByteBuffer> read(List<TileCoord> tileCoords) throws TileStoreExcept
    * @param entries the tile entries
    * @throws TileStoreException
    */
-  default void write(List<TileEntry> entries) throws TileStoreException {
+  default void write(List<TileEntry<T>> entries) throws TileStoreException {
     for (var entry : entries) {
-      write(entry.getTileCoord(), entry.getByteBuffer());
+      write(entry.getTileCoord(), entry.getTileValue());
     }
   }
 
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStoreException.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStoreException.java
index 1ad72e1eb..490a680ce 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStoreException.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStoreException.java
@@ -21,7 +21,7 @@
 public class TileStoreException extends Exception {
 
   /**
-   * Constructs an {@code BlobStoreException} with the specified detail message.
+   * Constructs an {@code TileStoreException} with the specified detail message.
    *
    * @param message the message
    */
@@ -30,7 +30,7 @@ public TileStoreException(String message) {
   }
 
   /**
-   * Constructs a {@code BlobStoreException} with the specified cause.
+   * Constructs a {@code TileStoreException} with the specified cause.
    *
    * @param cause the cause
    */
@@ -39,7 +39,7 @@ public TileStoreException(Throwable cause) {
   }
 
   /**
-   * Constructs a {@code BlobStoreException} with the specified detail message and cause.
+   * Constructs a {@code TileStoreException} with the specified detail message and cause.
    *
    * @param message the message
    * @param cause the cause
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java
index 5afcdafa0..d4bb68440 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java
@@ -28,7 +28,7 @@
 import org.apache.baremaps.tilestore.TileStoreException;
 
 /** Represents a {@code TileStore} baked by a directory. */
-public class FileTileStore implements TileStore {
+public class FileTileStore implements TileStore<ByteBuffer> {
 
   private final Path path;
 
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java
index 755739b6d..15149b76c 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java
@@ -39,7 +39,7 @@
  * <a href="https://docs.mapbox.com/help/glossary/mbtiles/">MBTiles</a> file format for storing
  * tiles.
  */
-public class MBTilesStore implements TileStore {
+public class MBTilesStore implements TileStore<ByteBuffer> {
 
   public static final String CREATE_TABLE_METADATA =
       "CREATE TABLE IF NOT EXISTS metadata (name TEXT, value TEXT, PRIMARY KEY (name))";
@@ -119,13 +119,13 @@ public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreExceptio
    * {@inheritDoc}
    */
   @Override
-  public void write(List<TileEntry> tileEntries) throws TileStoreException {
+  public void write(List<TileEntry<ByteBuffer>> tileEntries) throws TileStoreException {
     try (
         Connection connection = dataSource.getConnection();
         PreparedStatement statement = connection.prepareStatement(INSERT_TILE)) {
-      for (TileEntry tileEntry : tileEntries) {
+      for (TileEntry<ByteBuffer> tileEntry : tileEntries) {
         TileCoord tileCoord = tileEntry.getTileCoord();
-        ByteBuffer byteBuffer = tileEntry.getByteBuffer();
+        ByteBuffer byteBuffer = tileEntry.getTileValue();
         statement.setInt(1, tileCoord.z());
         statement.setInt(2, tileCoord.x());
         statement.setInt(3, reverseY(tileCoord.y(), tileCoord.z()));
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java
index b17b12ba1..d5a9d924e 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java
@@ -29,7 +29,7 @@
 import org.apache.baremaps.tilestore.TileStore;
 import org.apache.baremaps.tilestore.TileStoreException;
 
-public class PMTilesStore implements TileStore {
+public class PMTilesStore implements TileStore<ByteBuffer> {
 
   private final PMTilesWriter writer;
 
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java
deleted file mode 100644
index 1e640fab4..000000000
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.baremaps.tilestore.postgres;
-
-
-import java.sql.SQLException;
-import java.util.List;
-import java.util.stream.Collectors;
-import javax.sql.DataSource;
-import org.apache.baremaps.database.metadata.DatabaseMetadata;
-import org.apache.baremaps.database.metadata.TableMetadata;
-import org.apache.baremaps.maplibre.tileset.TilesetQuery;
-
-/**
- * A generator that uses PostgreSQL metadata to generate input queries for a {@code
- * PostgresTileStore}. It can be used to accelerate the creation of a tile set.
- *
- * <p>
- * As in
- * <a href="https://docs.oracle.com/javase/7/docs/api/java/sql/DatabaseMetaData.html">JDBC</a>, some
- * methods take arguments that are String patterns. These arguments all have names such as *
- * fooPattern. Within a pattern String, "%" means match any substring of 0 or more characters, and
- * "_" means match any * one character. Only metadata entries matching the search pattern are
- * returned. If a search pattern argument is set * to null, that argument's criterion will be
- * dropped from the search.
- */
-public class PostgresQueryGenerator {
-
-  private final String catalog;
-  private final String schemaPattern;
-  private final String tableNamePattern;
-  private final String columnNamePattern;
-  private final String[] types;
-
-  private final DataSource dataSource;
-
-  /**
-   * Constructs a {@code PostgresQueryGenerator}.
-   *
-   * @param dataSource the data source
-   */
-  public PostgresQueryGenerator(DataSource dataSource) {
-    this(dataSource, null, null, null, null);
-  }
-
-  /**
-   * Constructs a {@code PostgresQueryGenerator}.
-   *
-   * @param dataSource the data source
-   * @param catalog the catalog
-   * @param schemaPattern the schema pattern
-   * @param typeNamePattern the type name pattern
-   * @param columnNamePattern the column name pattern
-   * @param types the types
-   */
-  public PostgresQueryGenerator(
-      DataSource dataSource,
-      String catalog,
-      String schemaPattern,
-      String typeNamePattern,
-      String columnNamePattern,
-      String... types) {
-    this.dataSource = dataSource;
-    this.catalog = catalog;
-    this.schemaPattern = schemaPattern;
-    this.tableNamePattern = typeNamePattern;
-    this.columnNamePattern = columnNamePattern;
-    this.types = types;
-  }
-
-  /**
-   * Generates the queries.
-   *
-   * @return the queries
-   */
-  public List<TilesetQuery> generate() throws SQLException {
-    return new DatabaseMetadata(dataSource)
-        .getTableMetaData(catalog, schemaPattern, tableNamePattern, types).stream()
-        .filter(table -> table.primaryKeys().size() == 1)
-        .filter(table -> table.getGeometryColumns().size() == 1)
-        .map(this::getLayer).toList();
-  }
-
-  private TilesetQuery getLayer(TableMetadata table) {
-    String tableName = table.table().tableName();
-    String idColumn = table.primaryKeys().get(0).columnName();
-    String geometryColumn = table.getGeometryColumns().get(0).columnName();
-    String tagsColumns =
-        table.columns().stream().filter(column -> !idColumn.equals(column.columnName()))
-            .filter(column -> !geometryColumn.equals(column.columnName()))
-            .map(column -> String.format("'%1$s', %1$s::text", column.columnName()))
-            .collect(Collectors.joining(", ", "hstore(array[", "])"));
-    String sql = String.format("SELECT %s, %s, %s FROM %s", idColumn, tagsColumns, geometryColumn,
-        tableName);
-    return new TilesetQuery(0, 20, sql);
-  }
-}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java
index ba9f35865..311f86ff4 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java
@@ -38,7 +38,7 @@
  * This {@code TileStore} combines the input queries, identifies common table expressions (CTE), and
  * generates a single optimized sql that hits the database.
  */
-public class PostgresTileStore implements TileStore {
+public class PostgresTileStore implements TileStore<ByteBuffer> {
 
   private static final Logger logger = LoggerFactory.getLogger(PostgresTileStore.class);
 
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java
new file mode 100644
index 000000000..ceac74451
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+import java.awt.*;
+import java.nio.DoubleBuffer;
+import org.apache.sis.image.Interpolation;
+
+/**
+ * An {@code Interpolation} that performs bicubic interpolation.
+ */
+class BicubicInterpolation extends Interpolation {
+
+  /** {@inheritDoc} */
+  @Override
+  public Dimension getSupportSize() {
+    return new Dimension(4, 4);
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void interpolate(DoubleBuffer source, int numBands, double xfrac, double yfrac,
+      double[] writeTo, int writeToOffset) {
+    // Initialize arrays for the intermediate computations
+    double[] colValues = new double[4];
+    double[] rowValues = new double[4];
+
+    // Iterate over each band
+    for (int band = 0; band < numBands; band++) {
+      // Interpolate each row
+      for (int j = 0; j < 4; j++) {
+        for (int i = 0; i < 4; i++) {
+          rowValues[i] = source.get(band + i * numBands + j * numBands * 4);
+        }
+        colValues[j] = cubicInterpolate(rowValues, xfrac);
+      }
+
+      // Interpolate the final value for this band
+      writeTo[writeToOffset + band] = cubicInterpolate(colValues, yfrac);
+    }
+  }
+
+  private double cubicInterpolate(double[] p, double x) {
+    // Using the cubic interpolation formula
+    return p[1] + 0.5 * x * (p[2] - p[0] + x
+        * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] + x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
+  }
+
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffException.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffException.java
new file mode 100644
index 000000000..7dbaabab0
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffException.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+/**
+ * An exception thrown when an error occurs while reading a GeoTIFF file.
+ */
+public class GeoTiffException extends Exception {
+
+  /**
+   * Constructs an {@code GeoTiffException} with the specified detail message.
+   *
+   * @param message the message
+   */
+  public GeoTiffException(String message) {
+    super(message);
+  }
+
+  /**
+   * Constructs a {@code GeoTiffException} with the specified cause.
+   *
+   * @param cause the cause
+   */
+  public GeoTiffException(Throwable cause) {
+    super(cause);
+  }
+
+  /**
+   * Constructs a {@code GeoTiffException} with the specified detail message and cause.
+   *
+   * @param message the message
+   * @param cause the cause
+   */
+  public GeoTiffException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java
new file mode 100644
index 000000000..84a8a8f0f
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+import java.nio.file.Path;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.sis.coverage.grid.*;
+import org.apache.sis.geometry.Envelopes;
+import org.apache.sis.geometry.GeneralEnvelope;
+import org.apache.sis.image.ImageProcessor;
+import org.apache.sis.referencing.CRS;
+import org.apache.sis.referencing.CommonCRS;
+import org.apache.sis.storage.*;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.TransformException;
+import org.opengis.util.FactoryException;
+
+/**
+ * A reader for geotiff files based on the Apache SIS library.
+ */
+public class GeoTiffReader implements AutoCloseable {
+
+  private static final CoordinateReferenceSystem WEB_MERCATOR;
+
+  static {
+    try {
+      WEB_MERCATOR = CRS.fromWKT("""
+          ProjectedCRS["WGS 84 / Pseudo-Mercator",
+            BaseGeodCRS["WGS 84",
+              Datum["World Geodetic System 1984",
+                Ellipsoid["WGS 84", 6378137.0, 298.257223563]],
+              Unit["degree", 0.017453292519943295]],
+            Conversion["Popular Visualisation Pseudo-Mercator",
+              Method["Popular Visualisation Pseudo Mercator"]],
+            CS[Cartesian, 2],
+              Axis["Easting (X)", east],
+              Axis["Northing (Y)", north],
+              Unit["metre", 1],
+            Scope["Certain Web mapping and visualisation applications."],
+            Id["EPSG", 3857]]
+          """);
+    } catch (FactoryException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+
+  private final DataStore dataStore;
+
+  private final GridCoverage gridCoverage;
+
+  /**
+   * Constructs a {@code GeoTiffReader} with the specified path.
+   *
+   * @param path the path of the geotiff file
+   * @throws GeoTiffException if an error occurs
+   */
+  public GeoTiffReader(Path path) throws GeoTiffException {
+    try {
+      this.dataStore = DataStores.open(path);
+      var allImages = ((Aggregate) dataStore).components();
+      var firstImage = (GridCoverageResource) allImages.iterator().next();
+      firstImage.setLoadingStrategy(RasterLoadingStrategy.AT_GET_TILE_TIME);
+      gridCoverage = firstImage.read(null);
+    } catch (DataStoreException e) {
+      throw new GeoTiffException(e);
+    }
+  }
+
+  /**
+   * Read the elevation data for the specified tile coordinate.
+   *
+   * @param tileCoord the tile coordinate
+   * @param tileSizePx the size of the tile in pixels
+   * @param tileBufferPx the buffer size in pixels
+   * @return the elevation data
+   * @throws GeoTiffException if an error occurs
+   */
+  public double[] read(TileCoord tileCoord, int tileSizePx, int tileBufferPx)
+      throws GeoTiffException {
+    try {
+      // Compute the buffer size and expand the envelope
+      var imageSize = tileSizePx + 2 * tileBufferPx;
+      var tileEnvelope = tileCoord.envelope();
+      var tileWidth = tileEnvelope.getWidth();
+      var tileHeight = tileEnvelope.getHeight();
+      var pixelWidth = tileWidth / tileSizePx;
+      var pixelHeight = tileHeight / tileSizePx;
+      tileEnvelope.expandBy(pixelWidth * tileBufferPx, pixelHeight * tileBufferPx);
+
+      // Create the target grid geometry in the web mercator projection
+      var sourceEnvelope = new GeneralEnvelope(CommonCRS.WGS84.normalizedGeographic());
+      sourceEnvelope.setRange(0, tileEnvelope.getMinX(), tileEnvelope.getMaxX());
+      sourceEnvelope.setRange(1, tileEnvelope.getMinY(), tileEnvelope.getMaxY());
+      var targetEnvelope = Envelopes.transform(sourceEnvelope, WEB_MERCATOR);
+      var targetSize = new GridExtent(imageSize, imageSize);
+      var targetGridGeometry =
+          new GridGeometry(targetSize, targetEnvelope, GridOrientation.DISPLAY);
+
+      // Resample and render the image
+      var gridCoverageProcessor = new GridCoverageProcessor();
+      gridCoverageProcessor.setInterpolation(new BicubicInterpolation());
+      var tileGridCoverage = gridCoverageProcessor.resample(this.gridCoverage, targetGridGeometry);
+      var renderedImage = tileGridCoverage.render(null);
+
+      // Convert the image to the terrarium color scale
+      var imageProcessor = new ImageProcessor();
+      renderedImage = imageProcessor.prefetch(renderedImage, null);
+
+      // Convert the image to a grid
+      var values = new double[renderedImage.getWidth() * renderedImage.getHeight()];
+      renderedImage.getData().getPixels(
+          0,
+          0,
+          renderedImage.getWidth(),
+          renderedImage.getHeight(),
+          values);
+
+      return values;
+    } catch (TransformException e) {
+      throw new GeoTiffException(e);
+    }
+  }
+
+  /**
+   * Closes the reader.
+   *
+   * @throws Exception if an error occurs
+   */
+  @Override
+  public void close() throws Exception {
+    this.dataStore.close();
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java
new file mode 100644
index 000000000..17bc89c72
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.function.IntToDoubleFunction;
+import org.apache.baremaps.dem.ElevationUtils;
+import org.apache.baremaps.dem.HillshadeCalculator;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
+
+/**
+ * A {@code TileStore} that calculates hillshade tiles from elevation tiles.
+ */
+public class RasterHillshadeTileStore implements TileStore<BufferedImage> {
+
+  private final GeoTiffReader geoTiffReader;
+
+  private final IntToDoubleFunction pixelToElevation;
+
+  /**
+   * Constructs a {@code RasterHillshadeTileStore} with the specified tile store and pixel to
+   * elevation function.
+   *
+   * @param geoTiffReader the geotiff reader
+   * @param pixelToElevation the pixel to elevation function
+   */
+  public RasterHillshadeTileStore(
+      GeoTiffReader geoTiffReader,
+      IntToDoubleFunction pixelToElevation) {
+    this.geoTiffReader = geoTiffReader;
+    this.pixelToElevation = pixelToElevation;
+  }
+
+  /**
+   * Read the hillshade data for the specified tile coordinate.
+   *
+   * @param tileCoord the tile coordinate
+   * @return the hillshade data
+   * @throws TileStoreException if an error occurs
+   */
+  @Override
+  public BufferedImage read(TileCoord tileCoord) throws TileStoreException {
+    try {
+      var tileSize = 256;
+      var tileBuffer = 1;
+      var imageSize = tileSize + tileBuffer + tileBuffer;
+
+      // Read the elevation data
+      var grid = geoTiffReader.read(tileCoord, tileSize, tileBuffer);
+      grid = ElevationUtils.clampGrid(grid, 0, 10000);
+      grid = new HillshadeCalculator(
+          grid,
+          imageSize,
+          imageSize,
+          HillshadeCalculator.getResolution(tileCoord.z()) / 2)
+              .calculate(45, 315);
+
+      // Create the hillshade image
+      BufferedImage hillshadeImage =
+          new BufferedImage(imageSize, imageSize, BufferedImage.TYPE_BYTE_GRAY);
+      for (int y = 0; y < imageSize; y++) {
+        for (int x = 0; x < imageSize; x++) {
+          int value = (int) grid[y * imageSize + x];
+          hillshadeImage.setRGB(x, y, new Color(value, value, value).getRGB());
+        }
+      }
+
+      // Return the hillshade image without the buffer
+      return hillshadeImage.getSubimage(1, 1, tileSize, tileSize);
+    } catch (Exception e) {
+      throw new TileStoreException(e);
+    }
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void write(TileCoord tileCoord, BufferedImage blob) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void delete(TileCoord tileCoord) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void close() throws Exception {
+    // Do nothing
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java
new file mode 100644
index 000000000..0760f0c19
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.CaffeineSpec;
+import com.github.benmanes.caffeine.cache.Weigher;
+import java.awt.image.BufferedImage;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A {@code TileStore} decorator that uses caffeine to cache the content of tiles.
+ */
+public class RasterTileCache implements TileStore<BufferedImage> {
+
+  private static final Logger logger = LoggerFactory.getLogger(RasterTileCache.class);
+
+  private final TileStore<BufferedImage> tileStore;
+
+  private final Cache<TileCoord, BufferedImage> cache;
+
+  /**
+   * Decorates the TileStore with a cache.
+   *
+   * @param tileStore the tile store
+   * @param caffeineSpec the cache specification
+   */
+  public RasterTileCache(TileStore<BufferedImage> tileStore, CaffeineSpec caffeineSpec) {
+    this.tileStore = tileStore;
+    this.cache = Caffeine.from(caffeineSpec).weigher(new Weigher<TileCoord, BufferedImage>() {
+      @Override
+      public @NonNegative int weigh(TileCoord tileCoord, BufferedImage bufferedImage) {
+        return bufferedImage.getData().getDataBuffer().getSize() * 4;
+      }
+    }).build();
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public BufferedImage read(TileCoord tileCoord) throws TileStoreException {
+    return cache.get(tileCoord, t -> {
+      try {
+        return tileStore.read(t);
+      } catch (TileStoreException e) {
+        logger.error("Unable to read the tile.", e);
+        return null;
+      }
+    });
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void write(TileCoord tileCoord, BufferedImage bufferedImage) throws TileStoreException {
+    tileStore.write(tileCoord, bufferedImage);
+    cache.invalidate(tileCoord);
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void delete(TileCoord tileCoord) throws TileStoreException {
+    tileStore.delete(tileCoord);
+    cache.invalidate(tileCoord);
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void close() throws Exception {
+    cache.cleanUp();
+    tileStore.close();
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java
new file mode 100644
index 000000000..a8c90a6d0
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+import java.awt.image.BufferedImage;
+import org.apache.baremaps.dem.ElevationUtils;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
+
+/**
+ * A {@code TileStore} that reads elevation tiles from a GeoTIFF file and converts them to terrarium
+ * tiles format.
+ */
+public class TerrariumTileStore implements TileStore<BufferedImage> {
+
+  private final GeoTiffReader geoTiffReader;
+
+  /**
+   * Constructs a {@code TerrariumTileStore} with the specified GeoTIFF reader.
+   *
+   * @param geoTiffReader
+   */
+  public TerrariumTileStore(GeoTiffReader geoTiffReader) {
+    this.geoTiffReader = geoTiffReader;
+  }
+
+  /**
+   * Read the elevation data for the specified tile coordinate.
+   *
+   * @param tileCoord the tile coordinate
+   * @return the elevation data
+   * @throws TileStoreException if an error occurs
+   */
+  @Override
+  public BufferedImage read(TileCoord tileCoord) throws TileStoreException {
+    try {
+      var size = 256;
+      var grid = geoTiffReader.read(tileCoord, size, 0);
+      var bufferedImage = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
+      for (int x = 0; x < size; x++) {
+        for (int y = 0; y < size; y++) {
+          double value = (int) grid[y * size + x];
+          int rgb = ElevationUtils.elevationToTerrarium(value);
+          bufferedImage.setRGB(x, y, rgb);
+        }
+      }
+      return bufferedImage;
+    } catch (Exception e) {
+      throw new TileStoreException(e);
+    }
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void write(TileCoord tileCoord, BufferedImage blob) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void delete(TileCoord tileCoord) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void close() throws Exception {
+    this.geoTiffReader.close();
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java
new file mode 100644
index 000000000..bae912e2d
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.GZIPOutputStream;
+import org.apache.baremaps.dem.ContourTracer;
+import org.apache.baremaps.maplibre.vectortile.Feature;
+import org.apache.baremaps.maplibre.vectortile.Layer;
+import org.apache.baremaps.maplibre.vectortile.Tile;
+import org.apache.baremaps.maplibre.vectortile.VectorTileEncoder;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
+import org.locationtech.jts.geom.util.AffineTransformation;
+
+/**
+ * A {@code TileStore} that calculates vector contour tiles from elevation tiles.
+ */
+public class VectorContourTileStore implements TileStore<ByteBuffer> {
+
+  private final GeoTiffReader geoTiffReader;
+
+  /**
+   * Constructs a {@code VectorContourTileStore} with the specified GeoTIFF reader.
+   *
+   * @param geoTiffReader the geotiff reader
+   */
+  public VectorContourTileStore(GeoTiffReader geoTiffReader) {
+    this.geoTiffReader = geoTiffReader;
+  }
+
+  /**
+   * Read the contour data for the specified tile coordinate.
+   *
+   * @param tileCoord the tile coordinate
+   * @return the contour data
+   * @throws TileStoreException if an error occurs
+   */
+  @Override
+  public ByteBuffer read(TileCoord tileCoord) throws TileStoreException {
+    try {
+      var grid = geoTiffReader.read(tileCoord, 256, 4);
+
+      int increment = switch (tileCoord.z()) {
+        case 1 -> 2000;
+        case 2 -> 2000;
+        case 3 -> 1000;
+        case 4 -> 1000;
+        case 5 -> 1000;
+        case 6 -> 1000;
+        case 7 -> 1000;
+        case 8 -> 500;
+        case 9 -> 500;
+        case 10 -> 250;
+        case 11 -> 250;
+        case 12 -> 100;
+        case 13 -> 100;
+        case 14 -> 50;
+        default -> 10;
+      };
+
+      var features = new ArrayList<Feature>();
+      for (int level = -10000; level < 10000; level += increment) {
+        var contours =
+            new ContourTracer(grid, 264, 264, false, true)
+                .traceContours(level);
+        for (var contour : contours) {
+          contour = AffineTransformation
+              .translationInstance(-4, -4)
+              .scale(16, 16)
+              .transform(contour);
+          features.add(new Feature(level, Map.of("level", String.valueOf(level)), contour));
+        }
+      }
+
+      var layer = new Layer("contour", 4096, features);
+      var tile = new Tile(List.of(layer));
+      var vectorTile = new VectorTileEncoder().encodeTile(tile);
+      try (var baos = new ByteArrayOutputStream()) {
+        var gzip = new GZIPOutputStream(baos);
+        vectorTile.writeTo(gzip);
+        gzip.close();
+        return ByteBuffer.wrap(baos.toByteArray());
+      }
+    } catch (Exception e) {
+      throw new TileStoreException(e);
+    }
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void delete(TileCoord tileCoord) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void close() throws Exception {
+    geoTiffReader.close();
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java
new file mode 100644
index 000000000..277aeacc1
--- /dev/null
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java
@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.tilestore.raster;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.GZIPOutputStream;
+import org.apache.baremaps.dem.ContourTracer;
+import org.apache.baremaps.dem.ElevationUtils;
+import org.apache.baremaps.dem.HillshadeCalculator;
+import org.apache.baremaps.maplibre.vectortile.Feature;
+import org.apache.baremaps.maplibre.vectortile.Layer;
+import org.apache.baremaps.maplibre.vectortile.Tile;
+import org.apache.baremaps.maplibre.vectortile.VectorTileEncoder;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
+import org.locationtech.jts.geom.util.AffineTransformation;
+
+/**
+ * A {@code TileStore} that calculates vector hillshade tiles from elevation data.
+ */
+public class VectorHillshadeTileStore implements TileStore<ByteBuffer> {
+
+  private final GeoTiffReader geoTiffReader;
+
+  /**
+   * Constructs a {@code VectorHillshadeTileStore} with the specified geotiff reader.
+   *
+   * @param geoTiffReader the geotiff reader
+   */
+  public VectorHillshadeTileStore(GeoTiffReader geoTiffReader) {
+    this.geoTiffReader = geoTiffReader;
+  }
+
+  /**
+   * Read the hillshade data for the specified tile coordinate.
+   *
+   * @param tileCoord the tile coordinate
+   * @return the hillshade data
+   * @throws TileStoreException
+   */
+  @Override
+  public ByteBuffer read(TileCoord tileCoord) throws TileStoreException {
+    try {
+      var size = 256;
+
+      // Read the elevation data
+      var features = new ArrayList<Feature>();
+
+      // Calculate the hillshade
+      var grid = geoTiffReader.read(tileCoord, size, 16);
+      grid = ElevationUtils.clampGrid(grid, 0, 10000);
+      grid = new HillshadeCalculator(
+          grid,
+          size + 32, size + 32, HillshadeCalculator.getResolution(tileCoord.z()) / 2)
+              .calculate(45, 315);
+
+      contours(grid, 255 - 16, features, 1);
+      contours(grid, 255 - 32, features, 2);
+
+      grid = ElevationUtils.invertGrid(grid);
+      contours(grid, 255 - 32, features, 6);
+      contours(grid, 255 - 64, features, 5);
+      contours(grid, 255 - 98, features, 4);
+      contours(grid, 255 - 128, features, 3);
+
+      var layer = new Layer("elevation", 4096, features);
+      var tile = new Tile(List.of(layer));
+      var vectorTile = new VectorTileEncoder().encodeTile(tile);
+      try (var baos = new ByteArrayOutputStream()) {
+        var gzip = new GZIPOutputStream(baos);
+        vectorTile.writeTo(gzip);
+        gzip.close();
+        return ByteBuffer.wrap(baos.toByteArray());
+      }
+    } catch (Exception e) {
+      throw new TileStoreException(e);
+    }
+  }
+
+  private static void contours(double[] grid, int level, ArrayList<Feature> features,
+      int category) {
+    var contours =
+        new ContourTracer(grid, (int) Math.sqrt(grid.length), (int) Math.sqrt(grid.length), false,
+            true)
+                .traceContours(level);
+    for (var contour : contours) {
+      contour = AffineTransformation
+          .translationInstance(-16, -16)
+          .scale(16, 16)
+          .transform(contour);
+      features.add(new Feature(category, Map.of("level", String.valueOf(category)), contour));
+    }
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Unsupported operation.
+   */
+  @Override
+  public void delete(TileCoord tileCoord) throws TileStoreException {
+    throw new UnsupportedOperationException();
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void close() throws Exception {
+    // Do nothing
+  }
+}
diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java
similarity index 70%
rename from baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java
rename to baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java
index 199734a71..d8b7685ce 100644
--- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java
+++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.baremaps.tilestore;
+package org.apache.baremaps.tilestore.vector;
 
 
 
@@ -24,28 +24,31 @@
 import com.github.benmanes.caffeine.cache.CaffeineSpec;
 import com.github.benmanes.caffeine.cache.Weigher;
 import java.nio.ByteBuffer;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.apache.baremaps.tilestore.TileStoreException;
 import org.checkerframework.checker.index.qual.NonNegative;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /** A {@code TileStore} decorator that uses caffeine to cache the content of tiles. */
-public class TileCache implements TileStore {
+public class VectorTileCache implements TileStore<ByteBuffer> {
 
-  private static final Logger logger = LoggerFactory.getLogger(TileCache.class);
+  private static final Logger logger = LoggerFactory.getLogger(VectorTileCache.class);
 
-  private final TileStore tileStore;
+  private final TileStore<ByteBuffer> tileStore;
 
   private final Cache<TileCoord, ByteBuffer> cache;
 
   /**
    * Decorates the TileStore with a cache.
    *
-   * @param tileStore
-   * @param spec
+   * @param tileStore the tile store
+   * @param caffeineSpec the cache specification
    */
-  public TileCache(TileStore tileStore, CaffeineSpec spec) {
+  public VectorTileCache(TileStore<ByteBuffer> tileStore, CaffeineSpec caffeineSpec) {
     this.tileStore = tileStore;
-    this.cache = Caffeine.from(spec).weigher(new Weigher<TileCoord, ByteBuffer>() {
+    this.cache = Caffeine.from(caffeineSpec).weigher(new Weigher<TileCoord, ByteBuffer>() {
       @Override
       public @NonNegative int weigh(TileCoord tileCoord, ByteBuffer blob) {
         return 28 + blob.capacity();
@@ -56,7 +59,7 @@ public TileCache(TileStore tileStore, CaffeineSpec spec) {
   /** {@inheritDoc} */
   @Override
   public ByteBuffer read(TileCoord tileCoord) throws TileStoreException {
-    var buffer = cache.get(tileCoord, t -> {
+    var byteBuffer = cache.get(tileCoord, t -> {
       try {
         return tileStore.read(t);
       } catch (TileStoreException e) {
@@ -64,17 +67,17 @@ public ByteBuffer read(TileCoord tileCoord) throws TileStoreException {
         return null;
       }
     });
-    if (buffer == null) {
+    if (byteBuffer == null) {
       return null;
     } else {
-      return buffer.duplicate();
+      return byteBuffer.duplicate();
     }
   }
 
   /** {@inheritDoc} */
   @Override
-  public void write(TileCoord tileCoord, ByteBuffer bytes) throws TileStoreException {
-    tileStore.write(tileCoord, bytes);
+  public void write(TileCoord tileCoord, ByteBuffer byteBuffer) throws TileStoreException {
+    tileStore.write(tileCoord, byteBuffer);
     cache.invalidate(tileCoord);
   }
 
@@ -85,6 +88,7 @@ public void delete(TileCoord tileCoord) throws TileStoreException {
     cache.invalidate(tileCoord);
   }
 
+  /** {@inheritDoc} */
   @Override
   public void close() throws Exception {
     tileStore.close();
diff --git a/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java b/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java
index fefd185a8..e09e9cb49 100644
--- a/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java
+++ b/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java
@@ -17,11 +17,11 @@
 
 package org.apache.baremaps.config;
 
+import static org.apache.baremaps.testing.TestFiles.*;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import java.io.File;
 import java.io.IOException;
 import java.nio.file.Path;
 import org.apache.baremaps.maplibre.tilejson.TileJSON;
@@ -31,15 +31,9 @@
 
 public class TileSetTest {
 
-  final String tilesetFile = "/tilesets/tileset.json";
-  final String tilejsonFile = "/tilesets/tilejson.json";
   final ObjectMapper objectMapper = ObjectMapperUtils.objectMapper();
   final ConfigReader configReader = new ConfigReader();
 
-  private File resourceFile(String path) {
-    return new File(TileSetTest.class.getResource(path).getFile());
-  }
-
   @Test
   public void testBasemapJSConfig() throws IOException {
     var path = Path.of("../basemap/tileset.js");
@@ -55,9 +49,9 @@ public void testBasemapJSConfig() throws IOException {
   @Test
   public void validateTileset() throws IOException {
     // Mapping to a POJO for baremaps-core and baremaps-server
-    var tileSet = objectMapper.readValue(resourceFile(tilesetFile), Tileset.class);
+    var tileSet = objectMapper.readValue(TILESET_JSON.toFile(), Tileset.class);
     // Mapping to a POJO strictly following TileJSON specifications for API clients.
-    var tileJSON = objectMapper.readValue(resourceFile(tilesetFile), TileJSON.class);
+    var tileJSON = objectMapper.readValue(TILESET_JSON.toFile(), TileJSON.class);
 
     assertEquals("jdbc:postgresql://localhost:5432/baremaps?&user=baremaps&password=baremaps",
         tileSet.getDatabase());
@@ -67,14 +61,11 @@ public void validateTileset() throws IOException {
   @Test
   public void validateSpecificationExample() throws IOException {
     // Mapping to a POJO for baremaps-core and baremaps-server
-    var tileSet = objectMapper.readValue(resourceFile(tilejsonFile), Tileset.class);
+    var tileSet = objectMapper.readValue(TILEJSON_JSON.toFile(), Tileset.class);
     // Mapping to a POJO strictly following TileJSON specifications for API clients.
-    var tileJSON = objectMapper.readValue(resourceFile(tilejsonFile), TileJSON.class);
+    var tileJSON = objectMapper.readValue(TILEJSON_JSON.toFile(), TileJSON.class);
 
     assertNull(tileSet.getDatabase());
-    assertEquals("telephone", tileJSON.getVectorLayers().get(0).id());
-    assertEquals("the phone number", tileJSON.getVectorLayers().stream()
-        .filter(vl -> vl.id().equals("telephone"))
-        .findFirst().get().fields().get("phone_number"));
+    assertEquals("layer_a", tileJSON.getVectorLayers().get(0).id());
   }
 }
diff --git a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java
index 17c759b04..0fea6925f 100644
--- a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java
+++ b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java
@@ -31,7 +31,7 @@ public abstract class TileDataSchemaTest {
   @Test
   @Tag("integration")
   void readWriteDeleteTile() throws Exception {
-    TileStore tileStore = createTileStore();
+    TileStore<ByteBuffer> tileStore = createTileStore();
     TileCoord tileCoord = new TileCoord(1, 2, 3);
     ByteBuffer blob = ByteBuffer.wrap("tile_content".getBytes());
 
@@ -47,5 +47,5 @@ void readWriteDeleteTile() throws Exception {
     assertThrows(TileStoreException.class, () -> tileStore.read(tileCoord));
   }
 
-  public abstract TileStore createTileStore() throws Exception;
+  public abstract TileStore<ByteBuffer> createTileStore() throws Exception;
 }
diff --git a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java
deleted file mode 100644
index 214c13a69..000000000
--- a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.baremaps.tilestore.postgres;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.sql.SQLException;
-import java.util.List;
-import javax.sql.DataSource;
-import org.apache.baremaps.database.postgres.PostgresRepositoryTest;
-import org.apache.baremaps.maplibre.tileset.TilesetQuery;
-import org.junit.jupiter.api.Tag;
-import org.junit.jupiter.api.Test;
-
-class PostgresQueryGeneratorTest extends PostgresRepositoryTest {
-
-  @Test
-  @Tag("integration")
-  void generate() throws SQLException {
-    DataSource dataSource = dataSource();
-    List<TilesetQuery> queries =
-        new PostgresQueryGenerator(dataSource, null, "public", null, null, "TABLE").generate();
-    assertEquals(3, queries.size());
-    assertEquals(
-        "SELECT id, hstore(array['version', version::text, 'uid', uid::text, 'timestamp', timestamp::text, 'changeset', changeset::text, 'tags', tags::text, 'lon', lon::text, 'lat', lat::text]), geom FROM osm_nodes",
-        queries.get(0).getSql());
-  }
-}
diff --git a/baremaps-dem/pom.xml b/baremaps-dem/pom.xml
new file mode 100644
index 000000000..bd03f8740
--- /dev/null
+++ b/baremaps-dem/pom.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.apache.baremaps</groupId>
+    <artifactId>baremaps</artifactId>
+    <version>0.7.4-SNAPSHOT</version>
+  </parent>
+  <artifactId>baremaps-dem</artifactId>
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.baremaps</groupId>
+      <artifactId>baremaps-testing</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.locationtech.jts</groupId>
+      <artifactId>jts-core</artifactId>
+    </dependency>
+  </dependencies>
+</project>
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java
new file mode 100644
index 000000000..41e04eb4a
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import org.locationtech.jts.geom.*;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+/**
+ * A geometry transformer that applies the Chaikin smoothing algorithm to a geometry's coordinates.
+ * This class extends the {@link GeometryTransformer} to provide a smoother version of the input
+ * geometry by iteratively applying the Chaikin algorithm, which reduces sharp corners and refines
+ * the shape of geometrical features.
+ */
+public class ChaikinSmoother extends GeometryTransformer {
+
+  private final int iterations;
+
+  private final double factor;
+
+  /**
+   * Constructs a {@code ChaikinSmoother} with the specified number of iterations and factor.
+   *
+   * @param iterations the number of iterations
+   * @param factor the smoothing factor
+   */
+  public ChaikinSmoother(int iterations, double factor) {
+    this.iterations = iterations;
+    this.factor = factor;
+  }
+
+  /**
+   * Transforms the coordinates of a geometry using the Chaikin smoothing algorithm.
+   *
+   * @param coordinateSequence the coordinates to transform
+   * @param parent the parent geometry
+   * @return the transformed coordinates
+   */
+  @Override
+  protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinateSequence,
+      Geometry parent) {
+    return smooth(coordinateSequence, iterations, factor);
+  }
+
+  /**
+   * Smooths the coordinates of a coordinate sequence using the Chaikin algorithm. This method
+   * distinguishes between rings and lines and applies the algorithm accordingly.
+   *
+   * @param coordinateSequence the coordinates to smooth
+   * @param iterations the number of iterations
+   * @param factor the smoothing factor
+   * @return the smoothed coordinates
+   */
+  public static CoordinateSequence smooth(
+      CoordinateSequence coordinateSequence,
+      int iterations,
+      double factor) {
+    if (CoordinateSequences.isRing(coordinateSequence)) {
+      return new CoordinateArraySequence(chaikin(coordinateSequence.toCoordinateArray(), 2, 0.25));
+    } else {
+      Coordinate[] original = coordinateSequence.toCoordinateArray();
+      Coordinate[] smoothed = chaikin(original, iterations, factor);
+      int sumOfSquares = (iterations * (iterations + 1) * (2 * iterations + 1)) / 6;
+      int trimmedLength = smoothed.length - sumOfSquares;
+      Coordinate[] result = new Coordinate[trimmedLength + 2];
+      result[0] = original[0];
+      System.arraycopy(smoothed, 0, result, 1, trimmedLength);
+      result[trimmedLength + 1] = original[original.length - 1];
+      return new CoordinateArraySequence(result);
+    }
+  }
+
+  /**
+   * Applies the Chaikin smoothing algorithm to the specified coordinates.
+   *
+   * @param coordinates the coordinates to smooth
+   * @param iterations the number of iterations
+   * @param factor the smoothing factor
+   * @return the smoothed coordinates
+   */
+  private static Coordinate[] chaikin(
+      Coordinate[] coordinates,
+      int iterations,
+      double factor) {
+    if (iterations <= 0) {
+      return coordinates;
+    }
+
+    for (int i = 0; i < iterations; i++) {
+      int l = coordinates.length;
+      double f1 = 1 - factor;
+      double f2 = factor;
+
+      Coordinate[] smoothed = new Coordinate[l * 2];
+      for (int j = 0; j < l; j++) {
+        Coordinate c1 = coordinates[j];
+        Coordinate c2 = coordinates[(j + 1) % l];
+        smoothed[j * 2] = new Coordinate(
+            f1 * c1.getX() + f2 * c2.getX(),
+            f1 * c1.getY() + f2 * c2.getY());
+        smoothed[j * 2 + 1] = new Coordinate(
+            f2 * c1.getX() + f1 * c2.getX(),
+            f2 * c1.getY() + f1 * c2.getY());
+      }
+
+      coordinates = smoothed;
+    }
+
+    return coordinates;
+  }
+
+}
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java
new file mode 100644
index 000000000..cae349388
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java
@@ -0,0 +1,506 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.util.*;
+import org.locationtech.jts.geom.*;
+import org.locationtech.jts.geom.util.GeometryFixer;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+import org.locationtech.jts.operation.linemerge.LineMerger;
+
+/**
+ * Provides methods for generating contour lines and contour polygons from digital elevation models
+ * (DEMs). All the coordinates are expressed
+ */
+@SuppressWarnings({"squid:S3776", "squid:S135"})
+public class ContourTracer {
+
+  private static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory();
+
+  private static final double EPSILON = 1e-10;
+
+  private final double[] grid;
+
+  private final int width;
+
+  private final int height;
+
+  private final boolean normalize;
+
+  private final boolean polygonize;
+
+  /**
+   * Constructs a new ContourTracer with the specified grid, width, height, normalization, and
+   * polygonization options.
+   *
+   * @param grid The grid of elevation values
+   * @param width The width of the grid
+   * @param height The height of the grid
+   * @param normalize Whether to normalize the coordinates
+   * @param polygonize Whether to polygonize the contours
+   */
+  public ContourTracer(double[] grid, int width, int height, boolean normalize,
+      boolean polygonize) {
+    validateInput(grid, width, height);
+    this.grid = Arrays.copyOf(grid, grid.length);
+    this.width = width;
+    this.height = height;
+    this.normalize = normalize;
+    this.polygonize = polygonize;
+  }
+
+  /**
+   * Generates isolines for a given grid at a specific level.
+   *
+   * @param level The elevation level for which to generate isolines
+   * @return A list of LineString objects representing the isolines
+   */
+  public List<Geometry> traceContours(double level) {
+    // Process each cell in the grid to generate segments
+    List<LineString> cells = new ArrayList<>();
+    for (int y = 0; y < height - 1; y++) {
+      for (int x = 0; x < width - 1; x++) {
+        cells.addAll(processCell(level, x, y));
+      }
+    }
+
+    // Merge the cells
+    List<Geometry> contours = merge(cells);
+
+    // Polygonize the lines
+    if (polygonize) {
+      contours = polygonize(contours);
+    }
+
+    // Normalize the coordinates
+    if (normalize) {
+      contours = normalize(contours);
+    }
+
+    return contours;
+  }
+
+  public List<Geometry> merge(List<LineString> lineStrings) {
+    LineMerger cellMerger = new LineMerger();
+    cellMerger.add(lineStrings);
+    List<Geometry> mergedLineStrings = new ArrayList<>();
+    for (Object geometry : cellMerger.getMergedLineStrings()) {
+      if (geometry instanceof LineString lineString) {
+        mergedLineStrings.add(new GeometryFixer(lineString).getResult());
+      }
+    }
+    return mergedLineStrings;
+  }
+
+  private List<Geometry> polygonize(List<Geometry> geometries) {
+    var polygons = new ArrayList<>(geometries.stream()
+        .map(Geometry::getCoordinates)
+        .map(GEOMETRY_FACTORY::createPolygon)
+        .map(polygon -> new GeometryFixer(polygon).getResult())
+        .map(Polygon.class::cast)
+        .sorted((a, b) -> Double.compare(b.getArea(), a.getArea()))
+        .toList());
+
+    List<Geometry> polygonized = new ArrayList<>();
+    for (int i = 0; i < polygons.size(); i++) {
+      // Skip null polygons
+      if (polygons.get(i) == null) {
+        continue;
+      }
+
+      // Extract the shell and holes
+      Polygon shell = polygons.get(i);
+      List<Polygon> holes = new ArrayList<>();
+      for (int j = i + 1; j < polygons.size(); j++) {
+        // Skip null polygons
+        if (polygons.get(j) == null) {
+          continue;
+        }
+
+        Polygon polygon = polygons.get(j);
+        if (shell.contains(polygon)) {
+
+          // Check if the hole is within a previously found hole
+          boolean within = false;
+          for (Polygon hole : holes) {
+            if (hole.contains(polygon)) {
+              within = true;
+              break;
+            }
+          }
+          if (within) {
+            continue;
+          }
+
+          // Add the hole to the list
+          holes.add(polygon);
+
+          // Set the used polygon to null
+          polygons.set(j, null);
+        }
+      }
+
+      // Combine the shell and holes
+      Polygon combinedPolygon = GEOMETRY_FACTORY.createPolygon(
+          shell.getExteriorRing(),
+          holes.stream()
+              .map(Polygon::getExteriorRing)
+              .toArray(LinearRing[]::new));
+      polygonized.add(combinedPolygon);
+
+      // Set the used polygon to null
+      polygons.set(i, null);
+    }
+
+    return polygonized;
+  }
+
+  private List<Geometry> normalize(List<Geometry> contours) {
+    NormalizationTransformer transformer = new NormalizationTransformer();
+    return contours.stream()
+        .map(geometry -> transformer.transform(geometry.copy()))
+        .toList();
+  }
+
+  /**
+   * Generates contour for a given range of elevation levels.
+   *
+   * @param start The starting elevation level (inclusive)
+   * @param end The ending elevation level (exclusive)
+   * @param interval The interval between elevation levels
+   * @return A list of contour geometries
+   */
+  public List<Geometry> traceContours(int start, int end, int interval) {
+    validateInput(grid, width, height);
+    List<Geometry> contours = new ArrayList<>();
+    for (int level = start; level < end; level += interval) {
+      contours.addAll(traceContours(level));
+    }
+    return contours;
+  }
+
+  /**
+   * Validates the input grid, width, and height.
+   *
+   * @param grid The grid of elevation values
+   * @param width The width of the grid
+   * @param height The height of the grid
+   */
+  private static void validateInput(double[] grid, int width, int height) {
+    if (grid == null || grid.length == 0) {
+      throw new IllegalArgumentException("Grid array cannot be null or empty");
+    }
+    if (width <= 0 || height <= 0) {
+      throw new IllegalArgumentException("Width and height must be positive");
+    }
+    if (grid.length != width * height) {
+      throw new IllegalArgumentException("Grid array length does not match width * height");
+    }
+  }
+
+  /**
+   * Processes a cell in the grid to generate line segments for a given elevation level.
+   *
+   * @param level The elevation level
+   * @param x The x-coordinate of the cell
+   * @param y The y-coordinate of the cell
+   * @return A list of line segments
+   */
+  private List<LineString> processCell(double level, int x, int y) {
+    List<LineString> segments = new ArrayList<>();
+
+    boolean htb = polygonize && y == height - 2;
+    boolean hrb = polygonize && x == width - 2;
+    boolean hbb = polygonize && y == 0;
+    boolean hlb = polygonize && x == 0;
+
+    Coordinate tlc = new Coordinate(x, y + 1.0);
+    Coordinate tmc = interpolateCoordinate(level, x, y + 1, x + 1, y + 1);
+    Coordinate trc = new Coordinate(x + 1.0, y + 1.0);
+    Coordinate mrc = interpolateCoordinate(level, x + 1, y, x + 1, y + 1);
+    Coordinate brc = new Coordinate(x + 1.0, y);
+    Coordinate bmc = interpolateCoordinate(level, x, y, x + 1, y);
+    Coordinate blc = new Coordinate(x, y);
+    Coordinate mlc = interpolateCoordinate(level, x, y, x, y + 1);
+
+    double tlv = grid[y * width + x];
+    double trv = grid[y * width + (x + 1)];
+    double brv = grid[(y + 1) * width + (x + 1)];
+    double blv = grid[(y + 1) * width + x];
+
+    int index =
+        (tlv >= level ? 1 : 0) |
+            (trv >= level ? 2 : 0) |
+            (brv >= level ? 4 : 0) |
+            (blv >= level ? 8 : 0);
+
+    switch (index) {
+      case 1 -> {
+        segments.add(createSegment(mlc, bmc));
+        if (hbb) {
+          segments.add(createSegment(bmc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, mlc));
+        }
+      }
+      case 2 -> {
+        segments.add(createSegment(bmc, mrc));
+        if (hrb) {
+          segments.add(createSegment(mrc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, bmc));
+        }
+      }
+      case 3 -> {
+        segments.add(createSegment(mlc, mrc));
+        if (hrb) {
+          segments.add(createSegment(mrc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, mlc));
+        }
+      }
+      case 4 -> {
+        segments.add(createSegment(mrc, tmc));
+        if (htb) {
+          segments.add(createSegment(tmc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, mrc));
+        }
+      }
+      case 5 -> {
+        segments.add(createSegment(mlc, tmc));
+        if (htb) {
+          segments.add(createSegment(tmc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, mrc));
+        }
+        segments.add(createSegment(mrc, bmc));
+        if (hbb) {
+          segments.add(createSegment(bmc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, mlc));
+        }
+      }
+      case 6 -> {
+        segments.add(createSegment(bmc, tmc));
+        if (htb) {
+          segments.add(createSegment(tmc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, bmc));
+        }
+      }
+      case 7 -> {
+        segments.add(createSegment(mlc, tmc));
+        if (htb) {
+          segments.add(createSegment(tmc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, mlc));
+        }
+      }
+      case 8 -> {
+        segments.add(createSegment(tmc, mlc));
+        if (hlb) {
+          segments.add(createSegment(mlc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, tmc));
+        }
+      }
+      case 9 -> {
+        segments.add(createSegment(tmc, bmc));
+        if (hbb) {
+          segments.add(createSegment(bmc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, tmc));
+        }
+      }
+      case 10 -> {
+        // Detect saddle points ambiguity
+        segments.add(createSegment(bmc, mlc));
+        if (hlb) {
+          segments.add(createSegment(mlc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, tmc));
+        }
+        segments.add(createSegment(tmc, mrc));
+        if (hrb) {
+          segments.add(createSegment(mrc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, bmc));
+        }
+      }
+      case 11 -> {
+        segments.add(createSegment(tmc, mrc));
+        if (hrb) {
+          segments.add(createSegment(mrc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, tmc));
+        }
+      }
+      case 12 -> {
+        segments.add(createSegment(mrc, mlc));
+        if (hlb) {
+          segments.add(createSegment(mlc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, mrc));
+        }
+      }
+      case 13 -> {
+        segments.add(createSegment(mrc, bmc));
+        if (hbb) {
+          segments.add(createSegment(bmc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, mrc));
+        }
+      }
+      case 14 -> {
+        segments.add(createSegment(bmc, mlc));
+        if (hlb) {
+          segments.add(createSegment(mlc, tlc));
+        }
+        if (htb) {
+          segments.add(createSegment(tlc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, bmc));
+        }
+      }
+      case 15 -> {
+        if (htb) {
+          segments.add(createSegment(tlc, trc));
+        }
+        if (hrb) {
+          segments.add(createSegment(trc, brc));
+        }
+        if (hbb) {
+          segments.add(createSegment(brc, blc));
+        }
+        if (hlb) {
+          segments.add(createSegment(blc, tlc));
+        }
+      }
+      default -> {
+        // No segments
+      }
+    }
+
+    return segments;
+  }
+
+  /**
+   * Creates a line segment between two coordinates.
+   *
+   * @param c1 the first coordinate
+   * @param c2 the second coordinate
+   * @return the line segment
+   */
+  private LineString createSegment(Coordinate c1, Coordinate c2) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[] {c1, c2});
+  }
+
+  /**
+   * Interpolates a coordinate between two grid points. This method avoid division by zero by using
+   * a small epsilon value. It also ensures that the extreme values are not reached using the same
+   * epsilon value.
+   *
+   * @param level the elevation level
+   * @param x1 the x-coordinate of the first grid point
+   * @param y1 the y-coordinate of the first grid point
+   * @param x2 the x-coordinate of the second grid point
+   * @param y2 the y-coordinate of the second grid point
+   * @return the interpolated coordinate
+   */
+  private Coordinate interpolateCoordinate(double level, int x1, int y1, int x2, int y2) {
+    double v1 = grid[y1 * width + x1];
+    double v2 = grid[y2 * width + x2];
+    double t = (Math.abs(v2 - v1) < EPSILON) ? 0.5 : (level - v1) / (v2 - v1);
+    if (t < EPSILON) {
+      t = EPSILON;
+    } else if (t > 1 - EPSILON) {
+      t = 1 - EPSILON;
+    }
+    double x = x1 + t * (x2 - x1);
+    double y = y1 + t * (y2 - y1);
+    return new Coordinate(x, y);
+  }
+
+  /**
+   * A transformer that normalizes the coordinates of a geometry.
+   */
+  private class NormalizationTransformer extends GeometryTransformer {
+
+    @Override
+    protected CoordinateSequence transformCoordinates(CoordinateSequence coords, Geometry parent) {
+      for (int i = 0; i < coords.size(); i++) {
+        Coordinate coordinate = coords.getCoordinate(i);
+        double x = coordinate.getX() / width * (width + 1);
+        double y = coordinate.getY() / height * (height + 1);
+        coords.setOrdinate(i, 0, x);
+        coords.setOrdinate(i, 1, y);
+      }
+      return coords;
+    }
+  }
+}
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java
new file mode 100644
index 000000000..4b76b48d7
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.awt.image.BufferedImage;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.IntToDoubleFunction;
+
+/**
+ * Provides utility methods for processing raster images, particularly for elevation data.
+ */
+public class ElevationUtils {
+
+  private static final double ELEVATION_SCALE = 256.0 * 256.0;
+  private static final double ELEVATION_OFFSET = 10000.0;
+  private static final double TERRARIUM_OFFSET = 32768.0;
+
+  private ElevationUtils() {
+    // Prevent instantiation
+  }
+
+  /**
+   * Converts a BufferedImage to a grid of elevation values.
+   *
+   * @param image The input BufferedImage
+   * @return A double array representing the elevation grid
+   */
+  public static double[] imageToGrid(BufferedImage image) {
+    validateImage(image);
+    int width = image.getWidth();
+    int height = image.getHeight();
+    double[] grid = new double[width * height];
+    image.getRaster().getPixels(0, 0, width, height, grid);
+    return grid;
+  }
+
+  /**
+   * Converts a BufferedImage to a grid of elevation values.
+   *
+   * @param image The input BufferedImage
+   * @return A double array representing the elevation grid
+   */
+  public static double[] imageToGrid(BufferedImage image,
+      IntToDoubleFunction pixelToElevation) {
+    validateImage(image);
+    int width = image.getWidth();
+    int height = image.getHeight();
+    double[] grid = new double[width * height];
+
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        int rgb = image.getRGB(x, y);
+        grid[y * width + x] = pixelToElevation.applyAsDouble(rgb);
+      }
+    }
+
+    return grid;
+  }
+
+  /**
+   * Converts a grid of elevation values to a BufferedImage.
+   *
+   * @param grid The input elevation grid
+   * @param width The width of the grid
+   * @param height The height of the grid
+   * @return A BufferedImage representing the elevation data
+   */
+  public static BufferedImage gridToImage(double[] grid, int width, int height,
+      DoubleToIntFunction elevationToPixel) {
+    validateGrid(grid, width, height);
+    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        double elevation = grid[y * width + x];
+        image.setRGB(x, y, elevationToPixel.applyAsInt(elevation));
+      }
+    }
+
+    return image;
+  }
+
+  /**
+   * Validates the input image.
+   *
+   * @param image The input image
+   */
+  private static void validateImage(BufferedImage image) {
+    if (image == null) {
+      throw new IllegalArgumentException("Input image cannot be null");
+    }
+    if (image.getWidth() <= 0 || image.getHeight() <= 0) {
+      throw new IllegalArgumentException("Image dimensions must be positive");
+    }
+  }
+
+  /**
+   * Validates the input grid.
+   *
+   * @param grid The input grid
+   * @param width The width of the grid
+   * @param height The height of the grid
+   */
+  private static void validateGrid(double[] grid, int width, int height) {
+    if (grid == null || grid.length == 0) {
+      throw new IllegalArgumentException("Grid array cannot be null or empty");
+    }
+    if (width <= 0 || height <= 0) {
+      throw new IllegalArgumentException("Width and height must be positive");
+    }
+    if (grid.length != width * height) {
+      throw new IllegalArgumentException("Grid array length does not match width * height");
+    }
+  }
+
+  /**
+   * Inverts the values in the input grid.
+   *
+   * @param grid The input grid
+   * @return The inverted grid
+   */
+  public static double[] invertGrid(double[] grid) {
+    double[] invertedGrid = new double[grid.length];
+    for (int i = 0; i < grid.length; i++) {
+      invertedGrid[i] = 255.0 - grid[i];
+    }
+    return invertedGrid;
+  }
+
+  /**
+   * Clamps the values in the input grid to the specified range.
+   *
+   * @param grid The input grid
+   * @param min The minimum value
+   * @param max The maximum value
+   * @return The clamped grid
+   */
+  public static double[] clampGrid(double[] grid, double min, double max) {
+    double[] clampedGrid = new double[grid.length];
+    for (int i = 0; i < grid.length; i++) {
+      clampedGrid[i] = Math.max(min, Math.min(max, grid[i]));
+    }
+    return clampedGrid;
+  }
+
+  /**
+   * Converts a pixel value to an elevation value using an rgb color scheme.
+   *
+   * @param rgb The rgb pixel value
+   * @return The elevation value
+   */
+  public static double rgbToElevation(int rgb) {
+    int r = (rgb >> 16) & 0xFF;
+    int g = (rgb >> 8) & 0xFF;
+    int b = rgb & 0xFF;
+    return (r * ELEVATION_SCALE + g * 256.0 + b) / 10.0 - ELEVATION_OFFSET;
+  }
+
+  /**
+   * Converts an elevation value to a pixel value using an rgb color scheme.
+   *
+   * @param elevation The elevation value
+   * @return The rgb pixel value
+   */
+  public static int elevationToRgb(double elevation) {
+    int value = (int) ((elevation + ELEVATION_OFFSET) * 10.0);
+    int r = (value >> 16) & 0xFF;
+    int g = (value >> 8) & 0xFF;
+    int b = value & 0xFF;
+    return (r << 16) | (g << 8) | b;
+  }
+
+  /**
+   * Converts a pixel value to an elevation value using the Terrarium color scheme.
+   *
+   * @param rgb The input pixel value
+   * @return The elevation value
+   */
+  public static double terrariumToElevation(int rgb) {
+    int r = (rgb >> 16) & 0xFF;
+    int g = (rgb >> 8) & 0xFF;
+    int b = rgb & 0xFF;
+    return (r * 256.0 + g + b / 256.0) - TERRARIUM_OFFSET;
+  }
+
+  /**
+   * Converts an elevation value to a pixel value using the Terrarium color scheme.
+   *
+   * @param elevation The input elevation value
+   * @return The pixel value
+   */
+  public static int elevationToTerrarium(double elevation) {
+    double adjustedElevation = elevation + TERRARIUM_OFFSET;
+    int r = (int) (adjustedElevation / 256.0);
+    int g = (int) (adjustedElevation % 256.0);
+    int b = (int) ((adjustedElevation - (r * 256.0) - g) * 256.0);
+    return (r << 16) | (g << 8) | b;
+  }
+}
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java
new file mode 100644
index 000000000..38eae5b63
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+/**
+ * Provides methods for generating hillshade effects on digital elevation models (DEMs).
+ */
+public class HillshadeCalculator {
+
+  private static final double EARTH_RADIUS = 6378137; // in meters
+  private static final int TILE_SIZE = 256; // in pixels
+
+  private double[] dem;
+  private int width;
+  private int height;
+  private double cellSize;
+  private double[] hillshade;
+
+  /**
+   * Constructs a HillshadeCalculator with the specified DEM, width, height, and cell size.
+   *
+   * @param dem The digital elevation model
+   * @param width The width of the DEM
+   * @param height The height of the DEM
+   * @param cellSize The cell size of the DEM
+   */
+  public HillshadeCalculator(double[] dem, int width, int height, double cellSize) {
+    this.dem = dem;
+    this.width = width;
+    this.height = height;
+    this.cellSize = cellSize;
+    this.hillshade = new double[width * height];
+  }
+
+  /**
+   * Validates the input parameters for the hillshade calculation.
+   *
+   * @param grid The DEM grid
+   * @param width The width of the DEM
+   * @param height The height of the DEM
+   * @param altitude The altitude of the light source
+   * @param azimuth The azimuth of the light source
+   */
+  private static void validateInput(double[] grid, int width, int height, double altitude,
+      double azimuth) {
+    if (grid == null || grid.length == 0) {
+      throw new IllegalArgumentException("Grid array cannot be null or empty");
+    }
+    if (width <= 0 || height <= 0) {
+      throw new IllegalArgumentException("Width and height must be positive");
+    }
+    if (grid.length != width * height) {
+      throw new IllegalArgumentException("Grid array length does not match width * height");
+    }
+    if (altitude < 0 || altitude > 90) {
+      throw new IllegalArgumentException("Altitude must be between 0 and 90 degrees");
+    }
+    if (azimuth < 0 || azimuth > 360) {
+      throw new IllegalArgumentException("Azimuth must be between 0 and 360 degrees");
+    }
+  }
+
+  /**
+   * Calculates the hillshade effect for the specified altitude and azimuth.
+   *
+   * @param altitude The altitude of the light source
+   * @param azimuth The azimuth of the light source
+   * @return The hillshade effect
+   */
+  public double[] calculate(double altitude, double azimuth) {
+    validateInput(dem, width, height, altitude, azimuth);
+
+    double azimuthDeg = 360.0 - azimuth + 90.0;
+    double azimuthRad = Math.toRadians(azimuthDeg);
+
+    double zenithDeg = 90 - altitude;
+    double zenithRad = Math.toRadians(zenithDeg);
+
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        double a = getElevation(x - 1, y - 1);
+        double b = getElevation(x, y - 1);
+        double c = getElevation(x + 1, y - 1);
+        double d = getElevation(x - 1, y);
+        double f = getElevation(x + 1, y);
+        double g = getElevation(x - 1, y + 1);
+        double h = getElevation(x, y + 1);
+        double i = getElevation(x + 1, y + 1);
+
+        double dzdx = ((c + 2 * f + i) - (a + 2 * d + g)) / (8 * cellSize);
+        double dzdy = ((g + 2 * h + i) - (a + 2 * b + c)) / (8 * cellSize);
+
+        double slopeRad = Math.atan(Math.sqrt(dzdx * dzdx + dzdy * dzdy));
+
+        double aspectRad = Math.atan2(dzdy, -dzdx);
+        if (aspectRad < 0) {
+          aspectRad += 2 * Math.PI;
+        }
+
+        double hillshadeValue = 255.0
+            * ((Math.cos(zenithRad) * Math.cos(slopeRad))
+                + (Math.sin(zenithRad) * Math.sin(slopeRad) * Math.cos(azimuthRad - aspectRad)));
+
+        hillshadeValue = Math.max(0, Math.min(255, hillshadeValue));
+
+        hillshade[y * width + x] = hillshadeValue;
+      }
+    }
+
+    return hillshade;
+  }
+
+  /**
+   * Returns the elevation at the specified coordinates.
+   *
+   * @param x The x-coordinate
+   * @param y The y-coordinate
+   * @return The elevation
+   */
+  public double getElevation(int x, int y) {
+    x = Math.max(0, Math.min(width - 1, x));
+    y = Math.max(0, Math.min(height - 1, y));
+    return dem[y * width + x];
+  }
+
+  /**
+   * Returns the resolution of the specified zoom level.
+   *
+   * @param zoomLevel The zoom level
+   * @return The resolution
+   */
+  public static double getResolution(int zoomLevel) {
+    return (2 * Math.PI * EARTH_RADIUS) / (TILE_SIZE * Math.pow(2, zoomLevel));
+  }
+}
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java
new file mode 100644
index 000000000..1c3701995
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java
@@ -0,0 +1,294 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.awt.image.BufferedImage;
+
+/**
+ * The {@code Martini} class implements the MARTINI algorithm for generating 3D terrain meshes from
+ * height data.
+ *
+ * @see <a href="https://github.com/mapbox/martini">Martini GitHub</a>
+ */
+public class Martini {
+
+  private static final double ELEVATION_OFFSET = 10000.0;
+
+  private final int gridSize;
+  private final int numTriangles;
+  private final int numParentTriangles;
+  private final int[] baseCoords;
+
+  /**
+   * Constructs a new {@code Martini} instance with the specified grid size.
+   *
+   * @param gridSize the grid size (must be 2^n+1)
+   * @throws IllegalArgumentException if the grid size is invalid
+   */
+  public Martini(int gridSize) {
+    this.gridSize = gridSize;
+
+    int tileSize = gridSize - 1;
+    if ((tileSize & (tileSize - 1)) != 0) {
+      throw new IllegalArgumentException("Expected grid size to be 2^n+1, got " + gridSize + ".");
+    }
+
+    this.numTriangles = tileSize * tileSize * 2 - 2;
+    this.numParentTriangles = this.numTriangles - tileSize * tileSize;
+
+    this.baseCoords = new int[this.numTriangles * 4];
+    for (int i = 0; i < this.numTriangles; i++) {
+      int id = i + 2;
+      int ax = 0;
+      int ay = 0;
+      int bx = 0;
+      int by = 0;
+      int cx = 0;
+      int cy = 0;
+      if ((id & 1) != 0) {
+        bx = by = cx = tileSize;
+      } else {
+        ax = ay = cy = tileSize;
+      }
+      while ((id >>= 1) > 1) {
+        int mx = (ax + bx) >> 1;
+        int my = (ay + by) >> 1;
+
+        if ((id & 1) != 0) {
+          bx = ax;
+          by = ay;
+          ax = cx;
+          ay = cy;
+        } else {
+          ax = bx;
+          ay = by;
+          bx = cx;
+          by = cy;
+        }
+        cx = mx;
+        cy = my;
+      }
+      int k = i * 4;
+      this.baseCoords[k] = ax;
+      this.baseCoords[k + 1] = ay;
+      this.baseCoords[k + 2] = bx;
+      this.baseCoords[k + 3] = by;
+    }
+  }
+
+  /**
+   * Creates a terrain grid from a BufferedImage.
+   *
+   * @param image the input image
+   * @return a double array representing the terrain grid
+   */
+  public static double[] createGrid(BufferedImage image) {
+    int gridSize = image.getWidth() + 1;
+    double[] terrain = new double[gridSize * gridSize];
+
+    int tileSize = image.getWidth();
+
+    // decode terrain values
+    for (int y = 0; y < tileSize; y++) {
+      for (int x = 0; x < tileSize; x++) {
+        int r = (image.getRGB(x, y) >> 16) & 0xFF;
+        int g = (image.getRGB(x, y) >> 8) & 0xFF;
+        int b = image.getRGB(x, y) & 0xFF;
+        terrain[y * gridSize + x] = (r * 256 * 256 + g * 256.0f + b) / 10.0f - ELEVATION_OFFSET;
+      }
+    }
+
+    // backfill right and bottom borders
+    for (int x = 0; x < gridSize - 1; x++) {
+      terrain[gridSize * (gridSize - 1) + x] = terrain[gridSize * (gridSize - 2) + x];
+    }
+    for (int y = 0; y < gridSize; y++) {
+      terrain[gridSize * y + gridSize - 1] = terrain[gridSize * y + gridSize - 2];
+    }
+
+    return terrain;
+  }
+
+  /**
+   * Creates a new {@code Tile} instance with the specified terrain data.
+   *
+   * @param terrain the terrain data
+   * @return the tile
+   * @throws IllegalArgumentException if the terrain data is invalid
+   */
+  public Tile createTile(double[] terrain) {
+    return new Tile(terrain, gridSize, numTriangles, numParentTriangles, baseCoords);
+  }
+
+  /**
+   * The {@code Tile} class represents a tile of terrain data.
+   */
+  public static class Tile {
+
+    private final int gridSize;
+    private final int[] indices;
+    private final double[] errors;
+
+    private int numVertices;
+    private int numTriangles;
+
+    private int[] vertices;
+    private int[] triangles;
+    private int triIndex = 0;
+
+    private Tile(
+        double[] terrain,
+        int gridSize,
+        int numTriangles,
+        int numParentTriangles,
+        int[] coords) {
+      if (terrain.length != gridSize * gridSize) {
+        throw new IllegalArgumentException(
+            "Expected terrain data of length " + (gridSize * gridSize) + " (" + gridSize + " x "
+                + gridSize + "), got " + terrain.length + ".");
+      }
+
+      this.gridSize = gridSize;
+      this.indices = new int[this.gridSize * this.gridSize];
+
+      this.errors = new double[terrain.length];
+      for (int i = numTriangles - 1; i >= 0; i--) {
+        int k = i * 4;
+        int ax = coords[k];
+        int ay = coords[k + 1];
+        int bx = coords[k + 2];
+        int by = coords[k + 3];
+        int mx = (ax + bx) >> 1;
+        int my = (ay + by) >> 1;
+        int cx = mx + my - ay;
+        int cy = my + ax - mx;
+
+        double interpolatedHeight = (terrain[ay * gridSize + ax] + terrain[by * gridSize + bx]) / 2;
+        int middleIndex = my * gridSize + mx;
+        double middleError = Math.abs(interpolatedHeight - terrain[middleIndex]);
+
+        errors[middleIndex] = Math.max(errors[middleIndex], middleError);
+
+        if (i < numParentTriangles) {
+          int leftChildIndex = ((ay + cy) >> 1) * gridSize + ((ax + cx) >> 1);
+          int rightChildIndex = ((by + cy) >> 1) * gridSize + ((bx + cx) >> 1);
+          errors[middleIndex] = Math.max(errors[middleIndex],
+              Math.max(errors[leftChildIndex], errors[rightChildIndex]));
+        }
+      }
+    }
+
+    /**
+     * Returns the mesh of the tile with the specified maximum error.
+     *
+     * @param maxError the maximum error
+     * @return the mesh
+     */
+    public Mesh getMesh(double maxError) {
+      int max = gridSize - 1;
+
+      numVertices = 0;
+      numTriangles = 0;
+      countElements(0, 0, max, max, max, 0, maxError);
+      countElements(max, max, 0, 0, 0, max, maxError);
+
+      vertices = new int[numVertices * 2];
+      triangles = new int[numTriangles * 3];
+      triIndex = 0;
+      processTriangle(0, 0, max, max, max, 0, maxError);
+      processTriangle(max, max, 0, 0, 0, max, maxError);
+
+      return new Mesh(vertices, triangles);
+    }
+
+    private void countElements(int ax, int ay, int bx, int by, int cx, int cy, double maxError) {
+      int mx = (ax + bx) >> 1;
+      int my = (ay + by) >> 1;
+
+      if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * gridSize + mx] > maxError) {
+        countElements(cx, cy, ax, ay, mx, my, maxError);
+        countElements(bx, by, cx, cy, mx, my, maxError);
+      } else {
+        indices[ay * gridSize + ax] =
+            indices[ay * gridSize + ax] != 0 ? indices[ay * gridSize + ax] : ++numVertices;
+        indices[by * gridSize + bx] =
+            indices[by * gridSize + bx] != 0 ? indices[by * gridSize + bx] : ++numVertices;
+        indices[cy * gridSize + cx] =
+            indices[cy * gridSize + cx] != 0 ? indices[cy * gridSize + cx] : ++numVertices;
+        numTriangles++;
+      }
+    }
+
+    private void processTriangle(int ax, int ay, int bx, int by, int cx, int cy, double maxError) {
+      int mx = (ax + bx) >> 1;
+      int my = (ay + by) >> 1;
+
+      if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * gridSize + mx] > maxError) {
+        processTriangle(cx, cy, ax, ay, mx, my, maxError);
+        processTriangle(bx, by, cx, cy, mx, my, maxError);
+      } else {
+        int a = indices[ay * gridSize + ax] - 1;
+        int b = indices[by * gridSize + bx] - 1;
+        int c = indices[cy * gridSize + cx] - 1;
+
+        vertices[2 * a] = ax;
+        vertices[2 * a + 1] = ay;
+        vertices[2 * b] = bx;
+        vertices[2 * b + 1] = by;
+        vertices[2 * c] = cx;
+        vertices[2 * c + 1] = cy;
+
+        triangles[triIndex++] = a;
+        triangles[triIndex++] = b;
+        triangles[triIndex++] = c;
+      }
+    }
+  }
+
+  /**
+   * The {@code Mesh} class represents a mesh of vertices and triangles.
+   */
+  public static class Mesh {
+
+    private final int[] vertices;
+    private final int[] triangles;
+
+    private Mesh(int[] vertices, int[] triangles) {
+      this.vertices = vertices;
+      this.triangles = triangles;
+    }
+
+    /**
+     * Returns the vertices of the mesh.
+     *
+     * @return an array of vertex coordinates
+     */
+    public int[] getVertices() {
+      return vertices;
+    }
+
+    /**
+     * Returns the triangles of the mesh.
+     *
+     * @return an array of triangle indices
+     */
+    public int[] getTriangles() {
+      return triangles;
+    }
+  }
+}
diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java
new file mode 100644
index 000000000..63d802b1e
--- /dev/null
+++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+/**
+ * Provides utility methods for processing raster images.
+ */
+public class RasterUtils {
+
+  private RasterUtils() {
+    // Prevent instantiation
+  }
+
+  /**
+   * Resizes a BufferedImage to the specified dimensions.
+   *
+   * @param originalImage The original BufferedImage
+   * @param targetWidth The target width
+   * @param targetHeight The target height
+   * @return The resized BufferedImage
+   */
+  public static BufferedImage resizeImage(
+      BufferedImage originalImage, int targetWidth, int targetHeight) {
+    Image resultingImage =
+        originalImage.getScaledInstance(targetWidth, targetHeight, Image.SCALE_DEFAULT);
+    BufferedImage outputImage =
+        new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB);
+    outputImage.getGraphics().drawImage(resultingImage, 0, 0, null);
+    return outputImage;
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java
new file mode 100644
index 000000000..40df6c7ef
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.LineString;
+
+class ChaikinSmootherTest {
+
+  @Test
+  void smoothLineString() {
+    LineString lineString = new GeometryFactory().createLineString(new Coordinate[] {
+        new Coordinate(0, 0),
+        new Coordinate(1, 1),
+    });
+    Geometry smoothedLineString = new ChaikinSmoother(2, 0.25).transform(lineString);
+    assertEquals("LINESTRING (0 0, 0.375 0.375, 0.625 0.625, 0.75 0.75, 1 1)",
+        smoothedLineString.toString());
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java
new file mode 100644
index 000000000..992b7324f
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.awt.*;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import org.locationtech.jts.geom.Geometry;
+
+/**
+ * A simple renderer that traces contour lines on a raster image. This class is used for testing
+ * purposes only, hence it presence in the test folder.
+ */
+public class ContourRenderer {
+
+  public static void main(String[] args) throws IOException {
+    // Load the image
+    var path = Path.of("")
+        .toAbsolutePath()
+        .resolveSibling("baremaps/baremaps-dem/src/test/resources/fuji.png")
+        .toAbsolutePath().toFile();
+    var image = ImageIO.read(path);
+
+    // Convert the image to a grid
+    double[] grid = ElevationUtils.imageToGrid(image, ElevationUtils::terrariumToElevation);
+
+    // Trace the contours
+    List<Geometry> contours = new ArrayList<>();
+    for (int i = 0; i < 10000; i += 100) {
+      contours.addAll(new ContourTracer(grid, image.getWidth(), image.getHeight(), false, false)
+          .traceContours(i));
+    }
+
+    // Create a frame to display the contours
+    JFrame frame = new JFrame("Contour Lines");
+    frame.setSize(image.getWidth() + 20, image.getHeight() + 48);
+    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    frame.add(new ContourCanvas(image, contours));
+    frame.setVisible(true);
+  }
+
+  // Custom Canvas to draw the contours
+  static class ContourCanvas extends Canvas {
+
+    Image image;
+
+    List<Geometry> contours;
+
+    public ContourCanvas(Image image, List<Geometry> contours) {
+      this.image = image;
+      this.contours = contours;
+    }
+
+    @Override
+    public void paint(Graphics g) {
+
+      // Draw the image
+      g.drawImage(image, 10, 10, null);
+
+      g.setColor(Color.RED);
+      for (Geometry geometry : contours) {
+        List<Point> points = Stream.of(geometry.getCoordinates())
+            .map(p -> new Point((int) p.getX() + 10, (int) p.getY() + 10))
+            .toList();
+        for (int i = 0; i < points.size() - 1; i++) {
+          Point p1 = points.get(i);
+          Point p2 = points.get(i + 1);
+          g.drawLine(p1.x, p1.y, p2.x, p2.y);
+        }
+      }
+    }
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java
new file mode 100644
index 000000000..e11b06a17
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Geometry;
+
+class ContourTracerLineStringTest {
+
+  @Test
+  @DisplayName("Test case 0")
+  void testProcessCellWithCase00() {
+    var lines = trace(MarchingSquareUtils.CASE_00);
+    assertTrue(lines.isEmpty());
+  }
+
+  @Test
+  @DisplayName("Test case 1")
+  void testProcessCellWithCase01() {
+    var lines = trace(MarchingSquareUtils.CASE_01);
+    assertGeometryEquals("LINESTRING (0 0.5, 0.5 0)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 2")
+  void testProcessCellWithCase02() {
+    var lines = trace(MarchingSquareUtils.CASE_02);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 0, 1 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 3")
+  void testProcessCellWithCase03() {
+    var lines = trace(MarchingSquareUtils.CASE_03);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0 0.5, 1 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 4")
+  void testProcessCellWithCase04() {
+    var lines = trace(MarchingSquareUtils.CASE_04);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (1 0.5, 0.5 1)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 5")
+  void testProcessCellWithCase05() {
+    var lines = trace(MarchingSquareUtils.CASE_05);
+    assertEquals(2, lines.size());
+    assertGeometryEquals("LINESTRING (0 0.5, 0.5 1)", lines.get(0));
+    assertGeometryEquals("LINESTRING (1 0.5, 0.5 0)", lines.get(1));
+  }
+
+  @Test
+  @DisplayName("Test case 6")
+  void testProcessCellWithCase06() {
+    var lines = trace(MarchingSquareUtils.CASE_06);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 0, 0.5 1)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 7")
+  void testProcessCellWithCase07() {
+    var lines = trace(MarchingSquareUtils.CASE_07);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0 0.5, 0.5 1)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 8")
+  void testProcessCellWithCase08() {
+    var lines = trace(MarchingSquareUtils.CASE_08);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 1, 0 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 9")
+  void testProcessCellWithCase09() {
+    var lines = trace(MarchingSquareUtils.CASE_09);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 1, 0.5 0)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 10")
+  void testProcessCellWithCase10() {
+    var lines = trace(MarchingSquareUtils.CASE_10);
+    assertEquals(2, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 0, 0 0.5)", lines.get(0));
+    assertGeometryEquals("LINESTRING (0.5 1, 1 0.5)", lines.get(1));
+  }
+
+  @Test
+  @DisplayName("Test case 11")
+  void testProcessCellWithCase11() {
+    var lines = trace(MarchingSquareUtils.CASE_11);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 1, 1 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 12")
+  void testProcessCellWithCase12() {
+    var lines = trace(MarchingSquareUtils.CASE_12);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (1 0.5, 0 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 13")
+  void testProcessCellWithCase13() {
+    var lines = trace(MarchingSquareUtils.CASE_13);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (1 0.5, 0.5 0)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 14")
+  void testProcessCellWithCase14() {
+    var lines = trace(MarchingSquareUtils.CASE_14);
+    assertEquals(1, lines.size());
+    assertGeometryEquals("LINESTRING (0.5 0, 0 0.5)", lines.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 15")
+  void testProcessCellWithCase15() {
+    var lines = trace(MarchingSquareUtils.CASE_15);
+    assertTrue(lines.isEmpty());
+  }
+
+  List<Geometry> trace(double[] grid) {
+    return new ContourTracer(grid, 2, 2, false, false).traceContours(0.5);
+  }
+
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java
new file mode 100644
index 000000000..effeee978
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java
@@ -0,0 +1,191 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.Polygon;
+
+class ContourTracerPolygonTest {
+
+  @Test
+  @DisplayName("Test case 0")
+  void testProcessCellWithCase00() {
+    var polygons = trace(MarchingSquareUtils.CASE_00);
+    assertTrue(polygons.isEmpty());
+  }
+
+  @Test
+  @DisplayName("Test case 1")
+  void testProcessCellWithCase01() {
+    var polygons = trace(MarchingSquareUtils.CASE_01);
+    assertGeometryEquals("POLYGON ((0.5 0, 0 0, 0 0.5, 0.5 0))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 2")
+  void testProcessCellWithCase02() {
+    var polygons = trace(MarchingSquareUtils.CASE_02);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 0.5, 1 0, 0.5 0, 1 0.5))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 3")
+  void testProcessCellWithCase03() {
+    var polygons = trace(MarchingSquareUtils.CASE_03);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0 0, 0 0.5, 1 0.5, 1 0, 0 0))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 4")
+  void testProcessCellWithCase04() {
+    var polygons = trace(MarchingSquareUtils.CASE_04);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 1, 1 0.5, 0.5 1, 1 1))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 5")
+  void testProcessCellWithCase05() {
+    var polygons = trace(MarchingSquareUtils.CASE_05);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 1, 1 0.5, 0.5 0, 0 0, 0 0.5, 0.5 1, 1 1))",
+        polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 6")
+  void testProcessCellWithCase06() {
+    var polygons = trace(MarchingSquareUtils.CASE_06);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0.5 1, 1 1, 1 0, 0.5 0, 0.5 1))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 7")
+  void testProcessCellWithCase07() {
+    var polygons = trace(MarchingSquareUtils.CASE_07);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 1, 1 0, 0 0, 0 0.5, 0.5 1, 1 1))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 8")
+  void testProcessCellWithCase08() {
+    var polygons = trace(MarchingSquareUtils.CASE_08);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0.5 1, 0 0.5, 0 1, 0.5 1))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 9")
+  void testProcessCellWithCase09() {
+    var polygons = trace(MarchingSquareUtils.CASE_09);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0.5 1, 0.5 0, 0 0, 0 1, 0.5 1))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 10")
+  void testProcessCellWithCase10() {
+    var polygons = trace(MarchingSquareUtils.CASE_10);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0.5 1, 1 0.5, 1 0, 0.5 0, 0 0.5, 0 1, 0.5 1))",
+        polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 11")
+  void testProcessCellWithCase11() {
+    var polygons = trace(MarchingSquareUtils.CASE_11);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 0, 0 0, 0 1, 0.5 1, 1 0.5, 1 0))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 12")
+  void testProcessCellWithCase12() {
+    var polygons = trace(MarchingSquareUtils.CASE_12);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((1 0.5, 0 0.5, 0 1, 1 1, 1 0.5))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 13")
+  void testProcessCellWithCase13() {
+    var polygons = trace(MarchingSquareUtils.CASE_13);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0.5 0, 0 0, 0 1, 1 1, 1 0.5, 0.5 0))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 14")
+  void testProcessCellWithCase14() {
+    var polygons = trace(MarchingSquareUtils.CASE_14);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0 0.5, 0 1, 1 1, 1 0, 0.5 0, 0 0.5))", polygons.get(0));
+  }
+
+  @Test
+  @DisplayName("Test case 15")
+  void testProcessCellWithCase15() {
+    var polygons = trace(MarchingSquareUtils.CASE_15);
+    assertEquals(1, polygons.size());
+    assertGeometryEquals("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", polygons.get(0));
+  }
+
+  public static List<Geometry> trace(double[] grid) {
+    int size = (int) Math.sqrt(grid.length);
+    return new ContourTracer(grid, size, size, false, true).traceContours(0.5);
+  }
+
+  @Test
+  @DisplayName("Closed LineString Bug 1")
+  void testProcessCellWithCaseClosedLineStringBug1() {
+    var grid = new double[] {
+        133.3801854240864, 121.23325422569911, 153.52819487296264, 167.57377406292332,
+        100.937349262252, 96.62896517856514, 132.65708268451803, 147.307915356104,
+        98.7659308960914, 104.55934526711907, 141.3071569592299, 151.71211629894563,
+        139.87179431281479, 144.5483699607932, 171.74295402684095, 175.7901414451639
+    };
+    var contours = new ContourTracer(grid, 4, 4, false, true).traceContours(99);
+    assertFalse(contours.isEmpty());
+    assertTrue(contours.stream().allMatch(Polygon.class::isInstance));
+  }
+
+  @Test
+  @DisplayName("Closed LineString Bug 2")
+  void testProcessCellWithCaseClosedLineStringBug2() {
+    var grid = new double[] {
+        491.0, 495.0, 502.0, 503.0,
+        487.0, 493.0, 500.0, 499.0,
+        490.0, 495.0, 500.0, 497.0,
+        499.0, 502.0, 505.0, 500.0,
+    };
+    var contours = new ContourTracer(grid, 4, 4, false, true).traceContours(500);
+    assertFalse(contours.isEmpty());
+    assertTrue(contours.stream().allMatch(Polygon.class::isInstance));
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java
new file mode 100644
index 000000000..f09e4978d
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import javax.imageio.ImageIO;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Polygon;
+
+class ContourTracerTest {
+
+  @Test
+  @DisplayName("Test grid normalization")
+  void testGrid1() {
+    var grid = new double[] {
+        0, 0, 0,
+        0, 1, 0,
+        0, 0, 0,
+    };
+    var generatedContour = new ContourTracer(grid, 3, 3, true, true).traceContours(0).get(0);
+    assertGeometryEquals(
+        "POLYGON ((0 1.3333333333333333, 0 2.6666666666666665, 1.3333333333333333 2.6666666666666665, 2.6666666666666665 2.6666666666666665, 2.6666666666666665 1.3333333333333333, 2.6666666666666665 0, 1.3333333333333333 0, 0 0, 0 1.3333333333333333))",
+        generatedContour);
+  }
+
+  @Test
+  @DisplayName("Test Mount Fuji")
+  void testMountFuji() throws IOException {
+    var fujiImage = ImageIO.read(
+        Path.of("")
+            .toAbsolutePath()
+            .resolveSibling("baremaps-dem/src/test/resources/fuji.png")
+            .toAbsolutePath().toFile());
+
+    var fujiGrid = ElevationUtils.imageToGrid(fujiImage, ElevationUtils::rgbToElevation);
+    var fujiContours =
+        new ContourTracer(fujiGrid, fujiImage.getWidth(), fujiImage.getHeight(), false, true)
+            .traceContours(500);
+
+    assertFalse(fujiContours.isEmpty());
+  }
+
+  @Test
+  @DisplayName("Test polygon with hole and island")
+  void testPolygonWithHole() {
+    var grid = new double[] {
+        1, 1, 1, 1, 1,
+        1, 0, 0, 0, 1,
+        1, 0, 1, 0, 1,
+        1, 0, 0, 0, 1,
+        1, 1, 1, 1, 1,
+    };
+    var generatedContours = new ContourTracer(grid, 5, 5, false, true).traceContours(0.5);
+    assertEquals(2, generatedContours.size());
+    var polygon1 = (Polygon) generatedContours.get(0);
+    var exteriorRing = polygon1.getExteriorRing();
+    var interiorRing = polygon1.getInteriorRingN(0);
+    assertGeometryEquals(
+        "LINEARRING (0 0, 0 1, 0 2, 0 3, 0 4, 1 4, 2 4, 3 4, 4 4, 4 3, 4 2, 4 1, 4 0, 3 0, 2 0, 1 0, 0 0)",
+        exteriorRing);
+    assertGeometryEquals(
+        "LINEARRING (0.5 1, 1 0.5, 2 0.5, 3 0.5, 3.5 1, 3.5 2, 3.5 3, 3 3.5, 2 3.5, 1 3.5, 0.5 3, 0.5 2, 0.5 1)",
+        interiorRing);
+    var polygon2 = (Polygon) generatedContours.get(1);
+    assertGeometryEquals("LINEARRING (1.5 2, 2 2.5, 2.5 2, 2 1.5, 1.5 2)",
+        polygon2.getExteriorRing());
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java
new file mode 100644
index 000000000..21b899f0a
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.nio.file.Path;
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.event.ChangeListener;
+
+public class HillShadeRenderer extends JFrame {
+
+  private BufferedImage originalImage;
+  private double[] grid;
+  private JSlider altitudeSlider;
+  private JSlider azimuthSlider;
+  private JSlider scaleSlider;
+  private JCheckBox isSimpleCheckbox;
+  private JLabel imageLabel;
+  private JLabel altitudeLabel;
+  private JLabel azimuthLabel;
+  private JLabel scaleLabel;
+
+  public HillShadeRenderer() throws IOException {
+    super("Hillshade Display");
+    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+    // Load the image
+    originalImage = ImageIO.read(
+        Path.of("")
+            .toAbsolutePath()
+            .resolveSibling("baremaps/baremaps-dem/src/test/resources/fuji.png")
+            .toAbsolutePath().toFile());
+    grid = ElevationUtils.imageToGrid(originalImage, ElevationUtils::rgbToElevation);
+
+    // Create UI components
+    altitudeSlider = new JSlider(JSlider.VERTICAL, 0, 90, 45);
+    azimuthSlider = new JSlider(JSlider.VERTICAL, 0, 360, 315);
+    scaleSlider = new JSlider(JSlider.HORIZONTAL, 1, 100, 10); // Scale from 0.1 to 10.0
+    isSimpleCheckbox = new JCheckBox("Simple Algorithm", true);
+    imageLabel = new JLabel();
+    altitudeLabel = new JLabel("Sun Altitude: 45°");
+    azimuthLabel = new JLabel("Sun Azimuth: 315°");
+    scaleLabel = new JLabel("Scale: 1.0");
+
+    // Set up sliders
+    altitudeSlider.setMajorTickSpacing(15);
+    altitudeSlider.setPaintTicks(true);
+    altitudeSlider.setPaintLabels(true);
+
+    azimuthSlider.setMajorTickSpacing(45);
+    azimuthSlider.setPaintTicks(true);
+    azimuthSlider.setPaintLabels(true);
+
+    scaleSlider.setMajorTickSpacing(10);
+    scaleSlider.setPaintTicks(true);
+    scaleSlider.setPaintLabels(true);
+
+    // Add listeners
+    ChangeListener listener = e -> {
+      updateLabels();
+      redrawHillshade();
+    };
+    altitudeSlider.addChangeListener(listener);
+    azimuthSlider.addChangeListener(listener);
+    scaleSlider.addChangeListener(listener);
+    isSimpleCheckbox.addActionListener(e -> redrawHillshade());
+
+    // Set up layout
+    setLayout(new BorderLayout());
+    JPanel controlPanel = new JPanel(new GridBagLayout());
+    GridBagConstraints gbc = new GridBagConstraints();
+    gbc.gridx = 0;
+    gbc.gridy = 0;
+    gbc.insets = new Insets(5, 5, 5, 5);
+    controlPanel.add(altitudeLabel, gbc);
+    gbc.gridy++;
+    controlPanel.add(altitudeSlider, gbc);
+    gbc.gridy++;
+    controlPanel.add(azimuthLabel, gbc);
+    gbc.gridy++;
+    controlPanel.add(azimuthSlider, gbc);
+    gbc.gridy++;
+    controlPanel.add(scaleLabel, gbc);
+    gbc.gridy++;
+    controlPanel.add(scaleSlider, gbc);
+    gbc.gridy++;
+    controlPanel.add(isSimpleCheckbox, gbc);
+
+    add(imageLabel, BorderLayout.CENTER);
+    add(controlPanel, BorderLayout.EAST);
+
+    // Initial draw
+    redrawHillshade();
+
+    pack();
+    setVisible(true);
+  }
+
+  private void updateLabels() {
+    altitudeLabel.setText("Sun Altitude: " + altitudeSlider.getValue() + "°");
+    azimuthLabel.setText("Sun Azimuth: " + azimuthSlider.getValue() + "°");
+    scaleLabel.setText("Scale: " + (scaleSlider.getValue() / 10.0));
+  }
+
+  private void redrawHillshade() {
+    int sunAltitude = altitudeSlider.getValue();
+    int sunAzimuth = azimuthSlider.getValue();
+    double scale = scaleSlider.getValue() / 10.0;
+
+    double[] hillshade = new HillshadeCalculator(grid, originalImage.getWidth(),
+        originalImage.getHeight(), scale).calculate(sunAltitude, sunAzimuth);
+
+    BufferedImage hillshadeImage = new BufferedImage(originalImage.getWidth(),
+        originalImage.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
+    for (int y = 0; y < originalImage.getHeight(); y++) {
+      for (int x = 0; x < originalImage.getWidth(); x++) {
+        int shade = (int) hillshade[y * originalImage.getWidth() + x];
+        int rgb = new Color(shade, shade, shade).getRGB();
+        hillshadeImage.setRGB(x, y, rgb);
+      }
+    }
+
+    imageLabel.setIcon(new ImageIcon(hillshadeImage));
+    revalidate();
+    repaint();
+  }
+
+  public static void main(String[] args) {
+    SwingUtilities.invokeLater(() -> {
+      try {
+        new HillShadeRenderer();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    });
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java
new file mode 100644
index 000000000..4d3408dae
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class HillshadeCalculatorTest {
+
+  @Test
+  @DisplayName("Test hillShade with valid input")
+  void testHillShadeValidInput() {
+    double[] dem = {
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9
+    };
+    int width = 3;
+    int height = 3;
+    double sunAltitude = 45;
+    double sunAzimuth = 315;
+
+    double[] result =
+        new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, sunAzimuth);
+
+    assertNotNull(result);
+    assertEquals(dem.length, result.length);
+  }
+
+  @ParameterizedTest
+  @MethodSource("provideInvalidInput")
+  @DisplayName("Test hillShade with invalid input")
+  void testHillShadeInvalidInput(double[] dem, int width, int height, double sunAltitude,
+      double sunAzimuth, Class<? extends Exception> expectedException) {
+    assertThrows(expectedException,
+        () -> new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude,
+            sunAzimuth));
+  }
+
+  @ParameterizedTest
+  @MethodSource("provideInvalidInput")
+  @DisplayName("Test hillShadeEnhanced with invalid input")
+  void testHillShadeEnhancedInvalidInput(double[] dem, int width, int height, double sunAltitude,
+      double sunAzimuth, Class<? extends Exception> expectedException) {
+    assertThrows(expectedException,
+        () -> new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude,
+            sunAzimuth));
+  }
+
+  private static Stream<Arguments> provideInvalidInput() {
+    return Stream.of(
+        Arguments.of(null, 3, 3, 45, 315, IllegalArgumentException.class),
+        Arguments.of(new double[0], 3, 3, 45, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 0, 3, 45, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 3, 0, 45, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 2, 2, 45, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 3, 3, -1, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 3, 3, 91, 315, IllegalArgumentException.class),
+        Arguments.of(new double[9], 3, 3, 45, -1, IllegalArgumentException.class),
+        Arguments.of(new double[9], 3, 3, 45, 361, IllegalArgumentException.class));
+  }
+
+  @Test
+  @DisplayName("Test hillShade output range")
+  void testHillShadeOutputRange() {
+    double[] dem = new double[100];
+    for (int i = 0; i < dem.length; i++) {
+      dem[i] = Math.random() * 1000;
+    }
+    int width = 10;
+    int height = 10;
+    double sunAltitude = 45;
+    double sunAzimuth = 315;
+
+    double[] result =
+        new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, sunAzimuth);
+
+    for (double value : result) {
+      assertTrue(value >= 0 && value <= 255, "Hillshade value should be between 0 and 255");
+    }
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java
new file mode 100644
index 000000000..93966a507
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.apache.baremaps.dem.ContourTracerPolygonTest.*;
+
+import java.awt.*;
+import java.util.List;
+import javax.swing.*;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.util.AffineTransformation;
+
+/**
+ * A simple renderer that displays the cases of the Marching Square algorithm. This class is used
+ * for testing purposes only, hence it presence in the test folder.
+ */
+public class MarchingSquareRenderer extends JPanel {
+  private List<Geometry> geometries;
+
+  public MarchingSquareRenderer(List<Geometry> geometries) {
+    this.geometries = geometries;
+  }
+
+  @Override
+  protected void paintComponent(Graphics g) {
+    super.paintComponent(g);
+    Graphics2D g2d = (Graphics2D) g;
+    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+    g2d.drawRect(718 - 10, 790 - 10, 20, 20);
+
+    for (Geometry geometry : geometries) {
+      if (geometry instanceof Polygon) {
+        drawPolygon(g2d, (Polygon) geometry);
+      }
+      if (geometry instanceof LineString) {
+        drawLineString(g2d, (LineString) geometry);
+      }
+    }
+  }
+
+  private void drawLineString(Graphics2D g2d, LineString geometry) {
+    if (geometry.isClosed()) {
+      g2d.setColor(Color.RED);
+    } else {
+      System.out.println(geometry);
+      g2d.setColor(Color.BLUE);
+    }
+
+    Coordinate[] coordinates = geometry.getCoordinates();
+    int[] xPoints = new int[coordinates.length];
+    int[] yPoints = new int[coordinates.length];
+
+    for (int i = 0; i < coordinates.length; i++) {
+      xPoints[i] = (int) coordinates[i].getX();
+      yPoints[i] = (int) coordinates[i].getY();
+    }
+
+    g2d.drawPolyline(xPoints, yPoints, coordinates.length);
+  }
+
+  private void drawPolygon(Graphics2D g2d, Polygon polygon) {
+    Coordinate[] coordinates = polygon.getCoordinates();
+    int[] xPoints = new int[coordinates.length];
+    int[] yPoints = new int[coordinates.length];
+
+    for (int i = 0; i < coordinates.length; i++) {
+      xPoints[i] = (int) coordinates[i].getX();
+      yPoints[i] = (int) coordinates[i].getY();
+    }
+
+    g2d.drawPolygon(xPoints, yPoints, coordinates.length);
+  }
+
+  public static void main(String[] args) {
+    JFrame frame = new JFrame("Geometry Drawer");
+
+    JPanel mainPanel = new JPanel(new GridLayout(4, 4));
+    for (double[] c : MarchingSquareUtils.CASES) {
+
+      List<Geometry> geometries = trace(c)
+          .stream()
+          .map(AffineTransformation.scaleInstance(50, 50).translate(0, 0)::transform)
+          .toList();
+
+      MarchingSquareRenderer drawer = new MarchingSquareRenderer(geometries);
+      mainPanel.add(drawer);
+    }
+
+    frame.add(mainPanel);
+    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    frame.setLocationRelativeTo(null); // Center the frame on the screen
+    frame.setVisible(true);
+  }
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java
new file mode 100644
index 000000000..c7e8fec57
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import java.util.List;
+
+public class MarchingSquareUtils {
+
+  public static final double[] CASE_00 = {
+      0, 0,
+      0, 0,
+  };
+
+  public static final double[] CASE_01 = {
+      1, 0,
+      0, 0,
+  };
+
+  public static final double[] CASE_02 = {
+      0, 1,
+      0, 0,
+  };
+
+  public static final double[] CASE_03 = {
+      1, 1,
+      0, 0,
+  };
+
+  public static final double[] CASE_04 = {
+      0, 0,
+      0, 1,
+  };
+
+  public static final double[] CASE_05 = {
+      1, 0,
+      0, 1,
+  };
+
+  public static final double[] CASE_06 = {
+      0, 1,
+      0, 1,
+  };
+
+  public static final double[] CASE_07 = {
+      1, 1,
+      0, 1,
+  };
+
+  public static final double[] CASE_08 = {
+      0, 0,
+      1, 0,
+  };
+
+  public static final double[] CASE_09 = {
+      1, 0,
+      1, 0,
+  };
+
+  public static final double[] CASE_10 = {
+      0, 1,
+      1, 0,
+  };
+
+  public static final double[] CASE_11 = {
+      1, 1,
+      1, 0,
+  };
+
+  public static final double[] CASE_12 = {
+      0, 0,
+      1, 1,
+  };
+
+  public static final double[] CASE_13 = {
+      1, 0,
+      1, 1,
+  };
+
+  public static final double[] CASE_14 = {
+      0, 1,
+      1, 1,
+  };
+
+  public static final double[] CASE_15 = {
+      1, 1,
+      1, 1,
+  };
+
+  public static final List<double[]> CASES = List.of(
+      CASE_00, CASE_01, CASE_02, CASE_03,
+      CASE_04, CASE_05, CASE_06, CASE_07,
+      CASE_08, CASE_09, CASE_10, CASE_11,
+      CASE_12, CASE_13, CASE_14, CASE_15);
+
+  public static final double[] buffer(double[] grid) {
+    return new double[] {
+        0, 0, 0, 0,
+        0, grid[0], grid[1], 0,
+        0, grid[2], grid[3], 0,
+        0, 0, 0, 0,
+    };
+  }
+
+  public static final List<double[]> BUFFERED_CASES = List.of(
+      buffer(CASE_00), buffer(CASE_01), buffer(CASE_02), buffer(CASE_03),
+      buffer(CASE_04), buffer(CASE_05), buffer(CASE_06), buffer(CASE_07),
+      buffer(CASE_08), buffer(CASE_09), buffer(CASE_10), buffer(CASE_11),
+      buffer(CASE_12), buffer(CASE_13), buffer(CASE_14), buffer(CASE_15));
+
+
+
+}
diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java
new file mode 100644
index 000000000..b978b6a35
--- /dev/null
+++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.dem;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import javax.imageio.ImageIO;
+import org.junit.jupiter.api.Test;
+
+class MartiniTest {
+
+  @Test
+  void generateAMesh() throws IOException {
+    var png = ImageIO.read(
+        Path.of("")
+            .toAbsolutePath()
+            .resolveSibling("baremaps-dem/src/test/resources/fuji.png")
+            .toAbsolutePath().toFile());
+    var terrainGrid = Martini.createGrid(png);
+    var martini = new Martini(png.getWidth() + 1);
+    var tile = martini.createTile(terrainGrid);
+    var mesh = tile.getMesh(500);
+
+    assertArrayEquals(new int[] {
+        320, 64, 256, 128, 320, 128, 384, 128, 256, 0, 288, 160, 256, 192, 288, 192, 320, 192, 304,
+        176, 256, 256, 288, 224, 352, 160, 320, 160, 512, 0, 384, 0, 128, 128, 128, 0, 64, 64, 64,
+        0, 0, 0, 32, 32, 192, 192, 384, 384, 512, 256, 384, 256, 320, 320, 320, 256, 512, 512, 512,
+        128, 448, 192, 384, 192, 128, 384, 256, 512, 256, 384, 0, 512, 128, 256, 64, 192, 0, 256,
+        64, 128, 32, 96, 0, 128, 32, 64, 16, 48, 0, 64, 0, 32
+    }, mesh.getVertices());
+
+    assertArrayEquals(new int[] {
+        0, 1, 2, 3, 0, 2, 4, 1, 0, 5, 6, 7, 7, 8, 9, 5, 7, 9, 1, 6, 5, 6, 10, 11, 11, 8, 7, 6, 11,
+        7, 12, 2, 13, 8, 12, 13, 3, 2, 12, 2, 1, 5, 13, 5, 9, 8, 13, 9, 2, 5, 13, 3, 14, 15, 15, 4,
+        0, 3, 15, 0, 16, 4, 17, 18, 17, 19, 19, 20, 21, 18, 19, 21, 16, 17, 18, 1, 16, 22, 22, 10,
+        6, 1, 22, 6, 4, 16, 1, 23, 24, 25, 26, 25, 27, 10, 26, 27, 23, 25, 26, 28, 24, 23, 29, 3,
+        30, 24, 29, 30, 14, 3, 29, 8, 25, 31, 31, 3, 12, 8, 31, 12, 27, 8, 11, 10, 27, 11, 25, 8,
+        27, 25, 24, 30, 30, 3, 31, 25, 30, 31, 32, 33, 34, 10, 32, 34, 35, 33, 32, 33, 28, 23, 34,
+        23, 26, 10, 34, 26, 33, 23, 34, 36, 16, 37, 38, 36, 37, 36, 10, 22, 16, 36, 22, 39, 18, 40,
+        41, 39, 40, 16, 18, 39, 42, 21, 43, 44, 42, 43, 18, 21, 42, 21, 20, 45, 45, 44, 43, 21, 45,
+        43, 44, 41, 40, 40, 18, 42, 44, 40, 42, 41, 38, 37, 37, 16, 39, 41, 37, 39, 38, 35, 32, 32,
+        10, 36, 38, 32, 36
+    }, mesh.getTriangles());
+  }
+}
diff --git a/baremaps-dem/src/test/resources/fuji.png b/baremaps-dem/src/test/resources/fuji.png
new file mode 100644
index 000000000..9e4e8b766
Binary files /dev/null and b/baremaps-dem/src/test/resources/fuji.png differ
diff --git a/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java b/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java
index e0d6813e7..d58944096 100644
--- a/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java
+++ b/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java
@@ -21,6 +21,7 @@
 
 import org.apache.baremaps.openstreetmap.function.ProjectionTransformer;
 import org.locationtech.jts.geom.*;
+import org.locationtech.jts.geom.util.AffineTransformation;
 import org.locationtech.jts.io.ParseException;
 import org.locationtech.jts.io.WKBReader;
 import org.locationtech.jts.io.WKBWriter;
@@ -34,13 +35,15 @@ public class GeometryUtils {
   public static final GeometryFactory GEOMETRY_FACTORY_WGS84 =
       new GeometryFactory(new PrecisionModel(), 4326);
 
-  private GeometryUtils() {}
+  private GeometryUtils() {
+    // Prevent instantiation
+  }
 
   /**
    * Serializes a geometry in the WKB format.
    *
-   * @param geometry
-   * @return
+   * @param geometry the geometry to serialize
+   * @return the serialized geometry
    */
   public static byte[] serialize(Geometry geometry) {
     if (geometry == null) {
@@ -53,8 +56,8 @@ public static byte[] serialize(Geometry geometry) {
   /**
    * Deserializes a geometry in the WKB format.
    *
-   * @param wkb
-   * @return
+   * @param wkb the serialized geometry
+   * @return the deserialized geometry
    */
   public static Geometry deserialize(byte[] wkb) {
     if (wkb == null) {
@@ -93,4 +96,34 @@ public static ProjectionTransformer projectionTransformer(int inputSRID, int out
     return new ProjectionTransformer(inputSRID, outputSRID);
   }
 
+  /**
+   * Scales a geometry by a factor.
+   *
+   * @param geometry The geometry to scale
+   * @param factor The factor to scale by
+   * @return The scaled geometry
+   */
+  public static Geometry scale(Geometry geometry, double factor) {
+    AffineTransformation transform = AffineTransformation.scaleInstance(factor, factor);
+    return transform.transform(geometry);
+  }
+
+  /**
+   * Creates an envelope with the provided bounds.
+   *
+   * @param xMin the minimum x coordinate
+   * @param yMin the minimum y coordinate
+   * @param xMax the maximum x coordinate
+   * @param yMax the maximum y coordinate
+   * @return the envelope geometry
+   */
+  public static Geometry createEnvelope(int xMin, int yMin, int xMax, int yMax) {
+    return new GeometryFactory().createPolygon(new Coordinate[] {
+        new Coordinate(xMin, yMin),
+        new Coordinate(xMin, yMax),
+        new Coordinate(xMax, yMax),
+        new Coordinate(xMax, yMin),
+        new Coordinate(xMin, yMin)
+    });
+  }
 }
diff --git a/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java b/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java
new file mode 100644
index 000000000..e3d8b32eb
--- /dev/null
+++ b/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.baremaps.server;
+
+import static com.google.common.net.HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN;
+import static com.google.common.net.HttpHeaders.CONTENT_TYPE;
+
+import com.linecorp.armeria.common.HttpData;
+import com.linecorp.armeria.common.HttpResponse;
+import com.linecorp.armeria.common.ResponseHeaders;
+import com.linecorp.armeria.server.annotation.Blocking;
+import com.linecorp.armeria.server.annotation.Get;
+import com.linecorp.armeria.server.annotation.Param;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.util.function.Supplier;
+import javax.imageio.ImageIO;
+import org.apache.baremaps.tilestore.TileCoord;
+import org.apache.baremaps.tilestore.TileStore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A resource that serves raster tiles as PNG images.
+ */
+public class BufferedImageResource {
+
+  private static final Logger logger =
+      LoggerFactory.getLogger(BufferedImageResource.class);
+
+  public static final String TILE_TYPE = "image/png";
+
+  private final Supplier<TileStore<BufferedImage>> tileStoreSupplier;
+
+  /**
+   * Constructs a {@code BufferedImageResource} with the specified tile store supplier.
+   *
+   * @param tileStoreSupplier the tile store supplier
+   */
+  public BufferedImageResource(Supplier<TileStore<BufferedImage>> tileStoreSupplier) {
+    this.tileStoreSupplier = tileStoreSupplier;
+  }
+
+  /**
+   * Serves a raster tile as a PNG image.
+   *
+   * @param z the zoom level
+   * @param x the x coordinate
+   * @param y the y coordinate
+   * @return the HTTP response
+   */
+  @Get("regex:^/(?<z>[0-9]+)/(?<x>[0-9]+)/(?<y>[0-9]+).png")
+  @Blocking
+  public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y) {
+    TileCoord tileCoord = new TileCoord(x, y, z);
+    TileStore<BufferedImage> tileStore = tileStoreSupplier.get();
+    try (var outputStream = new ByteArrayOutputStream()) {
+      BufferedImage bufferedImage = tileStore.read(tileCoord);
+      if (bufferedImage != null) {
+        var headers = ResponseHeaders.builder(200)
+            .add(CONTENT_TYPE, TILE_TYPE)
+            .add(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .build();
+        ImageIO.write(bufferedImage, "png", outputStream);
+        HttpData data = HttpData.wrap(outputStream.toByteArray());
+        return HttpResponse.of(headers, data);
+      } else {
+        return HttpResponse.of(204);
+      }
+    } catch (Exception ex) {
+      logger.error("Error while reading tile.", ex);
+      return HttpResponse.of(404);
+    }
+  }
+}
diff --git a/baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java b/baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java
similarity index 76%
rename from baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java
rename to baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java
index 964ac158c..58e6e439a 100644
--- a/baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java
+++ b/baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java
@@ -34,28 +34,36 @@
 import org.slf4j.LoggerFactory;
 
 /**
- * A resource that provides access to the tiles.
+ * A resource that serves vector tiles as Mapbox Vector Tiles.
  */
-public class TileResource {
+public class VectorTileResource {
 
-  private static final Logger logger = LoggerFactory.getLogger(TileResource.class);
+  private static final Logger logger = LoggerFactory.getLogger(VectorTileResource.class);
 
   public static final String TILE_ENCODING = "gzip";
 
   public static final String TILE_TYPE = "application/vnd.mapbox-vector-tile";
 
-  private final Supplier<TileStore> tileStoreSupplier;
+  private final Supplier<TileStore<ByteBuffer>> tileStoreSupplier;
 
-  public TileResource(Supplier<TileStore> tileStoreSupplier) {
+  /**
+   * Constructs a {@code VectorTileResource} with the specified tile store supplier.
+   *
+   * @param tileStoreSupplier the tile store supplier
+   */
+  public VectorTileResource(Supplier<TileStore<ByteBuffer>> tileStoreSupplier) {
     this.tileStoreSupplier = tileStoreSupplier;
   }
 
-  @Get("regex:^/tiles/(?<z>[0-9]+)/(?<x>[0-9]+)/(?<y>[0-9]+).mvt$")
+  /**
+   * Serves a vector tile as a Mapbox Vector Tile.
+   */
+  @Get("regex:^/(?<z>[0-9]+)/(?<x>[0-9]+)/(?<y>[0-9]+).mvt$")
   @Blocking
   public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y) {
     TileCoord tileCoord = new TileCoord(x, y, z);
     try {
-      TileStore tileStore = tileStoreSupplier.get();
+      TileStore<ByteBuffer> tileStore = tileStoreSupplier.get();
       ByteBuffer blob = tileStore.read(tileCoord);
       if (blob != null) {
         var headers = ResponseHeaders.builder(200)
@@ -72,7 +80,7 @@ public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y
         return HttpResponse.of(204);
       }
     } catch (TileStoreException ex) {
-      logger.error("Error while reading tile.", ex);
+      logger.error("Error while reading tile {}", tileCoord, ex);
       return HttpResponse.of(404);
     }
   }
diff --git a/baremaps-server/src/main/resources/dem/favicon.ico b/baremaps-server/src/main/resources/dem/favicon.ico
new file mode 100644
index 000000000..7162b07e3
Binary files /dev/null and b/baremaps-server/src/main/resources/dem/favicon.ico differ
diff --git a/baremaps-server/src/main/resources/dem/index.html b/baremaps-server/src/main/resources/dem/index.html
new file mode 100644
index 000000000..6cde71c29
--- /dev/null
+++ b/baremaps-server/src/main/resources/dem/index.html
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>DEM</title>
+    <meta property="og:description" content="Digital Elevation Model (DEM)" />
+    <meta charset='utf-8'>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <script src="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.js" integrity="sha256-RU7N55x2fpxos26u6Mrn26qPlDih4ZiqZMstWPipnGE=" crossorigin="anonymous"></script>
+    <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js" integrity="sha256-NYdRoIbqeAWkTHjpa/BukMLXcsiqFoDuJCYzzaRei30=" crossorigin="anonymous"></script>
+    <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js" integrity="sha256-Jo8NvxMzooqayU8+eIsjO49b4EoakoE0o0tSSrBWPCU=" crossorigin="anonymous"></script>
+    <script src="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.js" integrity="sha256-80a3VIbp5OJ8HSIWJ7+6NjTvdBmVirLCR6otKucXnlw=" crossorigin="anonymous"></script>
+    <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-framerate.js" integrity="sha256-6IVzv2heNDAl7KkSqjRkmjr56asfkdCxO2q8ouTo8t8=" crossorigin="anonymous"></script>
+    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.css" integrity="sha256-V2sIX92Uh6ZaGSFTKMHghsB85b9toJtmazgG09AI2uk=" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css" integrity="sha256-ePhsoaklgbCBxK7kfSUcP+V+bVqnfFwpILz7hkSR0Lo=" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css" integrity="sha256-FxIRliWXnU67sT1i97MgNQ0qL8LjsgYiBH9v/uNxzdM=" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.css" integrity="sha256-rFc19qrZTPgcrNeYjtsLCcDOqM5NrLiPy2U+0FxW9vA=" crossorigin="anonymous">
+    <link rel="icon" type="image/x-icon" href="https://baremaps.apache.org/assets/favicon/favicon.ico">
+    <style>
+        body { margin: 0; padding: 0; }
+        html, body, #map { height: 100%; }
+    </style>
+</head>
+<body>
+<div id="map"></div>
+<script>
+    const map = (window.map = new maplibregl.Map({
+        antialias: true,
+        container: 'map',
+        zoom: 11,
+        center: [11.5519, 47.2719],
+        hash: true,
+        style: {
+            version: 8,
+            sources: {
+                rasterElevationSource: {
+                    type: 'raster',
+                    'tiles': [
+                        'http://localhost:9000/raster/elevation/{z}/{x}/{y}.png'
+                    ],
+                    tileSize: 256
+                },
+                rasterHillshadeSource: {
+                    type: 'raster',
+                    'tiles': [
+                        'http://localhost:9000/raster/hillshade/{z}/{x}/{y}.png'
+                    ],
+                    tileSize: 256
+                },
+                vectorContourSource: {
+                    type: 'vector',
+                    tiles: [
+                        'http://localhost:9000/vector/contour/{z}/{x}/{y}.mvt'
+                    ],
+                },
+                vectorHillshadeSource: {
+                    type: 'vector',
+                    tiles: [
+                        'http://localhost:9000/vector/hillshade/{z}/{x}/{y}.mvt'
+                    ],
+                },
+            },
+            layers: [
+                {
+                    'id': 'background',
+                    'type': 'background',
+                    'paint': {
+                        'background-color': '#bdbdbd'
+                    }
+                },
+                {
+                    'id': 'rasterElevation',
+                    'type': 'raster',
+                    'source': 'rasterElevationSource',
+                    'paint': {
+                        'raster-opacity': 0.5
+                    }
+                },
+                {
+                    'id': 'rasterHillshade',
+                    'type': 'raster',
+                    'source': 'rasterHillshadeSource',
+                    'paint': {
+                        'raster-opacity': 0.5
+                    }
+                },
+                {
+                    'id': 'vectorHillshade',
+                    'type': 'fill',
+                    'source': 'vectorHillshadeSource',
+                    'source-layer': 'elevation',
+                    "layout" : {
+                        "visibility" : "visible",
+                        "fill-sort-key": [
+                            "match",
+                            ["get", "level"],
+                            "1", 6,
+                            "2", 5,
+                            "3", 1,
+                            "4", 2,
+                            "5", 3,
+                            "6", 4,
+                            0
+                        ],
+                    },
+                    "paint" : {
+                        "fill-color" : [
+                            "match",
+                            ["get", "level"],
+                            "1", "#ffffff",
+                            "2", "#d9d9d9",
+                            "3", "#919191",
+                            "4", "#595959",
+                            "5", "#343434",
+                            "6", "#181818",
+                            "rgba(0,0,0,0)"
+                        ],
+                        "fill-opacity" : 0.8,
+                        "fill-antialias" : false,
+                    }
+                },
+
+                {
+                    'id': 'vectorContour',
+                    'type': 'line',
+                    'source': 'vectorContourSource',
+                    'source-layer': 'contour',
+                    "layout" : {
+                        "visibility" : "visible",
+                    },
+                    "paint" : {
+                        "line-color" : "#000000",
+                    }
+                },
+            ],
+        },
+        maxZoom: 18,
+        maxPitch: 85
+    }));
+
+    map.addControl(
+        new maplibregl.NavigationControl({
+            visualizePitch: false,
+            showZoom: true,
+            showCompass: true
+        })
+    );
+
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/baremaps-server/src/main/resources/static/server.html b/baremaps-server/src/main/resources/static/server.html
index d5ef77521..6c74e9a02 100644
--- a/baremaps-server/src/main/resources/static/server.html
+++ b/baremaps-server/src/main/resources/static/server.html
@@ -17,12 +17,15 @@
 -->
 <html lang="en">
 <head>
-  <script src="https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.js" integrity="sha256-qmQe97oAYERiVjChfXOO7hB6XvtPv+LURdheDkwjygk=" crossorigin="anonymous"></script>
+  <script src="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.js" integrity="sha256-RU7N55x2fpxos26u6Mrn26qPlDih4ZiqZMstWPipnGE=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js" integrity="sha256-NYdRoIbqeAWkTHjpa/BukMLXcsiqFoDuJCYzzaRei30=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js" integrity="sha256-Jo8NvxMzooqayU8+eIsjO49b4EoakoE0o0tSSrBWPCU=" crossorigin="anonymous"></script>
-  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.css" integrity="sha256-xOYnscyMgBG9kd6rZmIRZiBVqaN+CGquVtFHJS9018U=" crossorigin="anonymous">
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.js" integrity="sha256-80a3VIbp5OJ8HSIWJ7+6NjTvdBmVirLCR6otKucXnlw=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-framerate.js" integrity="sha256-6IVzv2heNDAl7KkSqjRkmjr56asfkdCxO2q8ouTo8t8=" crossorigin="anonymous"></script>
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.css" integrity="sha256-V2sIX92Uh6ZaGSFTKMHghsB85b9toJtmazgG09AI2uk=" crossorigin="anonymous">
   <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css" integrity="sha256-ePhsoaklgbCBxK7kfSUcP+V+bVqnfFwpILz7hkSR0Lo=" crossorigin="anonymous">
   <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css" integrity="sha256-FxIRliWXnU67sT1i97MgNQ0qL8LjsgYiBH9v/uNxzdM=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.css" integrity="sha256-rFc19qrZTPgcrNeYjtsLCcDOqM5NrLiPy2U+0FxW9vA=" crossorigin="anonymous">
   <link rel="icon" type="image/x-icon" href="https://baremaps.apache.org/assets/favicon/favicon.ico">
   <style>
 
diff --git a/baremaps-server/src/main/resources/static/viewer.html b/baremaps-server/src/main/resources/static/viewer.html
index 75b3b773a..cf00c992b 100644
--- a/baremaps-server/src/main/resources/static/viewer.html
+++ b/baremaps-server/src/main/resources/static/viewer.html
@@ -17,12 +17,12 @@
 -->
 <html lang="en">
 <head>
-  <script src="https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.js" integrity="sha256-qmQe97oAYERiVjChfXOO7hB6XvtPv+LURdheDkwjygk=" crossorigin="anonymous"></script>
+  <script src="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.js" integrity="sha256-RU7N55x2fpxos26u6Mrn26qPlDih4ZiqZMstWPipnGE=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js" integrity="sha256-NYdRoIbqeAWkTHjpa/BukMLXcsiqFoDuJCYzzaRei30=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js" integrity="sha256-Jo8NvxMzooqayU8+eIsjO49b4EoakoE0o0tSSrBWPCU=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.js" integrity="sha256-80a3VIbp5OJ8HSIWJ7+6NjTvdBmVirLCR6otKucXnlw=" crossorigin="anonymous"></script>
   <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-framerate.js" integrity="sha256-6IVzv2heNDAl7KkSqjRkmjr56asfkdCxO2q8ouTo8t8=" crossorigin="anonymous"></script>
-  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.css" integrity="sha256-xOYnscyMgBG9kd6rZmIRZiBVqaN+CGquVtFHJS9018U=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.css" integrity="sha256-V2sIX92Uh6ZaGSFTKMHghsB85b9toJtmazgG09AI2uk=" crossorigin="anonymous">
   <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css" integrity="sha256-ePhsoaklgbCBxK7kfSUcP+V+bVqnfFwpILz7hkSR0Lo=" crossorigin="anonymous">
   <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css" integrity="sha256-FxIRliWXnU67sT1i97MgNQ0qL8LjsgYiBH9v/uNxzdM=" crossorigin="anonymous">
   <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.css" integrity="sha256-rFc19qrZTPgcrNeYjtsLCcDOqM5NrLiPy2U+0FxW9vA=" crossorigin="anonymous">
diff --git a/baremaps-testing/src/main/java/org/apache/baremaps/testing/GeometryAssertions.java b/baremaps-testing/src/main/java/org/apache/baremaps/testing/GeometryAssertions.java
index d8e8e837b..d7c8bc89e 100644
--- a/baremaps-testing/src/main/java/org/apache/baremaps/testing/GeometryAssertions.java
+++ b/baremaps-testing/src/main/java/org/apache/baremaps/testing/GeometryAssertions.java
@@ -19,8 +19,12 @@
 
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.PrecisionModel;
+import org.locationtech.jts.io.WKTReader;
 import org.locationtech.jts.precision.GeometryPrecisionReducer;
 
+/**
+ * Utility methods for comparing geometries.
+ */
 public class GeometryAssertions {
 
   private GeometryAssertions() {
@@ -31,6 +35,41 @@ private static void throwAssertionError(Object expected, Object actual) {
     throw new AssertionError("Expected " + expected + " but was " + actual);
   }
 
+  /**
+   * Asserts that two geometries are equal.
+   *
+   * @param expected the expected wkt geometry
+   * @param actual the actual wkt geometry
+   */
+  public static void assertGeometryEquals(String expected, String actual) {
+    try {
+      var reader = new WKTReader();
+      assertGeometryEquals(reader.read(expected), reader.read(expected));
+    } catch (Exception e) {
+      throwAssertionError(expected, actual);
+    }
+  }
+
+  /**
+   * Asserts that two geometries are equal.
+   *
+   * @param expected the expected wkt geometry
+   * @param actual the actual jts geometry
+   */
+  public static void assertGeometryEquals(String expected, Geometry actual) {
+    try {
+      assertGeometryEquals(new WKTReader().read(expected), actual);
+    } catch (Exception e) {
+      throwAssertionError(expected, actual);
+    }
+  }
+
+  /**
+   * Asserts that two geometries are equal.
+   *
+   * @param expected the expected jts geometry
+   * @param actual the actual jts geometry
+   */
   public static void assertGeometryEquals(Geometry expected, Geometry actual) {
     if (expected == null && actual == null) {
       return;
@@ -38,11 +77,18 @@ public static void assertGeometryEquals(Geometry expected, Geometry actual) {
     if (expected == null || actual == null) {
       throwAssertionError(expected, actual);
     }
-    if (!expected.equalsExact(actual)) {
+    if (!expected.equals(actual)) {
       throwAssertionError(expected, actual);
     }
   }
 
+  /**
+   * Asserts that two geometries are approximately equal within a tolerance.
+   *
+   * @param expected the expected jts geometry
+   * @param actual the actual jts geometry
+   * @param tolerance the tolerance factor
+   */
   public static void assertGeometryEquals(Geometry expected, Geometry actual, double tolerance) {
     if (expected == null && actual == null) {
       return;
diff --git a/baremaps-testing/src/main/java/org/apache/baremaps/testing/TestFiles.java b/baremaps-testing/src/main/java/org/apache/baremaps/testing/TestFiles.java
index 2f47d2d69..4e7e2e2a9 100644
--- a/baremaps-testing/src/main/java/org/apache/baremaps/testing/TestFiles.java
+++ b/baremaps-testing/src/main/java/org/apache/baremaps/testing/TestFiles.java
@@ -70,6 +70,12 @@ private TestFiles() {
   public static final Path GEOPARQUET =
       resolve("baremaps-testing/data/samples/example.parquet");
 
+  public static final Path TILESET_JSON =
+      resolve("baremaps-testing/data/tilesets/tileset.json");
+
+  public static final Path TILEJSON_JSON =
+      resolve("baremaps-testing/data/tilesets/tilejson.json");
+
   /* The geometries of the osm-sample/sample.osm.xml file */
 
   private static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory();
diff --git a/basemap/index.html b/basemap/index.html
index 940c72f6a..6c74e9a02 100644
--- a/basemap/index.html
+++ b/basemap/index.html
@@ -17,12 +17,15 @@
 -->
 <html lang="en">
 <head>
-  <script src='https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.js'></script>
-  <script src='https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js'></script>
-  <script src='https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js'></script>
-  <link href='https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.css' rel='stylesheet' />
-  <link href='https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css' rel='stylesheet' />
-  <link href='https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css' rel='stylesheet' />
+  <script src="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.js" integrity="sha256-RU7N55x2fpxos26u6Mrn26qPlDih4ZiqZMstWPipnGE=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js" integrity="sha256-NYdRoIbqeAWkTHjpa/BukMLXcsiqFoDuJCYzzaRei30=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js" integrity="sha256-Jo8NvxMzooqayU8+eIsjO49b4EoakoE0o0tSSrBWPCU=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.js" integrity="sha256-80a3VIbp5OJ8HSIWJ7+6NjTvdBmVirLCR6otKucXnlw=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-framerate.js" integrity="sha256-6IVzv2heNDAl7KkSqjRkmjr56asfkdCxO2q8ouTo8t8=" crossorigin="anonymous"></script>
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.css" integrity="sha256-V2sIX92Uh6ZaGSFTKMHghsB85b9toJtmazgG09AI2uk=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css" integrity="sha256-ePhsoaklgbCBxK7kfSUcP+V+bVqnfFwpILz7hkSR0Lo=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css" integrity="sha256-FxIRliWXnU67sT1i97MgNQ0qL8LjsgYiBH9v/uNxzdM=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.css" integrity="sha256-rFc19qrZTPgcrNeYjtsLCcDOqM5NrLiPy2U+0FxW9vA=" crossorigin="anonymous">
   <link rel="icon" type="image/x-icon" href="https://baremaps.apache.org/assets/favicon/favicon.ico">
   <style>
 
diff --git a/examples/openstreetmap/index.html b/examples/openstreetmap/index.html
index 940c72f6a..6c74e9a02 100644
--- a/examples/openstreetmap/index.html
+++ b/examples/openstreetmap/index.html
@@ -17,12 +17,15 @@
 -->
 <html lang="en">
 <head>
-  <script src='https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.js'></script>
-  <script src='https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js'></script>
-  <script src='https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js'></script>
-  <link href='https://unpkg.com/maplibre-gl@4.0.2/dist/maplibre-gl.css' rel='stylesheet' />
-  <link href='https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css' rel='stylesheet' />
-  <link href='https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css' rel='stylesheet' />
+  <script src="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.js" integrity="sha256-RU7N55x2fpxos26u6Mrn26qPlDih4ZiqZMstWPipnGE=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.js" integrity="sha256-NYdRoIbqeAWkTHjpa/BukMLXcsiqFoDuJCYzzaRei30=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.js" integrity="sha256-Jo8NvxMzooqayU8+eIsjO49b4EoakoE0o0tSSrBWPCU=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.js" integrity="sha256-80a3VIbp5OJ8HSIWJ7+6NjTvdBmVirLCR6otKucXnlw=" crossorigin="anonymous"></script>
+  <script src="https://baremaps.apache.org/assets/maplibre/maplibre-gl-framerate.js" integrity="sha256-6IVzv2heNDAl7KkSqjRkmjr56asfkdCxO2q8ouTo8t8=" crossorigin="anonymous"></script>
+  <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@4.5.0/dist/maplibre-gl.css" integrity="sha256-V2sIX92Uh6ZaGSFTKMHghsB85b9toJtmazgG09AI2uk=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-inspect.css" integrity="sha256-ePhsoaklgbCBxK7kfSUcP+V+bVqnfFwpILz7hkSR0Lo=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-gl-tile-boundaries.css" integrity="sha256-FxIRliWXnU67sT1i97MgNQ0qL8LjsgYiBH9v/uNxzdM=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://baremaps.apache.org/assets/maplibre/maplibre-custom-controls.css" integrity="sha256-rFc19qrZTPgcrNeYjtsLCcDOqM5NrLiPy2U+0FxW9vA=" crossorigin="anonymous">
   <link rel="icon" type="image/x-icon" href="https://baremaps.apache.org/assets/favicon/favicon.ico">
   <style>
 
diff --git a/pom.xml b/pom.xml
index 75f89b46b..3afb754d0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,6 +50,7 @@ limitations under the License.
     <module>baremaps-cli</module>
     <module>baremaps-core</module>
     <module>baremaps-data</module>
+    <module>baremaps-dem</module>
     <module>baremaps-flatgeobuf</module>
     <module>baremaps-geoparquet</module>
     <module>baremaps-maplibre</module>
@@ -102,6 +103,7 @@ limitations under the License.
     <version.lib.proj4j>1.3.0</version.lib.proj4j>
     <version.lib.protobuf>4.28.0</version.lib.protobuf>
     <version.lib.roaringbitmap>1.2.1</version.lib.roaringbitmap>
+    <version.lib.sis>1.4</version.lib.sis>
     <version.lib.slf4j>2.0.16</version.lib.slf4j>
     <version.lib.sqlite>3.46.1.0</version.lib.sqlite>
     <version.lib.testcontainers>1.20.1</version.lib.testcontainers>
@@ -126,7 +128,6 @@ limitations under the License.
 
   <dependencyManagement>
     <dependencies>
-
       <dependency>
         <groupId>com.aayushatharva.brotli4j</groupId>
         <artifactId>native-linux-aarch64</artifactId>
@@ -264,11 +265,21 @@ limitations under the License.
         <artifactId>baremaps-data</artifactId>
         <version>${project.parent.version}</version>
       </dependency>
+      <dependency>
+        <groupId>org.apache.baremaps</groupId>
+        <artifactId>baremaps-dem</artifactId>
+        <version>${project.parent.version}</version>
+      </dependency>
       <dependency>
         <groupId>org.apache.baremaps</groupId>
         <artifactId>baremaps-flatgeobuf</artifactId>
         <version>${project.parent.version}</version>
       </dependency>
+      <dependency>
+        <groupId>org.apache.baremaps</groupId>
+        <artifactId>baremaps-gdal</artifactId>
+        <version>${project.parent.version}</version>
+      </dependency>
       <dependency>
         <groupId>org.apache.baremaps</groupId>
         <artifactId>baremaps-geoparquet</artifactId>
@@ -388,12 +399,32 @@ limitations under the License.
         <artifactId>parquet-hadoop</artifactId>
         <version>${version.lib.parquet}</version>
       </dependency>
+      <dependency>
+        <groupId>org.apache.sis.storage</groupId>
+        <artifactId>sis-geotiff</artifactId>
+        <version>${version.lib.sis}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.sis.storage</groupId>
+        <artifactId>sis-sqlstore</artifactId>
+        <version>${version.lib.sis}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.sis.storage</groupId>
+        <artifactId>sis-storage</artifactId>
+        <version>${version.lib.sis}</version>
+      </dependency>
       <dependency>
         <groupId>org.awaitility</groupId>
         <artifactId>awaitility</artifactId>
         <version>${version.lib.awaitability}</version>
         <scope>test</scope>
       </dependency>
+      <dependency>
+        <groupId>org.gdal</groupId>
+        <artifactId>gdal</artifactId>
+        <version>${version.lib.gdal}</version>
+      </dependency>
       <dependency>
         <groupId>org.graalvm.js</groupId>
         <artifactId>js</artifactId>