diff --git a/src/main/java/net/minestom/server/collision/CollisionUtils.java b/src/main/java/net/minestom/server/collision/CollisionUtils.java
index b03d8fe9331..d1ff88d1d29 100644
--- a/src/main/java/net/minestom/server/collision/CollisionUtils.java
+++ b/src/main/java/net/minestom/server/collision/CollisionUtils.java
@@ -35,7 +35,9 @@ public final class CollisionUtils {
     public static PhysicsResult handlePhysics(@NotNull Entity entity, @NotNull Vec entityVelocity,
                                               @Nullable PhysicsResult lastPhysicsResult, boolean singleCollision) {
         final Instance instance = entity.getInstance();
-        assert instance != null;
+        if (instance == null) {
+            throw new IllegalStateException("Instance cannot be null for entity: " + entity);
+        }
         return handlePhysics(instance, entity.getChunk(),
                 entity.getBoundingBox(),
                 entity.getPosition(), entityVelocity,
@@ -83,7 +85,9 @@ public static PhysicsResult handlePhysics(@NotNull Entity entity, @NotNull Vec e
     public static PhysicsResult handlePhysics(@NotNull Entity entity, @NotNull Vec entityVelocity,
                                               @Nullable PhysicsResult lastPhysicsResult) {
         final Instance instance = entity.getInstance();
-        assert instance != null;
+        if (instance == null) {
+            throw new IllegalStateException("Instance cannot be null for entity: " + entity);
+        }
         return handlePhysics(instance, entity.getChunk(),
                 entity.getBoundingBox(),
                 entity.getPosition(), entityVelocity,
diff --git a/src/main/java/net/minestom/server/collision/ShapeImpl.java b/src/main/java/net/minestom/server/collision/ShapeImpl.java
index f6c097c40ce..5b68a1d1318 100644
--- a/src/main/java/net/minestom/server/collision/ShapeImpl.java
+++ b/src/main/java/net/minestom/server/collision/ShapeImpl.java
@@ -175,9 +175,9 @@ private static BoundingBox[] parseRegistryBoundingBoxString(String str) {
             final Vec min = new Vec(minX, minY, minZ);
             final Vec max = new Vec(minX + boundXSize, minY + boundYSize, minZ + boundZSize);
             final BoundingBox bb = new BoundingBox(min, max);
-            assert bb.minX() == minX;
-            assert bb.minY() == minY;
-            assert bb.minZ() == minZ;
+            if (bb.minX() != minX || bb.minY() != minY || bb.minZ() != minZ) {
+                throw new IllegalStateException("BoundingBox min values do not match the parsed values.");
+            }
             boundingBoxes[i] = bb;
         }
         return boundingBoxes;
diff --git a/src/main/java/net/minestom/server/command/CommandParserImpl.java b/src/main/java/net/minestom/server/command/CommandParserImpl.java
index 07c3125f45d..2d3c487eae9 100644
--- a/src/main/java/net/minestom/server/command/CommandParserImpl.java
+++ b/src/main/java/net/minestom/server/command/CommandParserImpl.java
@@ -407,7 +407,9 @@ int cursor() {
         }
 
         void cursor(int cursor) {
-            assert cursor >= 0 && cursor <= input.length();
+            if (cursor < 0 || cursor > input.length()) {
+                throw new IllegalArgumentException("Cursor value must be between 0 and the length of the input.");
+            }
             this.cursor = cursor;
         }
     }
@@ -431,7 +433,9 @@ private static <T> ArgumentResult<T> parseArgument(@NotNull CommandSender sender
             return new ArgumentResult.IncompatibleType<>();
         }
         // Bruteforce
-        assert argument.allowSpace() && !argument.useRemaining();
+        if (!(argument.allowSpace() && !argument.useRemaining())) {
+            throw new IllegalArgumentException("Argument must allow space and not use remaining.");
+        }
         StringBuilder current = new StringBuilder(reader.readWord());
         while (true) {
             try {
diff --git a/src/main/java/net/minestom/server/component/DataComponentMapImpl.java b/src/main/java/net/minestom/server/component/DataComponentMapImpl.java
index c2b72572bf1..8ac2428a40a 100644
--- a/src/main/java/net/minestom/server/component/DataComponentMapImpl.java
+++ b/src/main/java/net/minestom/server/component/DataComponentMapImpl.java
@@ -150,7 +150,9 @@ public void write(@NotNull NetworkBuffer buffer, DataComponentMap value) {
                     buffer.write(NetworkBuffer.VAR_INT, entry.getIntKey());
                     //noinspection unchecked
                     DataComponent<Object> type = (DataComponent<Object>) this.idToType.apply(entry.getIntKey());
-                    assert type != null;
+                    if (type == null) {
+                        throw new IllegalStateException("DataComponent type cannot be null for key: " + entry.getIntKey());
+                    }
                     type.write(buffer, entry.getValue());
                 }
             }
diff --git a/src/main/java/net/minestom/server/entity/Entity.java b/src/main/java/net/minestom/server/entity/Entity.java
index cf418eb2786..cb498170338 100644
--- a/src/main/java/net/minestom/server/entity/Entity.java
+++ b/src/main/java/net/minestom/server/entity/Entity.java
@@ -137,8 +137,9 @@ public void remove(@NotNull Entity entity) {
         @Override
         public void referenceUpdate(@NotNull Point point, @Nullable EntityTracker tracker) {
             final Instance currentInstance = tracker != null ? instance : null;
-            assert currentInstance == null || currentInstance.getEntityTracker() == tracker :
-                    "EntityTracker does not match current instance";
+            if (currentInstance != null && currentInstance.getEntityTracker() != tracker) {
+                throw new IllegalStateException("EntityTracker does not match current instance");
+            }
             viewEngine.updateTracker(currentInstance, point);
         }
     };
@@ -1237,7 +1238,9 @@ public void refreshPosition(@NotNull final Pos newPosition, boolean ignoreView,
         final boolean positionChange = (distanceX + distanceY + distanceZ) > 0;
 
         final Chunk chunk = getChunk();
-        assert chunk != null;
+        if (chunk == null) {
+            throw new IllegalStateException("Chunk cannot be null");
+        }
         if (distanceX > 8 || distanceY > 8 || distanceZ > 8) {
             PacketUtils.prepareViewablePacket(chunk, new EntityTeleportPacket(getEntityId(), position, isOnGround()), this);
             nextSynchronizationTick = synchronizationTicks + 1;
@@ -1306,7 +1309,9 @@ protected void refreshCoordinate(Point newPosition) {
         }
         // Handle chunk switch
         final Instance instance = getInstance();
-        assert instance != null;
+        if (instance == null) {
+            throw new IllegalStateException("Instance cannot be null");
+        }
         instance.getEntityTracker().move(this, newPosition, trackingTarget, trackingUpdate);
         final int lastChunkX = currentChunk.getChunkX();
         final int lastChunkZ = currentChunk.getChunkZ();
diff --git a/src/main/java/net/minestom/server/entity/EntityView.java b/src/main/java/net/minestom/server/entity/EntityView.java
index 736122755ea..aec6b063d45 100644
--- a/src/main/java/net/minestom/server/entity/EntityView.java
+++ b/src/main/java/net/minestom/server/entity/EntityView.java
@@ -166,7 +166,9 @@ public boolean isRegistered(T entity) {
         }
 
         public void register(T entity) {
-            assert entity.getInstance() != null : "Instance-less entity shouldn't be registered as viewer";
+            if (entity.getInstance() == null) {
+                throw new IllegalArgumentException("Instance-less entity shouldn't be registered as viewer");
+            }
             this.bitSet.add(entity.getEntityId());
         }
 
diff --git a/src/main/java/net/minestom/server/entity/Player.java b/src/main/java/net/minestom/server/entity/Player.java
index d834b46270d..476b8d70b73 100644
--- a/src/main/java/net/minestom/server/entity/Player.java
+++ b/src/main/java/net/minestom/server/entity/Player.java
@@ -678,7 +678,9 @@ public Void join() {
                         throw new RuntimeException(e);
                     }
                     scheduler.process();
-                    assert isDone();
+                    if (!isDone()) {
+                        throw new IllegalStateException("Future should be completed before processing.");
+                    }
                 }
                 return super.join();
             }
diff --git a/src/main/java/net/minestom/server/event/EventNodeImpl.java b/src/main/java/net/minestom/server/event/EventNodeImpl.java
index e6710669f94..f7c38460ae7 100644
--- a/src/main/java/net/minestom/server/event/EventNodeImpl.java
+++ b/src/main/java/net/minestom/server/event/EventNodeImpl.java
@@ -276,7 +276,9 @@ record Graph(String name, String eventType, int priority,
     }
 
     void invalidateEventsFor(EventNodeImpl<? super T> node) {
-        assert Thread.holdsLock(GLOBAL_CHILD_LOCK);
+        if (!Thread.holdsLock(GLOBAL_CHILD_LOCK)) {
+            throw new IllegalStateException("Thread must hold the GLOBAL_CHILD_LOCK to call this method");
+        }
         for (Class<? extends T> eventType : listenerMap.keySet()) {
             node.invalidateEvent(eventType);
         }
diff --git a/src/main/java/net/minestom/server/event/trait/EntityInstanceEvent.java b/src/main/java/net/minestom/server/event/trait/EntityInstanceEvent.java
index 75391186415..622c930469d 100644
--- a/src/main/java/net/minestom/server/event/trait/EntityInstanceEvent.java
+++ b/src/main/java/net/minestom/server/event/trait/EntityInstanceEvent.java
@@ -14,7 +14,9 @@ public interface EntityInstanceEvent extends EntityEvent, InstanceEvent {
     @Override
     default @NotNull Instance getInstance() {
         final Instance instance = getEntity().getInstance();
-        assert instance != null : "EntityInstanceEvent is only supported on events where the entity's instance is non-null!";
+        if (instance == null) {
+            throw new IllegalStateException("EntityInstanceEvent is only supported on events where the entity's instance is non-null!");
+        }
         return instance;
     }
 }
diff --git a/src/main/java/net/minestom/server/instance/DynamicChunk.java b/src/main/java/net/minestom/server/instance/DynamicChunk.java
index 51ca29be4e2..c2ecf8a3a6c 100644
--- a/src/main/java/net/minestom/server/instance/DynamicChunk.java
+++ b/src/main/java/net/minestom/server/instance/DynamicChunk.java
@@ -335,6 +335,8 @@ private void calculateFullHeightmap() {
     }
 
     private void assertLock() {
-        assert Thread.holdsLock(this) : "Chunk must be locked before access";
+        if (!Thread.holdsLock(this)) {
+            throw new IllegalStateException("Chunk must be locked before access");
+        }
     }
 }
diff --git a/src/main/java/net/minestom/server/instance/InstanceContainer.java b/src/main/java/net/minestom/server/instance/InstanceContainer.java
index ea28b8b2a15..e6a6f3cbae9 100644
--- a/src/main/java/net/minestom/server/instance/InstanceContainer.java
+++ b/src/main/java/net/minestom/server/instance/InstanceContainer.java
@@ -319,7 +319,9 @@ public Chunk getChunk(int chunkX, int chunkZ) {
 
                     EventDispatcher.call(new InstanceChunkLoadEvent(this, chunk));
                     final CompletableFuture<Chunk> future = this.loadingChunks.remove(index);
-                    assert future == completableFuture : "Invalid future: " + future;
+                    if (future != completableFuture) {
+                        throw new IllegalStateException("Invalid future: " + future);
+                    }
                     completableFuture.complete(chunk);
                 })
                 .exceptionally(throwable -> {
diff --git a/src/main/java/net/minestom/server/instance/anvil/AnvilLoader.java b/src/main/java/net/minestom/server/instance/anvil/AnvilLoader.java
index 47730cbd0c9..a4997159132 100644
--- a/src/main/java/net/minestom/server/instance/anvil/AnvilLoader.java
+++ b/src/main/java/net/minestom/server/instance/anvil/AnvilLoader.java
@@ -147,7 +147,9 @@ public void loadInstance(@NotNull Instance instance) {
             perRegionLoadedChunksLock.lock();
             try {
                 Set<IntIntImmutablePair> previousVersion = perRegionLoadedChunks.put(new IntIntImmutablePair(regionX, regionZ), new HashSet<>());
-                assert previousVersion == null : "The AnvilLoader cache should not already have data for this region.";
+                if (previousVersion != null) {
+                    throw new IllegalStateException("The AnvilLoader cache should not already have data for this region.");
+                }
                 return new RegionFile(regionPath);
             } catch (IOException e) {
                 MinecraftServer.getExceptionManager().handleException(e);
diff --git a/src/main/java/net/minestom/server/instance/block/BlockImpl.java b/src/main/java/net/minestom/server/instance/block/BlockImpl.java
index f2e5568bbfa..2d199be715d 100644
--- a/src/main/java/net/minestom/server/instance/block/BlockImpl.java
+++ b/src/main/java/net/minestom/server/instance/block/BlockImpl.java
@@ -70,7 +70,9 @@ static Collection<Block> values() {
     @Override
     public @NotNull Block withProperty(@NotNull String property, @NotNull String value) {
         final PropertyType[] propertyTypes = PROPERTIES_TYPE.get(id());
-        assert propertyTypes != null;
+        if (propertyTypes == null) {
+            throw new IllegalStateException("Property types cannot be null for id: " + id());
+        }
         final byte keyIndex = findKeyIndex(propertyTypes, property, this);
         final byte valueIndex = findValueIndex(propertyTypes[keyIndex], value, this);
         final long updatedProperties = updateIndex(propertiesArray, keyIndex, valueIndex);
@@ -81,7 +83,9 @@ static Collection<Block> values() {
     public @NotNull Block withProperties(@NotNull Map<@NotNull String, @NotNull String> properties) {
         if (properties.isEmpty()) return this;
         final PropertyType[] propertyTypes = PROPERTIES_TYPE.get(id());
-        assert propertyTypes != null;
+        if (propertyTypes == null) {
+            throw new IllegalStateException("Property types cannot be null for id: " + id());
+        }
         long updatedProperties = this.propertiesArray;
         for (Map.Entry<String, String> entry : properties.entrySet()) {
             final byte keyIndex = findKeyIndex(propertyTypes, entry.getKey(), this);
@@ -114,7 +118,9 @@ static Collection<Block> values() {
     @Override
     public @Unmodifiable @NotNull Map<String, String> properties() {
         final PropertyType[] propertyTypes = PROPERTIES_TYPE.get(id());
-        assert propertyTypes != null;
+        if (propertyTypes == null) {
+            throw new IllegalStateException("Property types cannot be null for id: " + id());
+        }
         final int length = propertyTypes.length;
         if (length == 0) return Map.of();
         String[] keys = new String[length];
@@ -167,7 +173,9 @@ public int hashCode() {
     private Block compute(long updatedProperties) {
         if (updatedProperties == this.propertiesArray) return this;
         final BlockImpl block = possibleProperties().get(updatedProperties);
-        assert block != null;
+        if (block == null) {
+            throw new IllegalStateException("Block cannot be null for updated properties: " + updatedProperties);
+        }
         // Reuse the same block instance if possible
         if (nbt == null && handler == null) return block;
         // Otherwise copy with the nbt and handler
@@ -192,7 +200,9 @@ private static Block createImpl(String namespace, Registry.Properties properties
                 for (var entry : stateProperties) {
                     final var k = entry.getKey();
                     final var v = (List<String>) entry.getValue();
-                    assert v.size() < MAX_VALUES;
+                    if (v.size() >= MAX_VALUES) {
+                        throw new IllegalStateException("Too many values for property " + k + " in block " + namespace);
+                    }
                     propertyTypes[i++] = new PropertyType(k, v);
                 }
             } else {
@@ -211,7 +221,9 @@ private static Block createImpl(String namespace, Registry.Properties properties
                 final String query = stateEntry.getKey();
                 final var stateOverride = (Map<String, Object>) stateEntry.getValue();
                 final var propertyMap = BlockUtils.parseProperties(query);
-                assert propertyTypes.length == propertyMap.size();
+                if (propertyTypes.length != propertyMap.size()) {
+                    throw new IllegalStateException("Property types size mismatch for query " + query);
+                }
                 long propertiesValue = 0;
                 for (Map.Entry<String, String> entry : propertyMap.entrySet()) {
                     final byte keyIndex = findKeyIndex(propertyTypes, entry.getKey(), null);
diff --git a/src/main/java/net/minestom/server/instance/generator/GeneratorImpl.java b/src/main/java/net/minestom/server/instance/generator/GeneratorImpl.java
index 9d41bc7f24b..b738e00f584 100644
--- a/src/main/java/net/minestom/server/instance/generator/GeneratorImpl.java
+++ b/src/main/java/net/minestom/server/instance/generator/GeneratorImpl.java
@@ -105,10 +105,12 @@ static final class DynamicFork implements Block.Setter {
         public void setBlock(int x, int y, int z, @NotNull Block block) {
             resize(x, y, z);
             GenerationUnit section = findAbsolute(sections, minSection, width, height, depth, x, y, z);
-            assert section.absoluteStart().chunkX() == getChunkCoordinate(x) &&
+            boolean isValidSection = section.absoluteStart().chunkX() == getChunkCoordinate(x) &&
                     section.absoluteStart().section() == getChunkCoordinate(y) &&
-                    section.absoluteStart().chunkZ() == getChunkCoordinate(z) :
-                    "Invalid section " + section.absoluteStart() + " for " + x + ", " + y + ", " + z;
+                    section.absoluteStart().chunkZ() == getChunkCoordinate(z);
+            if (!isValidSection) {
+                throw new IllegalStateException("Invalid section " + section.absoluteStart() + " for coordinates (" + x + ", " + y + ", " + z + ")");
+            }
             section.modifier().setBlock(x, y, z, block);
         }
 
@@ -528,7 +530,9 @@ private static GenerationUnit findAbsolute(List<GenerationUnit> units, Point sta
 
     private static int findIndex(int width, int height, int depth,
                                  int x, int y, int z) {
-        assert width > 0 && height > 0 && depth > 0;
+        if (width <= 0 || height <= 0 || depth <= 0) {
+            throw new IllegalArgumentException("Dimensions (width, height, depth) must be positive");
+        }
         return (z * width * height) + (y * width) + x;
     }
 
diff --git a/src/main/java/net/minestom/server/instance/light/BlockLight.java b/src/main/java/net/minestom/server/instance/light/BlockLight.java
index f0b5109ae46..f1ebd1c0f87 100644
--- a/src/main/java/net/minestom/server/instance/light/BlockLight.java
+++ b/src/main/java/net/minestom/server/instance/light/BlockLight.java
@@ -34,7 +34,9 @@ static ShortArrayFIFOQueue buildInternalQueue(Palette blockPalette) {
         // Apply section light
         blockPalette.getAllPresent((x, y, z, stateId) -> {
             final Block block = Block.fromStateId((short) stateId);
-            assert block != null;
+            if (block == null) {
+                throw new IllegalStateException("Block cannot be null for stateId: " + stateId);
+            }
             final byte lightEmission = (byte) block.registry().lightEmission();
 
             final int index = x | (z << 4) | (y << 8);
diff --git a/src/main/java/net/minestom/server/instance/palette/FlexiblePalette.java b/src/main/java/net/minestom/server/instance/palette/FlexiblePalette.java
index 89e07e9f0c7..e13edf1dbe9 100644
--- a/src/main/java/net/minestom/server/instance/palette/FlexiblePalette.java
+++ b/src/main/java/net/minestom/server/instance/palette/FlexiblePalette.java
@@ -138,7 +138,9 @@ public void setAll(@NotNull EntrySupplier supplier) {
                 }
             }
         }
-        assert index == maxSize();
+        if (index != maxSize()) {
+            throw new IllegalStateException("Index does not match the expected max size");
+        }
         // Update palette content
         if (fillValue < 0) {
             updateAll(cache);
@@ -167,7 +169,9 @@ public void replaceAll(@NotNull EntryFunction function) {
             cache[index] = newValue != value ? getPaletteIndex(newValue) : value;
             if (newValue != 0) count.setPlain(count.getPlain() + 1);
         });
-        assert arrayIndex.getPlain() == maxSize();
+        if (arrayIndex.getPlain() != maxSize()) {
+            throw new IllegalStateException("Array index does not match the expected max size");
+        }
         // Update palette content
         updateAll(cache);
         this.count = count.getPlain();
@@ -249,7 +253,9 @@ private void retrieveAll(@NotNull EntryConsumer consumer, boolean consumeEmpty)
 
     private void updateAll(int[] paletteValues) {
         final int size = maxSize();
-        assert paletteValues.length >= size;
+        if (paletteValues.length < size) {
+            throw new IllegalArgumentException("Palette values array length is smaller than the expected size");
+        }
         final int bitsPerEntry = this.bitsPerEntry;
         final int valuesPerLong = 64 / bitsPerEntry;
         final long clear = (1L << bitsPerEntry) - 1L;
@@ -274,7 +280,9 @@ void resize(byte newBitsPerEntry) {
         getAll(palette::set);
         this.bitsPerEntry = palette.bitsPerEntry;
         this.values = palette.values;
-        assert this.count == palette.count;
+        if (this.count != palette.count) {
+            throw new IllegalStateException("Palette count mismatch after resizing");
+        }
     }
 
     private int getPaletteIndex(int value) {
@@ -289,7 +297,9 @@ private int getPaletteIndex(int value) {
         final int lookup = valueToPaletteMap.putIfAbsent(value, lastPaletteIndex);
         if (lookup != -1) return lookup;
         this.paletteToValueList.add(value);
-        assert lastPaletteIndex < maxPaletteSize(bpe);
+        if (lastPaletteIndex >= maxPaletteSize(bpe)) {
+            throw new IllegalStateException("Palette size exceeded after adding new value");
+        }
         return lastPaletteIndex;
     }
 
diff --git a/src/main/java/net/minestom/server/network/NetworkBufferTypeImpl.java b/src/main/java/net/minestom/server/network/NetworkBufferTypeImpl.java
index 8a790a79a22..df1af758dd1 100644
--- a/src/main/java/net/minestom/server/network/NetworkBufferTypeImpl.java
+++ b/src/main/java/net/minestom/server/network/NetworkBufferTypeImpl.java
@@ -269,7 +269,9 @@ public void write(@NotNull NetworkBuffer buffer, byte[] value) {
         public byte[] read(@NotNull NetworkBuffer buffer) {
             final int limit = buffer.nioBuffer.limit();
             final int length = limit - buffer.readIndex();
-            assert length >= 0 : "Invalid remaining: " + length;
+            if (length < 0) {
+                throw new IllegalStateException("Invalid remaining: " + length);
+            }
             final byte[] bytes = new byte[length];
             buffer.nioBuffer.get(buffer.readIndex(), bytes);
             buffer.readIndex += length;
diff --git a/src/main/java/net/minestom/server/network/PacketProcessor.java b/src/main/java/net/minestom/server/network/PacketProcessor.java
index 7cadc525683..863f93c48dc 100644
--- a/src/main/java/net/minestom/server/network/PacketProcessor.java
+++ b/src/main/java/net/minestom/server/network/PacketProcessor.java
@@ -37,7 +37,9 @@ public PacketProcessor(@NotNull PacketListenerManager packetListenerManager) {
         NetworkBuffer buffer = new NetworkBuffer(body);
         final ClientPacket clientPacket = switch (connectionState) {
             case HANDSHAKE -> {
-                assert packetId == 0;
+                if (packetId != 0) {
+                    throw new IllegalArgumentException("Invalid packetId for HANDSHAKE state. Expected packetId 0.");
+                }
                 yield new ClientHandshakePacket(buffer);
             }
             case STATUS -> statusHandler.create(packetId, buffer);
@@ -57,7 +59,9 @@ public ClientPacket process(@NotNull PlayerConnection connection, int packetId,
         }
 
         final Player player = connection.getPlayer();
-        assert player != null;
+        if (player == null) {
+            throw new IllegalStateException("Player should not be null");
+        }
         player.addPacketToQueue(packet);
         return packet;
     }
diff --git a/src/main/java/net/minestom/server/network/packet/client/play/ClientAdvancementTabPacket.java b/src/main/java/net/minestom/server/network/packet/client/play/ClientAdvancementTabPacket.java
index fec3c5c7f36..c583fc904e1 100644
--- a/src/main/java/net/minestom/server/network/packet/client/play/ClientAdvancementTabPacket.java
+++ b/src/main/java/net/minestom/server/network/packet/client/play/ClientAdvancementTabPacket.java
@@ -34,7 +34,9 @@ private static ClientAdvancementTabPacket read(@NotNull NetworkBuffer reader) {
     public void write(@NotNull NetworkBuffer writer) {
         writer.writeEnum(AdvancementAction.class, action);
         if (action == AdvancementAction.OPENED_TAB) {
-            assert tabIdentifier != null;
+            if (tabIdentifier == null) {
+                throw new IllegalStateException("Tab identifier must not be null.");
+            }
             if (tabIdentifier.length() > 256) {
                 throw new IllegalArgumentException("Tab identifier cannot be longer than 256 characters.");
             }
diff --git a/src/main/java/net/minestom/server/network/packet/server/common/ServerLinksPacket.java b/src/main/java/net/minestom/server/network/packet/server/common/ServerLinksPacket.java
index e5c34546d64..61beb4b169c 100644
--- a/src/main/java/net/minestom/server/network/packet/server/common/ServerLinksPacket.java
+++ b/src/main/java/net/minestom/server/network/packet/server/common/ServerLinksPacket.java
@@ -48,7 +48,9 @@ public void write(@NotNull NetworkBuffer buffer, Entry value) {
                 if (value.knownType != null) {
                     buffer.write(KnownLinkType.NETWORK_TYPE, value.knownType);
                 } else {
-                    assert value.customType != null;
+                    if (value.customType == null) {
+                        throw new IllegalStateException("Custom type cannot be null when known type is not present.");
+                    }
                     buffer.write(NetworkBuffer.COMPONENT, value.customType);
                 }
                 buffer.write(NetworkBuffer.STRING, value.link);
diff --git a/src/main/java/net/minestom/server/network/packet/server/play/AdvancementsPacket.java b/src/main/java/net/minestom/server/network/packet/server/play/AdvancementsPacket.java
index 1461344f4f0..5d8469a57e2 100644
--- a/src/main/java/net/minestom/server/network/packet/server/play/AdvancementsPacket.java
+++ b/src/main/java/net/minestom/server/network/packet/server/play/AdvancementsPacket.java
@@ -183,7 +183,9 @@ public void write(@NotNull NetworkBuffer writer) {
             writer.writeEnum(FrameType.class, frameType);
             writer.write(INT, flags);
             if ((flags & 0x1) != 0) {
-                assert backgroundTexture != null;
+                if (backgroundTexture == null) {
+                    throw new IllegalStateException("Background texture cannot be null when the first flag is set.");
+                }
                 writer.write(STRING, backgroundTexture);
             }
             writer.write(FLOAT, x);
diff --git a/src/main/java/net/minestom/server/network/packet/server/play/ScoreboardObjectivePacket.java b/src/main/java/net/minestom/server/network/packet/server/play/ScoreboardObjectivePacket.java
index 9afbc12c389..6e6a3c96563 100644
--- a/src/main/java/net/minestom/server/network/packet/server/play/ScoreboardObjectivePacket.java
+++ b/src/main/java/net/minestom/server/network/packet/server/play/ScoreboardObjectivePacket.java
@@ -45,9 +45,13 @@ public void write(@NotNull NetworkBuffer writer) {
         writer.write(STRING, objectiveName);
         writer.write(BYTE, mode);
         if (mode == 0 || mode == 2) {
-            assert objectiveValue != null;
+            if (objectiveValue == null) {
+                throw new IllegalStateException("Objective value cannot be null when mode is 0 or 2.");
+            }
             writer.write(COMPONENT, objectiveValue);
-            assert type != null;
+            if (type == null) {
+                throw new IllegalStateException("Type cannot be null when mode is 0 or 2.");
+            }
             writer.write(VAR_INT, type.ordinal());
             writer.writeOptional(numberFormat);
         }
diff --git a/src/main/java/net/minestom/server/network/packet/server/play/StopSoundPacket.java b/src/main/java/net/minestom/server/network/packet/server/play/StopSoundPacket.java
index b4c2196450e..ec212d98496 100644
--- a/src/main/java/net/minestom/server/network/packet/server/play/StopSoundPacket.java
+++ b/src/main/java/net/minestom/server/network/packet/server/play/StopSoundPacket.java
@@ -31,11 +31,15 @@ private static StopSoundPacket read(@NotNull NetworkBuffer reader) {
     public void write(@NotNull NetworkBuffer writer) {
         writer.write(BYTE, flags);
         if (flags == 3 || flags == 1) {
-            assert source != null;
+            if (source == null) {
+                throw new IllegalStateException("Source cannot be null when flags are 3 or 1.");
+            }
             writer.write(VAR_INT, AdventurePacketConvertor.getSoundSourceValue(source));
         }
         if (flags == 2 || flags == 3) {
-            assert sound != null;
+            if (sound == null) {
+                throw new IllegalStateException("Sound cannot be null when flags are 2 or 3.");
+            }
             writer.write(STRING, sound);
         }
     }
diff --git a/src/main/java/net/minestom/server/network/packet/server/play/data/ChunkData.java b/src/main/java/net/minestom/server/network/packet/server/play/data/ChunkData.java
index 877832732d5..368f99afa35 100644
--- a/src/main/java/net/minestom/server/network/packet/server/play/data/ChunkData.java
+++ b/src/main/java/net/minestom/server/network/packet/server/play/data/ChunkData.java
@@ -47,7 +47,9 @@ public void write(@NotNull NetworkBuffer writer) {
 
             writer.write(VAR_INT, registry.blockEntityId());
             final CompoundBinaryTag nbt = BlockUtils.extractClientNbt(block);
-            assert nbt != null;
+            if (nbt == null) {
+                throw new IllegalStateException("Block NBT cannot be null.");
+            }
             writer.write(NBT, nbt); // block nbt
         }
     }
diff --git a/src/main/java/net/minestom/server/network/socket/Worker.java b/src/main/java/net/minestom/server/network/socket/Worker.java
index f285fce0bb5..4a4a0e5f404 100644
--- a/src/main/java/net/minestom/server/network/socket/Worker.java
+++ b/src/main/java/net/minestom/server/network/socket/Worker.java
@@ -117,8 +117,12 @@ public void run() {
     }
 
     public void disconnect(PlayerSocketConnection connection, SocketChannel channel) {
-        assert !connection.isOnline();
-        assert Thread.currentThread() == this;
+        if (connection.isOnline()) {
+            throw new IllegalStateException("Connection is still online and cannot be disconnected.");
+        }
+        if (Thread.currentThread() != this) {
+            throw new IllegalStateException("Method must be called from the correct thread.");
+        }
         this.connectionMap.remove(channel);
         if (channel.isOpen()) {
             try {
diff --git a/src/main/java/net/minestom/server/scoreboard/Sidebar.java b/src/main/java/net/minestom/server/scoreboard/Sidebar.java
index 03778ff4a36..884e836163a 100644
--- a/src/main/java/net/minestom/server/scoreboard/Sidebar.java
+++ b/src/main/java/net/minestom/server/scoreboard/Sidebar.java
@@ -474,11 +474,15 @@ public NumberFormat(NetworkBuffer reader) {
         public void write(@NotNull NetworkBuffer writer) {
             writer.write(NetworkBuffer.VAR_INT, formatType.ordinal());
             if (formatType == FormatType.STYLED) {
-                assert content != null;
+                if (content == null) {
+                    throw new IllegalStateException("Content cannot be null when formatType is " + formatType);
+                }
                 writer.write(NetworkBuffer.COMPONENT, content);
             }
             else if (formatType == FormatType.FIXED) {
-                assert content != null;
+                if (content == null) {
+                    throw new IllegalStateException("Content cannot be null when formatType is " + formatType);
+                }
                 writer.write(NetworkBuffer.COMPONENT, content);
             }
         }
diff --git a/src/main/java/net/minestom/server/tag/Tag.java b/src/main/java/net/minestom/server/tag/Tag.java
index 1983982642e..6d05019956a 100644
--- a/src/main/java/net/minestom/server/tag/Tag.java
+++ b/src/main/java/net/minestom/server/tag/Tag.java
@@ -46,7 +46,10 @@ record PathEntry(String name, int index) {
         Function<?, ?> readComparator,
         Serializers.Entry<T, BinaryTag> entry,
         Supplier<T> defaultValue, PathEntry[] path, UnaryOperator<T> copy, int listScope) {
-        assert index == INDEX_MAP.get(key);
+        if (index != INDEX_MAP.get(key)) {
+            throw new IllegalArgumentException("Index must match the value in INDEX_MAP for the given key: " + key);
+        }
+
         this.index = index;
         this.key = key;
         this.readComparator = readComparator;
diff --git a/src/main/java/net/minestom/server/tag/TagHandlerImpl.java b/src/main/java/net/minestom/server/tag/TagHandlerImpl.java
index 92a304ccc69..c3d8c190b79 100644
--- a/src/main/java/net/minestom/server/tag/TagHandlerImpl.java
+++ b/src/main/java/net/minestom/server/tag/TagHandlerImpl.java
@@ -185,7 +185,9 @@ private Node traversePathWrite(Node root, Tag<?> tag,
             if (entry != null && entry.tag.entry.isPath()) {
                 // Existing path, continue navigating
                 final Node tmp = (Node) entry.value;
-                assert tmp.parent == local : "Path parent is invalid: " + tmp.parent + " != " + local;
+                if (tmp.parent != local) {
+                    throw new IllegalStateException("Path parent is invalid: " + tmp.parent + " != " + local);
+                }
                 local = tmp;
             } else {
                 if (!present) return null;
@@ -194,7 +196,9 @@ private Node traversePathWrite(Node root, Tag<?> tag,
                     if (synEntry != null && synEntry.tag.entry.isPath()) {
                         // Existing path, continue navigating
                         final Node tmp = (Node) synEntry.value;
-                        assert tmp.parent == local : "Path parent is invalid: " + tmp.parent + " != " + local;
+                        if (tmp.parent != local) {
+                            throw new IllegalStateException("Path parent is invalid: " + tmp.parent + " != " + local);
+                        }
                         local = tmp;
                         continue;
                     }
@@ -306,7 +310,9 @@ Node copy(Node parent) {
                         return; // Empty node
                     value = copy;
                     nbt = copy.compound;
-                    assert nbt != null : "Node copy should also compute the compound";
+                    if (nbt == null) {
+                        throw new IllegalStateException("Node copy should also compute the compound");
+                    }
                 } else {
                     nbt = entry.updatedNbt();
                 }
@@ -356,7 +362,9 @@ BinaryTag updatedNbt() {
         }
 
         void updateValue(T value) {
-            assert !tag.entry.isPath();
+            if (tag.entry.isPath()) {
+                throw new IllegalStateException("Cannot update value when the tag entry is a path.");
+            }
             this.value = value;
             this.nbt = null;
         }
diff --git a/src/main/java/net/minestom/server/tag/TagNbtSeparator.java b/src/main/java/net/minestom/server/tag/TagNbtSeparator.java
index 93584dbb606..44baa4f2ff3 100644
--- a/src/main/java/net/minestom/server/tag/TagNbtSeparator.java
+++ b/src/main/java/net/minestom/server/tag/TagNbtSeparator.java
@@ -37,14 +37,20 @@ static void separate(String key, BinaryTag nbt, Consumer<Entry> consumer) {
     }
 
     static Entry separateSingle(String key, BinaryTag nbt) {
-        assert !(nbt instanceof CompoundBinaryTag);
+        if (nbt instanceof CompoundBinaryTag) {
+            throw new IllegalArgumentException("NBT must not be an instance of CompoundBinaryTag: " + nbt);
+        }
         AtomicReference<Entry<?>> entryRef = new AtomicReference<>();
         convert(new ArrayList<>(), key, nbt, entry -> {
-            assert entryRef.getPlain() == null : "Multiple entries found for nbt tag: " + key + " -> " + nbt;
+            if (entryRef.getPlain() != null) {
+                throw new IllegalStateException("Multiple entries found for NBT tag: " + key + " -> " + nbt);
+            }
             entryRef.setPlain(entry);
         });
         var entry = entryRef.getPlain();
-        assert entry != null;
+        if (entry == null) {
+            throw new IllegalStateException("No entry found for NBT tag: " + key + " -> " + nbt);
+        }
         return entry;
     }
 
diff --git a/src/main/java/net/minestom/server/tag/TagRecord.java b/src/main/java/net/minestom/server/tag/TagRecord.java
index 6cc3d33d757..d70ce27fc15 100644
--- a/src/main/java/net/minestom/server/tag/TagRecord.java
+++ b/src/main/java/net/minestom/server/tag/TagRecord.java
@@ -35,7 +35,10 @@ final class TagRecord {
     static final ClassValue<Serializer<? extends Record>> serializers = new ClassValue<>() {
         @Override
         protected Serializer<? extends Record> computeValue(Class<?> type) {
-            assert type.isRecord();
+            if (!type.isRecord()) {
+                throw new IllegalArgumentException("The provided class must be a record: " + type.getName());
+            }
+
             final RecordComponent[] components = type.getRecordComponents();
             final Entry[] entries = Arrays.stream(components)
                     .map(recordComponent -> {
@@ -65,7 +68,9 @@ protected Serializer<? extends Record> computeValue(Class<?> type) {
     };
 
     static <T extends Record> @NotNull Serializer<T> serializer(@NotNull Class<T> type) {
-        assert type.isRecord();
+        if (!type.isRecord()) {
+            throw new IllegalArgumentException("The provided class must be a record: " + type.getName());
+        }
         //noinspection unchecked
         return (Serializer<T>) serializers.get(type);
     }
diff --git a/src/main/java/net/minestom/server/thread/ThreadDispatcher.java b/src/main/java/net/minestom/server/thread/ThreadDispatcher.java
index 541a2f9ebdb..41a1b296508 100644
--- a/src/main/java/net/minestom/server/thread/ThreadDispatcher.java
+++ b/src/main/java/net/minestom/server/thread/ThreadDispatcher.java
@@ -147,7 +147,9 @@ public void refreshThreads(long nanoTimeout) {
                     if (partition == null) break;
                     // Update chunk's thread
                     Partition partitionEntry = partitions.get(partition);
-                    assert partitionEntry != null;
+                    if (partitionEntry == null) {
+                        throw new IllegalStateException("Partition entry cannot be null.");
+                    }
                     final TickThread previous = partitionEntry.thread;
                     final TickThread next = retrieveThread(partition);
                     if (next != previous) {
diff --git a/src/main/java/net/minestom/server/thread/TickThread.java b/src/main/java/net/minestom/server/thread/TickThread.java
index 21f3edb0fb9..16c5070db9b 100644
--- a/src/main/java/net/minestom/server/thread/TickThread.java
+++ b/src/main/java/net/minestom/server/thread/TickThread.java
@@ -65,7 +65,9 @@ private void tick() {
         final ReentrantLock lock = this.lock;
         final long tickTime = this.tickTime;
         for (ThreadDispatcher.Partition entry : entries) {
-            assert entry.thread() == this;
+            if (entry.thread() != this) {
+                throw new IllegalStateException("The entry thread does not match the current thread.");
+            }
             final List<Tickable> elements = entry.elements();
             if (elements.isEmpty()) continue;
             for (Tickable element : elements) {
diff --git a/src/main/java/net/minestom/server/utils/ArrayUtils.java b/src/main/java/net/minestom/server/utils/ArrayUtils.java
index ca21c1a23c1..5fd7a3d178d 100644
--- a/src/main/java/net/minestom/server/utils/ArrayUtils.java
+++ b/src/main/java/net/minestom/server/utils/ArrayUtils.java
@@ -45,12 +45,16 @@ public static <T> int[] mapToIntArray(Collection<T> collection, ToIntFunction<T>
         for (T object : collection) {
             result[i++] = function.applyAsInt(object);
         }
-        assert i == size;
+        if (i != size) {
+            throw new IllegalStateException("Index mismatch: expected " + size + " but got " + i);
+        }
         return result;
     }
 
     public static <K, V> Map<K, V> toMap(@NotNull K[] keys, @NotNull V[] values, int length) {
-        assert keys.length >= length && keys.length == values.length;
+        if (keys.length < length || keys.length != values.length) {
+            throw new IllegalArgumentException("Keys and values arrays must have the same length and at least the specified length.");
+        }
         return switch (length) {
             case 0 -> Map.of();
             case 1 -> Map.of(keys[0], values[0]);
@@ -96,7 +100,9 @@ public static long[] pack(int[] ints, int bitsPerEntry) {
     }
 
     public static void unpack(int[] out, long[] in, int bitsPerEntry) {
-        assert in.length != 0: "unpack input array is zero";
+        if (in.length == 0) {
+            throw new IllegalArgumentException("Unpack input array is zero");
+        }
 
         var intsPerLong = Math.floor(64d / bitsPerEntry);
         var intsPerLongCeil = (int) Math.ceil(intsPerLong);
diff --git a/src/main/java/net/minestom/server/utils/NamespaceID.java b/src/main/java/net/minestom/server/utils/NamespaceID.java
index 2bec8358d33..65a17a211f1 100644
--- a/src/main/java/net/minestom/server/utils/NamespaceID.java
+++ b/src/main/java/net/minestom/server/utils/NamespaceID.java
@@ -39,9 +39,15 @@ public record NamespaceID(@NotNull String domain, @NotNull String path) implemen
     public NamespaceID {
         domain = domain.intern();
         path = path.intern();
-        assert !domain.contains(".") && !domain.contains("/") : "Domain cannot contain a dot nor a slash character (" + asString() + ")";
-        assert domain.matches(LEGAL_LETTERS) : "Illegal character in domain (" + asString() + "). Must match " + LEGAL_LETTERS;
-        assert path.matches(LEGAL_PATH_LETTERS) : "Illegal character in path (" + asString() + "). Must match " + LEGAL_PATH_LETTERS;
+        if (domain.contains(".") || domain.contains("/")) {
+            throw new IllegalArgumentException("Domain cannot contain a dot nor a slash character (" + asString() + ")");
+        }
+        if (!domain.matches(LEGAL_LETTERS)) {
+            throw new IllegalArgumentException("Illegal character in domain (" + asString() + "). Must match " + LEGAL_LETTERS);
+        }
+        if (!path.matches(LEGAL_PATH_LETTERS)) {
+            throw new IllegalArgumentException("Illegal character in path (" + asString() + "). Must match " + LEGAL_PATH_LETTERS);
+        }
     }
 
     @Override
diff --git a/src/main/java/net/minestom/server/utils/PacketUtils.java b/src/main/java/net/minestom/server/utils/PacketUtils.java
index 49565b009fe..970c835afc7 100644
--- a/src/main/java/net/minestom/server/utils/PacketUtils.java
+++ b/src/main/java/net/minestom/server/utils/PacketUtils.java
@@ -389,7 +389,9 @@ private static void writeTo(PlayerConnection connection, ByteBuffer buffer, int
 
     @ApiStatus.Internal
     public static int invalidPacketState(@NotNull Class<?> packetClass, @NotNull ConnectionState state, @NotNull ConnectionState... expected) {
-        assert expected.length > 0 : "Expected states cannot be empty: " + packetClass;
+        if (expected.length == 0) {
+            throw new IllegalArgumentException("Expected states cannot be empty: " + packetClass);
+        }
         StringBuilder expectedStr = new StringBuilder();
         for (ConnectionState connectionState : expected) {
             expectedStr.append(connectionState).append(", ");
diff --git a/src/main/java/net/minestom/server/utils/binary/BinaryBuffer.java b/src/main/java/net/minestom/server/utils/binary/BinaryBuffer.java
index ef3e98355a6..96030ce3ed6 100644
--- a/src/main/java/net/minestom/server/utils/binary/BinaryBuffer.java
+++ b/src/main/java/net/minestom/server/utils/binary/BinaryBuffer.java
@@ -31,7 +31,9 @@ public static BinaryBuffer ofSize(int size) {
 
     @ApiStatus.Internal
     public static BinaryBuffer wrap(ByteBuffer buffer) {
-        assert buffer.isDirect();
+        if (!buffer.isDirect()) {
+            throw new IllegalArgumentException("The buffer must be direct");
+        }
         return new BinaryBuffer(buffer);
     }
 
diff --git a/src/main/java/net/minestom/server/utils/block/BlockUtils.java b/src/main/java/net/minestom/server/utils/block/BlockUtils.java
index 36034d1e325..8aeaef18113 100644
--- a/src/main/java/net/minestom/server/utils/block/BlockUtils.java
+++ b/src/main/java/net/minestom/server/utils/block/BlockUtils.java
@@ -64,7 +64,9 @@ public static Map<String, String> parseProperties(String query) {
         if (query.length() == 2) return Map.of();
 
         final int entries = StringUtils.countMatches(query, ',') + 1;
-        assert entries > 0;
+        if (entries <= 0) {
+            throw new IllegalArgumentException("Invalid number of entries in the query");
+        }
         String[] keys = new String[entries];
         String[] values = new String[entries];
         int entryCount = 0;