diff --git a/src/main/java/net/minestom/server/entity/Entity.java b/src/main/java/net/minestom/server/entity/Entity.java
index 73c4c9859..ad98f4641 100644
--- a/src/main/java/net/minestom/server/entity/Entity.java
+++ b/src/main/java/net/minestom/server/entity/Entity.java
@@ -127,11 +127,6 @@ public class Entity implements Viewable, Tickable, Schedulable, TagHandler, Perm
         public void remove(@NotNull Entity entity) {
             viewEngine.handleAutoViewRemoval(entity);
         }
-
-        @Override
-        public void updateTracker(@NotNull Point point, @Nullable EntityTracker tracker) {
-            viewEngine.updateTracker(point, tracker);
-        }
     };
 
     protected final ViewEngine viewEngine = new ViewEngine(this,
diff --git a/src/main/java/net/minestom/server/instance/EntityTracker.java b/src/main/java/net/minestom/server/instance/EntityTracker.java
index 14fb7b277..f9e633b44 100644
--- a/src/main/java/net/minestom/server/instance/EntityTracker.java
+++ b/src/main/java/net/minestom/server/instance/EntityTracker.java
@@ -162,8 +162,6 @@ public sealed interface EntityTracker permits EntityTrackerImpl {
         void add(@NotNull E entity);
 
         void remove(@NotNull E entity);
-
-        void updateTracker(@NotNull Point point, @Nullable EntityTracker tracker);
     }
 
     /**
diff --git a/src/main/java/net/minestom/server/instance/EntityTrackerImpl.java b/src/main/java/net/minestom/server/instance/EntityTrackerImpl.java
index 49d3aac8a..ec91f3180 100644
--- a/src/main/java/net/minestom/server/instance/EntityTrackerImpl.java
+++ b/src/main/java/net/minestom/server/instance/EntityTrackerImpl.java
@@ -44,7 +44,6 @@ final class EntityTrackerImpl implements EntityTracker {
                 if (newEntity == entity) return;
                 update.add(newEntity);
             });
-            update.updateTracker(point, this);
         }
     }
 
@@ -60,7 +59,6 @@ final class EntityTrackerImpl implements EntityTracker {
         }
         if (update != null) {
             visibleEntities(point, target, update::remove);
-            update.updateTracker(point, null);
         }
     }
 
@@ -79,8 +77,17 @@ final class EntityTrackerImpl implements EntityTracker {
                 }
             }
             if (update != null) {
-                difference(oldPoint, newPoint, target, update);
-                update.updateTracker(newPoint, this);
+                difference(oldPoint, newPoint, target, new Update<>() {
+                    @Override
+                    public void add(@NotNull T added) {
+                        if (entity != added) update.add(added);
+                    }
+
+                    @Override
+                    public void remove(@NotNull T removed) {
+                        if (entity != removed) update.remove(removed);
+                    }
+                });
             }
         }
     }
diff --git a/src/test/java/instance/EntityTrackerTest.java b/src/test/java/instance/EntityTrackerTest.java
index fc280f833..808a0f0af 100644
--- a/src/test/java/instance/EntityTrackerTest.java
+++ b/src/test/java/instance/EntityTrackerTest.java
@@ -1,12 +1,10 @@
 package instance;
 
-import net.minestom.server.coordinate.Point;
 import net.minestom.server.coordinate.Vec;
 import net.minestom.server.entity.Entity;
 import net.minestom.server.entity.EntityType;
 import net.minestom.server.instance.EntityTracker;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -15,7 +13,7 @@ public class EntityTrackerTest {
     @Test
     public void register() {
         var ent1 = new Entity(EntityType.ZOMBIE);
-        var updated = new EntityTracker.Update<>() {
+        var updater = new EntityTracker.Update<>() {
             @Override
             public void add(@NotNull Entity entity) {
                 assertNotSame(ent1, entity);
@@ -27,29 +25,103 @@ public class EntityTrackerTest {
                 assertNotSame(ent1, entity);
                 fail("No other entity should be registered yet");
             }
-
-            @Override
-            public void updateTracker(@NotNull Point point, @Nullable EntityTracker tracker) {
-                // Empty
-            }
         };
         EntityTracker tracker = EntityTracker.newTracker();
         var chunkEntities = tracker.chunkEntities(Vec.ZERO, EntityTracker.Target.ENTITIES);
         assertTrue(chunkEntities.isEmpty());
 
-        tracker.register(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, updated);
+        tracker.register(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, updater);
         assertTrue(chunkEntities.isEmpty());
 
         chunkEntities = tracker.chunkEntities(Vec.ZERO, EntityTracker.Target.ENTITIES);
         assertEquals(1, chunkEntities.size());
 
-        tracker.unregister(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, updated);
+        tracker.unregister(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, updater);
         chunkEntities = tracker.chunkEntities(Vec.ZERO, EntityTracker.Target.ENTITIES);
         assertEquals(0, chunkEntities.size());
     }
 
     @Test
     public void move() {
+        var ent1 = new Entity(EntityType.ZOMBIE);
+        var updater = new EntityTracker.Update<>() {
+            @Override
+            public void add(@NotNull Entity entity) {
+                fail("No other entity should be registered yet");
+            }
 
+            @Override
+            public void remove(@NotNull Entity entity) {
+                fail("No other entity should be registered yet");
+            }
+        };
+
+        EntityTracker tracker = EntityTracker.newTracker();
+
+        tracker.register(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, updater);
+        assertEquals(1, tracker.chunkEntities(Vec.ZERO, EntityTracker.Target.ENTITIES).size());
+
+        tracker.move(ent1, Vec.ZERO, new Vec(32, 0, 32), EntityTracker.Target.ENTITIES, updater);
+        assertEquals(0, tracker.chunkEntities(Vec.ZERO, EntityTracker.Target.ENTITIES).size());
+        assertEquals(1, tracker.chunkEntities(new Vec(32, 0, 32), EntityTracker.Target.ENTITIES).size());
+    }
+
+    @Test
+    public void tracking() {
+        var ent1 = new Entity(EntityType.ZOMBIE);
+        var ent2 = new Entity(EntityType.ZOMBIE);
+
+        EntityTracker tracker = EntityTracker.newTracker();
+        tracker.register(ent1, Vec.ZERO, EntityTracker.Target.ENTITIES, new EntityTracker.Update<>() {
+            @Override
+            public void add(@NotNull Entity entity) {
+                fail("No other entity should be registered yet");
+            }
+
+            @Override
+            public void remove(@NotNull Entity entity) {
+                fail("No other entity should be registered yet");
+            }
+        });
+
+        tracker.register(ent2, Vec.ZERO, EntityTracker.Target.ENTITIES, new EntityTracker.Update<>() {
+            @Override
+            public void add(@NotNull Entity entity) {
+                assertNotSame(ent2, entity);
+                assertSame(ent1, entity);
+            }
+
+            @Override
+            public void remove(@NotNull Entity entity) {
+                fail("No other entity should be removed yet");
+            }
+        });
+
+        tracker.move(ent1, Vec.ZERO, new Vec(Integer.MAX_VALUE, 0, 0), EntityTracker.Target.ENTITIES, new EntityTracker.Update<>() {
+            @Override
+            public void add(@NotNull Entity entity) {
+                assertNotSame(ent1, entity);
+                fail("No other entity should be added");
+            }
+
+            @Override
+            public void remove(@NotNull Entity entity) {
+                assertNotSame(ent1, entity);
+                assertSame(ent2, entity);
+            }
+        });
+
+        tracker.move(ent1, new Vec(Integer.MAX_VALUE, 0, 0), Vec.ZERO, EntityTracker.Target.ENTITIES, new EntityTracker.Update<>() {
+            @Override
+            public void add(@NotNull Entity entity) {
+                assertNotSame(ent1, entity);
+                assertSame(ent2, entity);
+            }
+
+            @Override
+            public void remove(@NotNull Entity entity) {
+                fail("no entity to remove");
+            }
+        });
     }
 }