diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/MatrixHandler.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/MatrixHandler.kt
index 23b7487ec..04f23479b 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/MatrixHandler.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/MatrixHandler.kt
@@ -113,7 +113,8 @@ class MatrixHandler(
         val fov = calculateFOV()
         val view = camera.view.view
         val eyePosition = view.eyePosition
-        val matrixPosition = view.matrixPosition
+        context.camera.offset.draw()
+        val matrixPosition = Vec3(eyePosition - context.camera.offset.offset)
         val front = view.front
         if (upToDate && matrixPosition == this.matrixPosition && front == this.front && fov == previousFOV && shaking.isEmpty) {
             return
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/WorldOffset.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/WorldOffset.kt
index 956b5e673..dc62f6933 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/WorldOffset.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/WorldOffset.kt
@@ -17,15 +17,23 @@ import de.bixilon.kotlinglm.vec3.Vec3i
 import de.bixilon.kutil.observer.DataObserver.Companion.observed
 import de.bixilon.minosoft.data.world.World
 import de.bixilon.minosoft.gui.rendering.renderer.drawable.Drawable
+import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.blockPosition
+import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.EMPTY
 import de.bixilon.minosoft.protocol.protocol.ProtocolDefinition
 
 class WorldOffset(private val camera: Camera) : Drawable {
-    var offset by observed(Vec3i(100, 100, 100))
+    var offset by observed(Vec3i.EMPTY)
         private set
 
     override fun draw() {
         val previous = offset
         val position = camera.view.view.eyePosition
+
+        val mod = (position.blockPosition / MAX_DISTANCE) * MAX_DISTANCE
+        if (mod != previous) {
+            this.offset = mod
+        }
+        // TODO: optimize this and use MIN_DISTANCE
     }
 
 
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/CameraView.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/CameraView.kt
index 652fcb72f..5e3371634 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/CameraView.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/CameraView.kt
@@ -32,7 +32,6 @@ interface CameraView {
     val updateFrustum: Boolean get() = true
 
     val eyePosition: Vec3d
-    val matrixPosition: Vec3
 
     val rotation: EntityRotation
     val front: Vec3
@@ -49,12 +48,4 @@ interface CameraView {
 
 
     fun draw() = Unit
-
-
-    companion object {
-
-        fun CameraView.matrix(eye: Vec3d): Vec3 {
-            return Vec3(eye - context.camera.offset.offset)
-        }
-    }
 }
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/DebugView.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/DebugView.kt
index 950ba83ac..881f5f5ab 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/DebugView.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/DebugView.kt
@@ -20,7 +20,6 @@ import de.bixilon.minosoft.data.entities.EntityRotation
 import de.bixilon.minosoft.gui.rendering.RenderContext
 import de.bixilon.minosoft.gui.rendering.camera.Camera
 import de.bixilon.minosoft.gui.rendering.camera.CameraDefinition.CAMERA_UP_VEC3
-import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
 import de.bixilon.minosoft.input.camera.MovementInputActions
@@ -32,7 +31,6 @@ class DebugView(private val camera: Camera) : CameraView {
     override val shaking: Boolean get() = false
 
     override var eyePosition = Vec3d.EMPTY
-    override var matrixPosition = Vec3.EMPTY
 
     override var rotation = EntityRotation.EMPTY
     override var front = Vec3.EMPTY
@@ -65,7 +63,6 @@ class DebugView(private val camera: Camera) : CameraView {
         movement *= delta
 
         eyePosition = eyePosition + movement
-        this.matrixPosition = matrix(this.eyePosition)
     }
 
     override fun onMouse(delta: Vec2d) {
@@ -79,7 +76,6 @@ class DebugView(private val camera: Camera) : CameraView {
 
     override fun onAttach(previous: CameraView?) {
         this.eyePosition = previous?.eyePosition ?: Vec3d.EMPTY
-        this.matrixPosition = matrix(this.eyePosition)
         this.rotation = previous?.rotation ?: EntityRotation.EMPTY
         this.front = previous?.front ?: Vec3.EMPTY
     }
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/FirstPersonView.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/FirstPersonView.kt
index cd94fdb22..ce29e5eb9 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/FirstPersonView.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/FirstPersonView.kt
@@ -22,7 +22,6 @@ import de.bixilon.minosoft.data.entities.entities.player.PlayerEntity
 import de.bixilon.minosoft.gui.rendering.RenderContext
 import de.bixilon.minosoft.gui.rendering.camera.Camera
 import de.bixilon.minosoft.gui.rendering.camera.view.CameraView
-import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
 
@@ -41,7 +40,6 @@ class FirstPersonView(override val camera: Camera) : PersonView {
     override val renderOverlays: Boolean get() = true
 
     override var eyePosition: Vec3d = Vec3d.EMPTY
-    override var matrixPosition: Vec3 = Vec3.EMPTY
 
     override var rotation = EntityRotation.EMPTY
     override var front = Vec3.EMPTY
@@ -56,7 +54,6 @@ class FirstPersonView(override val camera: Camera) : PersonView {
     private fun update() {
         val entity = context.connection.camera.entity
         this.eyePosition = entity.renderInfo.eyePosition
-        this.matrixPosition = matrix(this.eyePosition)
         this.rotation = entity.physics.rotation
         this.front = this.rotation.front
     }
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/ThirdPersonView.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/ThirdPersonView.kt
index b07f4b2e2..804fcb585 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/ThirdPersonView.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/ThirdPersonView.kt
@@ -20,7 +20,6 @@ import de.bixilon.minosoft.data.entities.EntityRotation
 import de.bixilon.minosoft.gui.rendering.RenderContext
 import de.bixilon.minosoft.gui.rendering.camera.Camera
 import de.bixilon.minosoft.gui.rendering.camera.view.CameraView
-import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
 import de.bixilon.minosoft.gui.rendering.util.VecUtil.toVec3d
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
@@ -32,7 +31,6 @@ class ThirdPersonView(override val camera: Camera) : PersonView {
     override val context: RenderContext get() = camera.context
 
     override var eyePosition: Vec3d = Vec3d.EMPTY
-    override var matrixPosition: Vec3 = Vec3.EMPTY
 
     override var rotation = EntityRotation.EMPTY
     override var front = Vec3.EMPTY
@@ -62,7 +60,6 @@ class ThirdPersonView(override val camera: Camera) : PersonView {
         val distance = target?.distance?.let { minOf(it, MAX_DISTANCE) } ?: MAX_DISTANCE
 
         this.eyePosition = position + (-front * distance)
-        this.matrixPosition = matrix(this.eyePosition)
     }
 
     override fun onAttach(previous: CameraView?) {
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudArray.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudArray.kt
index 48d6cb2f6..9b5a09ff5 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudArray.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudArray.kt
@@ -27,6 +27,7 @@ class CloudArray(
     }
 
     private fun build() {
+        val offset = layer.clouds.context.camera.offset.offset
         val matrix = layer.clouds.matrix
         val matrixOffset = (offset * ARRAY_SIZE) and 0xFF
 
@@ -47,7 +48,7 @@ class CloudArray(
                     matrix[matrixX - 1, matrixZ + 0], // WEST
                     matrix[matrixX + 1, matrixZ + 0], // EAST
                 )
-                mesh.createCloud(start, start + CLOUD_SIZE, layer.height.first, layer.height.last, layer.clouds.flat, cull)
+                mesh.createCloud(start, start + CLOUD_SIZE, offset, layer.height.first, layer.height.last, layer.clouds.flat, cull)
             }
         }
     }
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudMesh.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudMesh.kt
index 103b21bf8..18291d78c 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudMesh.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudMesh.kt
@@ -16,6 +16,7 @@ package de.bixilon.minosoft.gui.rendering.sky.clouds
 import de.bixilon.kotlinglm.vec2.Vec2
 import de.bixilon.kotlinglm.vec2.Vec2i
 import de.bixilon.kotlinglm.vec3.Vec3
+import de.bixilon.kotlinglm.vec3.Vec3i
 import de.bixilon.minosoft.data.direction.Directions
 import de.bixilon.minosoft.gui.rendering.RenderContext
 import de.bixilon.minosoft.gui.rendering.system.base.MeshUtil.buffer
@@ -30,9 +31,9 @@ class CloudMesh(context: RenderContext) : Mesh(context, CloudMeshStruct, context
     }
 
 
-    fun createCloud(start: Vec2i, end: Vec2i, yStart: Int, yEnd: Int, flat: Boolean, culling: BooleanArray) {
-        val start = Vec3(start.x, yStart, start.y) + CLOUD_OFFSET
-        val end = Vec3(end.x, yEnd, end.y) + CLOUD_OFFSET
+    fun createCloud(start: Vec2i, end: Vec2i, offset: Vec3i, yStart: Int, yEnd: Int, flat: Boolean, culling: BooleanArray) {
+        val start = Vec3(start.x - offset.x, yStart - offset.y, start.y - offset.z) + CLOUD_OFFSET
+        val end = Vec3(end.x - offset.x, yEnd - offset.y, end.y - offset.z) + CLOUD_OFFSET
 
         addYQuad(Vec2(start.x, start.z), start.y, Vec2(end.x, end.z)) { position, _ -> addVertex(position, Directions.DOWN) }
         if (!flat) {
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt
index 309fb03f6..4ac0d2218 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt
@@ -113,6 +113,7 @@ class WorldRenderer(
                 paused = false
             }
         }
+        context.camera.offset::offset.observe(this) { silentlyClearChunkCache() }
 
         context.inputHandler.registerKeyCallback("minosoft:clear_chunk_cache".toResourceLocation(), KeyBinding(
             KeyActions.MODIFIER to setOf(KeyCodes.KEY_F3),
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/world/border/WorldBorderRenderer.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/world/border/WorldBorderRenderer.kt
index 2289f4320..3bda890f0 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/world/border/WorldBorderRenderer.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/world/border/WorldBorderRenderer.kt
@@ -15,6 +15,7 @@ package de.bixilon.minosoft.gui.rendering.world.border
 
 import de.bixilon.kotlinglm.func.common.clamp
 import de.bixilon.kotlinglm.vec2.Vec2
+import de.bixilon.kotlinglm.vec2.Vec2d
 import de.bixilon.kutil.latch.CountUpAndDownLatch
 import de.bixilon.kutil.time.TimeUtil.millis
 import de.bixilon.minosoft.data.registries.identified.Namespaces.minosoft
@@ -86,7 +87,8 @@ class WorldBorderRenderer(
         color = color.with(alpha = (strength * strength))
         shader.tintColor = color
         shader.radius = border.diameter.toFloat() / 2.0f
-        shader.center = Vec2(border.center)
+        val offset = context.camera.offset.offset
+        shader.center = Vec2(border.center - Vec2d(offset.x, offset.z))
     }
 
     override fun drawTranslucent() {
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/world/chunk/ChunkBorderRenderer.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/world/chunk/ChunkBorderRenderer.kt
index ffe9ea7f0..c0bf9beed 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/world/chunk/ChunkBorderRenderer.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/world/chunk/ChunkBorderRenderer.kt
@@ -32,6 +32,7 @@ import de.bixilon.minosoft.gui.rendering.system.base.RenderSystem
 import de.bixilon.minosoft.gui.rendering.system.base.phases.OpaqueDrawable
 import de.bixilon.minosoft.gui.rendering.util.mesh.LineMesh
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.blockPosition
+import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.EMPTY
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.chunkPosition
 import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.sectionHeight
 import de.bixilon.minosoft.protocol.network.connection.play.PlayConnection
@@ -45,6 +46,7 @@ class ChunkBorderRenderer(
 ) : AsyncRenderer, OpaqueDrawable, MeshSwapper {
     private val profile = connection.profiles.rendering
     override val renderSystem: RenderSystem = context.renderSystem
+    private var offset = Vec3i.EMPTY
     private var chunkPosition: Vec2i? = null
     private var sectionHeight: Int = Int.MIN_VALUE
 
@@ -77,52 +79,54 @@ class ChunkBorderRenderer(
         val eyePosition = connection.camera.entity.renderInfo.eyePosition.blockPosition
         val chunkPosition = eyePosition.chunkPosition
         val sectionHeight = eyePosition.sectionHeight
-        if (chunkPosition == this.chunkPosition && sectionHeight == this.sectionHeight && mesh != null) {
+        val offset = context.camera.offset.offset
+        if (chunkPosition == this.chunkPosition && sectionHeight == this.sectionHeight && this.offset == offset && mesh != null) {
             return
         }
         unload = true
         val mesh = LineMesh(context)
 
         val dimension = context.connection.world.dimension
-        val basePosition = chunkPosition * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z)
+        val basePosition = chunkPosition * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z) - Vec2i(offset.x, offset.z)
 
-        mesh.drawInnerChunkLines(basePosition, dimension)
+        mesh.drawInnerChunkLines(Vec3i(basePosition.x, -offset.y, basePosition.y), dimension)
 
         if (sectionHeight in dimension.minSection until dimension.maxSection) {
             mesh.drawSectionLines(Vec3i(basePosition.x, sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y, basePosition.y))
         }
 
-        mesh.drawOuterChunkLines(chunkPosition, dimension)
+        mesh.drawOuterChunkLines(chunkPosition, offset, dimension)
 
-        this.nextMesh = mesh
         this.chunkPosition = chunkPosition
         this.sectionHeight = sectionHeight
+        this.offset = offset
+        this.nextMesh = mesh
     }
 
-    private fun LineMesh.drawOuterChunkLines(chunkPosition: Vec2i, dimension: DimensionProperties) {
+    private fun LineMesh.drawOuterChunkLines(chunkPosition: Vec2i, offset: Vec3i, dimension: DimensionProperties) {
         for (x in -OUTER_CHUNK_SIZE..OUTER_CHUNK_SIZE + 1) {
             for (z in -OUTER_CHUNK_SIZE..OUTER_CHUNK_SIZE + 1) {
                 if ((x == 0 || x == 1) && (z == 0 || z == 1)) {
                     continue
                 }
-                val chunkBase = (chunkPosition + Vec2i(x, z)) * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z)
-                drawLine(Vec3(chunkBase.x + 0, dimension.minY, chunkBase.y), Vec3(chunkBase.x + 0, dimension.maxY + 1, chunkBase.y), OUTER_CHUNK_LINE_WIDTH, OUTER_CHUNK_COLOR)
+                val chunkBase = (chunkPosition + Vec2i(x, z)) * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z) - Vec2i(offset.x, offset.z)
+                drawLine(Vec3(chunkBase.x + 0, dimension.minY - offset.y, chunkBase.y), Vec3(chunkBase.x + 0, dimension.maxY - offset.y + 1, chunkBase.y), OUTER_CHUNK_LINE_WIDTH, OUTER_CHUNK_COLOR)
             }
         }
     }
 
-    private fun LineMesh.drawInnerChunkLines(basePosition: Vec2i, dimension: DimensionProperties) {
-        drawLine(Vec3(basePosition.x + 0, dimension.minY, basePosition.y), Vec3(basePosition.x + 0, dimension.maxY + 1, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-        drawLine(Vec3(basePosition.x, dimension.minY, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, dimension.maxY + 1, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-        drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.minY, basePosition.y + 0), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.maxY + 1, basePosition.y + 0), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-        drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.minY, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.maxY + 1, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+    private fun LineMesh.drawInnerChunkLines(basePosition: Vec3i, dimension: DimensionProperties) {
+        drawLine(Vec3(basePosition.x + 0, basePosition.y + dimension.minY, basePosition.z), Vec3(basePosition.x + 0, basePosition.y + dimension.maxY + 1, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+        drawLine(Vec3(basePosition.x, basePosition.y + dimension.minY, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, basePosition.y + dimension.maxY + 1, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+        drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.minY, basePosition.z + 0), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.maxY + 1, basePosition.z + 0), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+        drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.minY, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.maxY + 1, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
 
         for (sectionHeight in dimension.minSection..dimension.maxSection) {
-            val y = sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
-            drawLine(Vec3(basePosition.x, y, basePosition.y), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-            drawLine(Vec3(basePosition.x, y, basePosition.y), Vec3(basePosition.x, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-            drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
-            drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+            val y = basePosition.y + sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
+            drawLine(Vec3(basePosition.x, y, basePosition.z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+            drawLine(Vec3(basePosition.x, y, basePosition.z), Vec3(basePosition.x, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+            drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
+            drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
         }
     }
 
diff --git a/src/main/java/de/bixilon/minosoft/gui/rendering/world/preparer/cull/FluidCullSectionPreparer.kt b/src/main/java/de/bixilon/minosoft/gui/rendering/world/preparer/cull/FluidCullSectionPreparer.kt
index f7f8f710a..e16a5e5ae 100644
--- a/src/main/java/de/bixilon/minosoft/gui/rendering/world/preparer/cull/FluidCullSectionPreparer.kt
+++ b/src/main/java/de/bixilon/minosoft/gui/rendering/world/preparer/cull/FluidCullSectionPreparer.kt
@@ -68,6 +68,8 @@ class FluidCullSectionPreparer(
         var rendered = false
         var tint: Int
 
+        val cameraOffset = context.camera.offset.offset
+
         val offsetX = chunkPosition.x * ProtocolDefinition.SECTION_WIDTH_X
         val offsetY = sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
         val offsetZ = chunkPosition.y * ProtocolDefinition.SECTION_WIDTH_Z
@@ -130,6 +132,8 @@ class FluidCullSectionPreparer(
                         getCornerHeight(chunk, chunkPosition, position + Directions.SOUTH, fluid),
                     )
 
+                    val offsetPosition = Vec3(position - cameraOffset)
+
                     if (!skip[Directions.O_UP]) {
                         val velocity = fluid.getVelocity(blockState, position, chunk)
                         val still = velocity.x == 0.0 && velocity.z == 0.0
@@ -164,10 +168,10 @@ class FluidCullSectionPreparer(
                         val meshToUse = texture.transparency.getMesh(mesh)
 
                         val positions = arrayOf(
-                            Vec3(position.x, position.y + cornerHeights[0], position.z),
-                            Vec3(position.x + 1, position.y + cornerHeights[1], position.z),
-                            Vec3(position.x + 1, position.y + cornerHeights[2], position.z + 1),
-                            Vec3(position.x, position.y + cornerHeights[3], position.z + 1),
+                            Vec3(offsetPosition.x, offsetPosition.y + cornerHeights[0], offsetPosition.z),
+                            Vec3(offsetPosition.x + 1, offsetPosition.y + cornerHeights[1], offsetPosition.z),
+                            Vec3(offsetPosition.x + 1, offsetPosition.y + cornerHeights[2], offsetPosition.z + 1),
+                            Vec3(offsetPosition.x, offsetPosition.y + cornerHeights[3], offsetPosition.z + 1),
                         )
 
 
@@ -182,9 +186,9 @@ class FluidCullSectionPreparer(
                         if (skip[Directions.SIDE_OFFSET + direction]) {
                             continue
                         }
-                        var faceX = position.x.toFloat()
+                        var faceX = offsetPosition.x
                         var faceXEnd = faceX
-                        var faceZ = position.z.toFloat()
+                        var faceZ = offsetPosition.z
                         var faceZEnd = faceZ
                         var v1 = 0.0f
                         var v2 = 0.0f
@@ -222,10 +226,10 @@ class FluidCullSectionPreparer(
 
 
                         val positions = arrayOf(
-                            Vec3(faceX, position.y + v1, faceZ),
-                            Vec3(faceX, position.y, faceZ),
-                            Vec3(faceXEnd, position.y, faceZEnd),
-                            Vec3(faceXEnd, position.y + v2, faceZEnd),
+                            Vec3(faceX, offsetPosition.y + v1, faceZ),
+                            Vec3(faceX, offsetPosition.y, faceZ),
+                            Vec3(faceXEnd, offsetPosition.y, faceZEnd),
+                            Vec3(faceXEnd, offsetPosition.y + v2, faceZEnd),
                         )
                         val texturePositions = arrayOf(
                             TEXTURE_1,