diff --git a/game/client/devPacks/inTestingSoundsPack/assets/minecraft/sounds/sounds.json b/game/client/devPacks/inTestingSoundsPack/assets/minecraft/sounds/sounds.json
index a667a01cd..4cd5c6628 100644
--- a/game/client/devPacks/inTestingSoundsPack/assets/minecraft/sounds/sounds.json
+++ b/game/client/devPacks/inTestingSoundsPack/assets/minecraft/sounds/sounds.json
@@ -171,5 +171,51 @@
         "stream": true
       }
     ]
+  },
+  "music.bta.nether": {
+    "sounds": [
+      {
+        "name": "btamusic/nether/nether1.ogg",
+        "title": "Venus",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether2.ogg",
+        "title": "Death Coils",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether3.ogg",
+        "title": "Reactor",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether4.ogg",
+        "title": "Outlands",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether5.ogg",
+        "title": "Nematocyst",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether6.ogg",
+        "title": "Alkali Feldspar",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/underground/nether7.ogg",
+        "title": "Slip",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      }
+    ]
   }
 }
diff --git a/game/client/src/main/java/net/minecraft/client/gui/ScreenSelectWorld.java b/game/client/src/main/java/net/minecraft/client/gui/ScreenSelectWorld.java
index aa7f5f622..bc9808c70 100644
--- a/game/client/src/main/java/net/minecraft/client/gui/ScreenSelectWorld.java
+++ b/game/client/src/main/java/net/minecraft/client/gui/ScreenSelectWorld.java
@@ -129,9 +129,13 @@ public class ScreenSelectWorld extends Screen {
         this.buttons.add(this.buttonFolder = new ListenerButtonElement(8, this.width / 2 - 154, this.height - 28, 20, 20, "")
             .setTextures("minecraft:gui/misc/button_folder", "minecraft:gui/misc/button_folder_highlighted", "minecraft:gui/misc/button_folder_disabled")
             .setListener(buttonElement -> {
-                if (selectedWorld < 0) return;
+                File savesDir = new File(mc.getMinecraftDir(), "saves");
+                if (this.selectedWorld < 0 || this.selectedWorld >= this.saveList.size()) {
+                    FileOpener.open(savesDir);
+                    return;
+                }
                 SaveFile save = this.saveList.get(this.selectedWorld);
-                FileOpener.open(new File(mc.getMinecraftDir(), "saves/" + save.getFileName()));
+                FileOpener.open(new File(savesDir, save.getFileName()));
             }));
         this.buttons.add(this.buttonRename = new ButtonElement(6, this.width / 2 - 126, this.height - 28, 57, 20, i18n.translateKey("gui.select_world.button.rename")));
         this.buttons.add(this.buttonDelete = new ButtonElement(2, this.width / 2 - 61, this.height - 28, 57, 20, i18n.translateKey("gui.select_world.button.delete")));
@@ -140,7 +144,6 @@ public class ScreenSelectWorld extends Screen {
         this.buttonSelect.enabled = false;
         this.buttonRename.enabled = false;
         this.buttonDelete.enabled = false;
-        this.buttonFolder.enabled = false;
     }
 
     public void deletePresetWorld(String name) {
@@ -280,7 +283,6 @@ public class ScreenSelectWorld extends Screen {
             ScreenSelectWorld.this.buttonSelect.enabled = flag1 && !corrupted;
             ScreenSelectWorld.this.buttonRename.enabled = flag1 && !corrupted;
             ScreenSelectWorld.this.buttonDelete.enabled = flag1;
-            ScreenSelectWorld.this.buttonFolder.enabled = flag1;
             if (doubleClicked && flag1) {
                 selectWorld(itemIndex);
             }
diff --git a/game/client/src/main/java/net/minecraft/client/render/worldtype/WorldTypeFXDispatcher.java b/game/client/src/main/java/net/minecraft/client/render/worldtype/WorldTypeFXDispatcher.java
index 4ce89e1cf..76a1747a9 100644
--- a/game/client/src/main/java/net/minecraft/client/render/worldtype/WorldTypeFXDispatcher.java
+++ b/game/client/src/main/java/net/minecraft/client/render/worldtype/WorldTypeFXDispatcher.java
@@ -62,6 +62,9 @@ public class WorldTypeFXDispatcher extends Dispatcher<WorldType, WorldTypeFX> {
         addDispatch(new WorldTypeFXNether(WorldTypes.NETHER_SKYBLOCK)
             .setHasClouds(false)
             .setHasSky(false));
+        addDispatch(new WorldTypeFXNether(WorldTypes.NETHER_BETA_173)
+            .setHasClouds(false)
+            .setHasSky(false));
 
         addDispatch(new WorldTypeFXDrift(WorldTypes.DRIFT_DEFAULT)
             .setCloudHeight(8f)
diff --git a/game/client/src/main/java/net/minecraft/client/sound/MusicCategory.java b/game/client/src/main/java/net/minecraft/client/sound/MusicCategory.java
index 1f47092b9..89b651341 100644
--- a/game/client/src/main/java/net/minecraft/client/sound/MusicCategory.java
+++ b/game/client/src/main/java/net/minecraft/client/sound/MusicCategory.java
@@ -5,7 +5,8 @@ import org.jetbrains.annotations.NotNull;
 public enum MusicCategory {
 
     OVERWORLD("overworld"),
-    UNDERGROUND("underground");
+    UNDERGROUND("underground"),
+    NETHER("nether");
 
     public final String namespace;
 
diff --git a/game/client/src/main/java/net/minecraft/client/sound/MusicCategoryManager.java b/game/client/src/main/java/net/minecraft/client/sound/MusicCategoryManager.java
index 3ff45d21d..e93e77fb3 100644
--- a/game/client/src/main/java/net/minecraft/client/sound/MusicCategoryManager.java
+++ b/game/client/src/main/java/net/minecraft/client/sound/MusicCategoryManager.java
@@ -2,8 +2,10 @@ package net.minecraft.client.sound;
 
 import net.minecraft.client.Minecraft;
 import net.minecraft.core.entity.player.Player;
+import net.minecraft.core.world.Dimension;
 import net.minecraft.core.world.World;
 import net.minecraft.core.world.pos.TilePos;
+import net.minecraft.core.world.type.tag.WorldTypeTags;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -17,6 +19,7 @@ public class MusicCategoryManager {
     static {
         register(MusicCategory.OVERWORLD, (World::canBlockSeeSky));
         register(MusicCategory.UNDERGROUND, (world, pos) -> (!world.canBlockSeeSky(pos)) && pos.y <= world.getWorldType().getOceanY());
+        register(MusicCategory.NETHER, (world, pos) -> world.getWorldType().hasTag(WorldTypeTags.NETHER));
     }
 
     public static void register(MusicCategory category, MusicCondition condition){
diff --git a/game/core/src/main/java/net/minecraft/core/entity/animal/MobDeer.java b/game/core/src/main/java/net/minecraft/core/entity/animal/MobDeer.java
index 5ef59ea37..70a1f492a 100644
--- a/game/core/src/main/java/net/minecraft/core/entity/animal/MobDeer.java
+++ b/game/core/src/main/java/net/minecraft/core/entity/animal/MobDeer.java
@@ -148,17 +148,17 @@ public class MobDeer
     //Todo: change with new sounds
     @Override
     public String getLivingSound() {
-        return "mob.cow";
+        return "";
     }
 
     @Override
     protected String getHurtSound() {
-        return "mob.cowhurt";
+        return "";
     }
 
     @Override
     protected String getDeathSound() {
-        return "mob.cowhurt";
+        return "";
     }
 
     @Override
diff --git a/game/core/src/main/java/net/minecraft/core/world/biome/Biomes.java b/game/core/src/main/java/net/minecraft/core/world/biome/Biomes.java
index 3389965b3..41bf3fa58 100644
--- a/game/core/src/main/java/net/minecraft/core/world/biome/Biomes.java
+++ b/game/core/src/main/java/net/minecraft/core/world/biome/Biomes.java
@@ -298,7 +298,18 @@ public class Biomes {
             )
     );
 
-
+    public static final @NotNull Biome NETHER_LEGACY_HELL = register(
+        "minecraft:nether.legacy.hell",
+        new BiomeNether("nether.legacy.hell")
+            .withDebugColor(0x77_37_2A)
+            .withBlockedWeathers(Weathers.OVERWORLD_RAIN, Weathers.OVERWORLD_SNOW, Weathers.OVERWORLD_STORM, Weathers.OVERWORLD_FOG)
+            .withSurfaceProperties(
+                new SurfaceProperties.Builder()
+                        .withTopBlock(Blocks.COBBLE_NETHERRACK)
+                        .withFillerBlock(Blocks.COBBLE_NETHERRACK)
+                        .build()
+            )
+    );
 
     public static final @NotNull Biome DRIFT_DRIFT = register(
         "minecraft:drift.drift",
diff --git a/game/core/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderNetherB173.java
new file mode 100644
index 000000000..e1f8aaeea
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/biome/provider/BiomeProviderNetherB173.java
@@ -0,0 +1,79 @@
+package net.minecraft.core.world.biome.provider;
+
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.biome.Biome;
+import net.minecraft.core.world.biome.Biomes;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public final class BiomeProviderNetherB173 extends BiomeProvider {
+    public BiomeProviderNetherB173(final @NotNull World world) {
+        super(world);
+    }
+
+    @Override
+    public Biome[] getBiomes(Biome[] biomes, double[] temperatures, double[] humidities, double[] varieties, int x, int y, int z, int xSize, int ySize, int zSize) {
+        if (biomes == null || biomes.length < xSize * ySize * zSize) {
+            biomes = new Biome[xSize * ySize * zSize];
+        }
+        Arrays.fill(biomes, 0, xSize * ySize * zSize, Biomes.NETHER_LEGACY_HELL);
+
+        if (temperatures != null) {
+            Arrays.fill(temperatures, 0, Math.min(temperatures.length, xSize * zSize), 1.0);
+        }
+        if (humidities != null) {
+            Arrays.fill(humidities, 0, Math.min(humidities.length, xSize * zSize), 0.0);
+        }
+        if (varieties != null) {
+            Arrays.fill(varieties, 0, Math.min(varieties.length, xSize * zSize), 0.0);
+        }
+
+        return biomes;
+    }
+
+    @Override
+    public double[] getTemperatures(double[] temperatures, int x, int z, int xSize, int zSize) {
+        if (temperatures == null || temperatures.length < xSize * zSize) {
+            temperatures = new double[xSize * zSize];
+        }
+        Arrays.fill(temperatures, 0, xSize * zSize, 1.0);
+        return temperatures;
+    }
+
+    @Override
+    public double[] getHumidities(double[] humidities, int x, int z, int xSize, int zSize) {
+        if (humidities == null || humidities.length < xSize * zSize) {
+            humidities = new double[xSize * zSize];
+        }
+        Arrays.fill(humidities, 0, xSize * zSize, 0.0);
+        return humidities;
+    }
+
+    @Override
+    public double[] getVarieties(double[] varieties, int x, int z, int xSize, int zSize) {
+        if (varieties == null || varieties.length < xSize * zSize) {
+            varieties = new double[xSize * zSize];
+        }
+        Arrays.fill(varieties, 0, xSize * zSize, 0.0);
+        return varieties;
+    }
+
+    @Override
+    public double[] getBiomenesses(double[] biomenesses, int x, int y, int z, int xSize, int ySize, int zSize) {
+        if (biomenesses == null || biomenesses.length < xSize * ySize * zSize) {
+            biomenesses = new double[xSize * ySize * zSize];
+        }
+        Arrays.fill(biomenesses, 0, xSize * ySize * zSize, 1.0);
+        return biomenesses;
+    }
+
+    @Override
+    public Biome lookupBiome(double temperature, double humidity, double altitude, double variety) {
+        return Biomes.NETHER_LEGACY_HELL;
+    }
+
+    public static Biome[] allBiomes() {
+        return new Biome[] { Biomes.NETHER_LEGACY_HELL };
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/DensityGeneratorNether.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/DensityGeneratorNether.java
index 095d6727c..d5399599f 100644
--- a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/DensityGeneratorNether.java
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/DensityGeneratorNether.java
@@ -9,18 +9,25 @@ import org.jetbrains.annotations.NotNull;
 
 public class DensityGeneratorNether
     implements DensityGenerator {
-    private final @NotNull World world;
+    protected final @NotNull World world;
 
     private final @NotNull Noise3D minLimitNoise;
     private final @NotNull Noise3D maxLimitNoise;
     private final @NotNull Noise3D mainNoise;
 
     public DensityGeneratorNether(@NotNull World world) {
-        this.world = world;
+        this(world,
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 0)),
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 16)),
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 8, 32))
+        );
+    }
 
-        this.minLimitNoise = new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 0));
-        this.maxLimitNoise = new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 16));
-        this.mainNoise = new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 8, 32));
+    protected DensityGeneratorNether(@NotNull World world, @NotNull Noise3D minLimitNoise, @NotNull Noise3D maxLimitNoise, @NotNull Noise3D mainNoise) {
+        this.world = world;
+        this.minLimitNoise = minLimitNoise;
+        this.maxLimitNoise = maxLimitNoise;
+        this.mainNoise = mainNoise;
     }
 
     @Override
@@ -42,7 +49,7 @@ public class DensityGeneratorNether
 
         // Allocate a fresh array locally for thread safety
         double[] densityMapArray = new double[outerSize];
-        double[] biomeDensityMap = this.generateDensityMap(xSize, threeQuarterYSize, zSize, x, y, z);
+        double[] biomeDensityMap = this.computeDensityRegion(xSize, threeQuarterYSize, zSize, x, y, z);
 
         for (int dx = 0; dx < xSize; dx++) {
             for (int dz = 0; dz < zSize; dz++) {
@@ -56,7 +63,7 @@ public class DensityGeneratorNether
         return densityMapArray;
     }
 
-    private double @NotNull[] generateDensityMap(int xSize, int ySize, int zSize, int x, int y, int z) {
+    protected double @NotNull[] computeDensityRegion(int xSize, int ySize, int zSize, int x, int y, int z) {
         final int innerSize = xSize * ySize * zSize;
 
         double[] densityMapArray = new double[innerSize];
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkDecoratorNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkDecoratorNetherB173.java
new file mode 100644
index 000000000..b4b0c81ab
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkDecoratorNetherB173.java
@@ -0,0 +1,101 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import com.mojang.logging.LogUtils;
+import net.minecraft.core.block.BlockLogicFallingBlock;
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.chunk.Chunk;
+import net.minecraft.core.world.generate.chunk.ChunkDecorator;
+import net.minecraft.core.world.generate.feature.WorldFeatureFlowers;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+
+import java.util.Random;
+
+public class ChunkDecoratorNetherB173 implements ChunkDecorator {
+    private static final @NotNull Logger LOGGER = LogUtils.getLogger();
+
+    private final @NotNull World world;
+
+    public ChunkDecoratorNetherB173(final @NotNull World world) {
+        this.world = world;
+    }
+
+    @Override
+    public void decorate(final @NotNull Chunk chunk) {
+        this.world.scheduledUpdatesAreImmediate = true;
+        BlockLogicFallingBlock.fallInstantly = true;
+
+        final int x = chunk.pos.x;
+        final int z = chunk.pos.z;
+
+        try {
+            final int wx = x * 16;
+            final int wz = z * 16;
+
+            final @NotNull Random rand = new Random(this.world.getRandomSeed());
+            final long rx = rand.nextLong() / 2L * 2L + 1L;
+            final long rz = rand.nextLong() / 2L * 2L + 1L;
+            rand.setSeed(rx * x + rz * z ^ this.world.getRandomSeed());
+
+            // Lava springs
+            try {
+                for (int i = 0; i < 8; i++) {
+                    final int fx = wx + rand.nextInt(16) + 8;
+                    final int fy = rand.nextInt(120) + 4;
+                    final int fz = wz + rand.nextInt(16) + 8;
+                    new WorldFeatureNetherLavaSpringB173(Blocks.FLUID_LAVA_FLOWING).place(this.world, rand, fx, fy, fz);
+                }
+            } catch (final Throwable t) { LOGGER.error("Nether decoration step 'lava_springs' failed at chunk ({}, {}); continuing.", x, z, t); }
+
+            // Fire
+            try {
+                final int numFire = rand.nextInt(rand.nextInt(10) + 1) + 1;
+                for (int i = 0; i < numFire; i++) {
+                    final int fx = wx + rand.nextInt(16) + 8;
+                    final int fy = rand.nextInt(120) + 4;
+                    final int fz = wz + rand.nextInt(16) + 8;
+                    new WorldFeatureFireB173().place(this.world, rand, fx, fy, fz);
+                }
+            } catch (final Throwable t) { LOGGER.error("Nether decoration step 'fire' failed at chunk ({}, {}); continuing.", x, z, t); }
+
+            // Glowstone pass 1
+            try {
+                final int numGlowstone = rand.nextInt(rand.nextInt(10) + 1);
+                for (int i = 0; i < numGlowstone; i++) {
+                    final int fx = wx + rand.nextInt(16) + 8;
+                    final int fy = rand.nextInt(120) + 4;
+                    final int fz = wz + rand.nextInt(16) + 8;
+                    new WorldFeatureGlowstoneB173().place(this.world, rand, fx, fy, fz);
+                }
+            } catch (final Throwable t) { LOGGER.error("Nether decoration step 'glowstone_1' failed at chunk ({}, {}); continuing.", x, z, t); }
+
+            // Glowstone pass 2
+            try {
+                for (int i = 0; i < 10; i++) {
+                    final int fx = wx + rand.nextInt(16) + 8;
+                    final int fy = rand.nextInt(128);
+                    final int fz = wz + rand.nextInt(16) + 8;
+                    new WorldFeatureGlowstoneB173().place(this.world, rand, fx, fy, fz);
+                }
+            } catch (final Throwable t) { LOGGER.error("Nether decoration step 'glowstone_2' failed at chunk ({}, {}); continuing.", x, z, t); }
+
+            // Mushrooms
+            try {
+                int fx = wx + rand.nextInt(16) + 8;
+                int fy = rand.nextInt(128);
+                int fz = wz + rand.nextInt(16) + 8;
+                new WorldFeatureFlowers(Blocks.MUSHROOM_BROWN.id(), 64, false).place(this.world, rand, fx, fy, fz);
+
+                fx = wx + rand.nextInt(16) + 8;
+                fy = rand.nextInt(128);
+                fz = wz + rand.nextInt(16) + 8;
+                new WorldFeatureFlowers(Blocks.MUSHROOM_RED.id(), 64, false).place(this.world, rand, fx, fy, fz);
+            } catch (final Throwable t) { LOGGER.error("Nether decoration step 'mushrooms' failed at chunk ({}, {}); continuing.", x, z, t); }
+
+        } finally {
+            BlockLogicFallingBlock.fallInstantly = false;
+            this.world.scheduledUpdatesAreImmediate = false;
+        }
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkGeneratorNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkGeneratorNetherB173.java
new file mode 100644
index 000000000..bf35ab95d
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/ChunkGeneratorNetherB173.java
@@ -0,0 +1,20 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.generate.LargeFeature;
+import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin;
+import org.jetbrains.annotations.NotNull;
+
+public class ChunkGeneratorNetherB173 extends ChunkGeneratorPerlin {
+    public ChunkGeneratorNetherB173(@NotNull World world) {
+        super(
+            world,
+            new ChunkDecoratorNetherB173(world),
+            new TerrainGeneratorNetherB173(world),
+            new SurfaceGeneratorNetherB173(world),
+            new LargeFeature[]{
+                new NetherCavesLargeFeatureB173(world.getWorldType().getMinY(world), world.getWorldType().getMaxY(world) + 1)
+            }
+        );
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/DensityGeneratorNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/DensityGeneratorNetherB173.java
new file mode 100644
index 000000000..bbb13f611
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/DensityGeneratorNetherB173.java
@@ -0,0 +1,31 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.chunk.Chunk;
+import net.minecraft.core.world.generate.chunk.perlin.nether.DensityGeneratorNether;
+import net.minecraft.core.world.noise.FractalNoise3D;
+import net.minecraft.core.world.noise.ImprovedPerlinNoise;
+import net.minecraft.core.world.type.WorldType;
+import org.jetbrains.annotations.NotNull;
+
+public class DensityGeneratorNetherB173 extends DensityGeneratorNether {
+    public DensityGeneratorNetherB173(@NotNull World world) {
+        super(world,
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 0, ImprovedPerlinNoise.LegacyNoiseType.BETA)),
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 16, 16, ImprovedPerlinNoise.LegacyNoiseType.BETA)),
+            new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 8, 32, ImprovedPerlinNoise.LegacyNoiseType.BETA))
+        );
+    }
+
+    @Override
+    public double @NotNull [] generateDensityMap(@NotNull Chunk chunk) {
+        WorldType worldType = this.world.getWorldType();
+
+        int terrainHeight = (worldType.getMaxY(world) + 1) - worldType.getMinY(world);
+        int xSize = 4 + 1;
+        int ySize = (terrainHeight / 8) + 1;
+        int zSize = 4 + 1;
+
+        return this.computeDensityRegion(xSize, ySize, zSize, chunk.pos.x * 4, 0, chunk.pos.z * 4);
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/NetherCavesLargeFeatureB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/NetherCavesLargeFeatureB173.java
new file mode 100644
index 000000000..907f20b6e
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/NetherCavesLargeFeatureB173.java
@@ -0,0 +1,49 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.util.helper.MathHelper;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.chunk.Chunk;
+import net.minecraft.core.world.generate.RetroCavesLargeFeature;
+import net.minecraft.core.world.generate.chunk.ChunkGeneratorResult;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class NetherCavesLargeFeatureB173 extends RetroCavesLargeFeature {
+    private final int caveMinY;
+    private final int caveMaxY;
+
+    public NetherCavesLargeFeatureB173(int minY, int maxY) {
+        super(minY, maxY);
+        this.caveMinY = minY;
+        this.caveMaxY = maxY;
+    }
+
+    @Override
+    protected void doGeneration(@NotNull World world, @NotNull Random random, int chunkX, int chunkZ, int baseChunkX, int baseChunkZ, @NotNull ChunkGeneratorResult result) {
+        int cavesToGenerate = random.nextInt(random.nextInt(random.nextInt(10) + 1) + 1);
+        if (random.nextInt(5) != 0) {
+            cavesToGenerate = 0;
+        }
+
+        final int yRange = this.caveMaxY - this.caveMinY;
+
+        for (int i = 0; i < cavesToGenerate; i++) {
+            double blockX = chunkX * Chunk.CHUNK_SIZE_X + random.nextInt(Chunk.CHUNK_SIZE_X);
+            double blockY = this.caveMinY + random.nextInt(yRange);
+            double blockZ = chunkZ * Chunk.CHUNK_SIZE_Z + random.nextInt(Chunk.CHUNK_SIZE_Z);
+
+            int numBranches = 1;
+            if (random.nextInt(4) == 0) {
+                generateHubRoom(world, random, baseChunkX, baseChunkZ, result, blockX, blockY, blockZ);
+                numBranches += random.nextInt(4);
+            }
+            for (int l1 = 0; l1 < numBranches; l1++) {
+                float yRot = random.nextFloat() * MathHelper.PI * 2.0F;
+                float xRot = ((random.nextFloat() - 0.5F) * 2.0F) / 8F;
+                float radius = (random.nextFloat() * 2.0F + random.nextFloat()) * 2.0F;
+                generateCave(world, random, baseChunkX, baseChunkZ, result, blockX, blockY, blockZ, radius, yRot, xRot, 0, 0, 0.5D);
+            }
+        }
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/SurfaceGeneratorNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/SurfaceGeneratorNetherB173.java
new file mode 100644
index 000000000..9ec4f1f87
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/SurfaceGeneratorNetherB173.java
@@ -0,0 +1,134 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import java.util.Random;
+
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.biome.Biome;
+import net.minecraft.core.world.chunk.Chunk;
+import net.minecraft.core.world.generate.chunk.ChunkGeneratorResult;
+import net.minecraft.core.world.generate.chunk.perlin.SurfaceGenerator;
+import net.minecraft.core.world.noise.FractalNoise3D;
+import net.minecraft.core.world.noise.ImprovedPerlinNoise;
+import net.minecraft.core.world.noise.Noise3D;
+import net.minecraft.core.world.pos.ChunkTilePos;
+import org.jetbrains.annotations.NotNull;
+
+public class SurfaceGeneratorNetherB173 implements SurfaceGenerator {
+    private final World world;
+
+    private final Noise3D sandNoise;
+    private final Noise3D heightNoise;
+
+    public SurfaceGeneratorNetherB173(final @NotNull World world) {
+        this.world = world;
+        this.sandNoise = new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 4, 40, ImprovedPerlinNoise.LegacyNoiseType.BETA));
+        this.heightNoise = new FractalNoise3D<>(ImprovedPerlinNoise.genOctaves(world.getRandomSeed(), 4, 44, ImprovedPerlinNoise.LegacyNoiseType.BETA));
+    }
+
+    @Override
+    public void generateSurface(@NotNull Chunk chunk, @NotNull ChunkGeneratorResult result) {
+        int minY = world.getWorldType().getMinY(world);
+        int maxY = world.getWorldType().getMaxY(world);
+        int chunkX = chunk.pos.x;
+        int chunkZ = chunk.pos.z;
+
+        // 173s replaceBlocksForBiome dresses the surface band at a fixed y level of 64, independent of the lava sea
+        // level, and drops lava into exposed dips below it.
+        int bandLevel = minY + 64;
+
+        int worldFillBlock = world.getWorldType().getFillerBlockId();
+        short lavaId = (short) world.getWorldType().getOceanBlockIds()[0];
+
+        short bedrockId = (short) Blocks.BEDROCK.id();
+        short soulSandId = (short) Blocks.SOULSAND.id();
+        short gravelId = (short) Blocks.GRAVEL.id();
+
+        Random rand = new Random((long) chunkX * 0x4F9939F508L + (long) chunkZ * 0x1EF1565BD5L);
+
+        double beachScale = 0.03125;
+
+        double[] soulSandField = sandNoise.getRegion(null, chunkX * Chunk.CHUNK_SIZE_X, chunkZ * Chunk.CHUNK_SIZE_Z, 0.0D, Chunk.CHUNK_SIZE_X, Chunk.CHUNK_SIZE_Z, 1, beachScale, beachScale, 1.0D);
+        double[] gravelField = sandNoise.getRegion(null, chunkX * Chunk.CHUNK_SIZE_X, 109.0134D, chunkZ * Chunk.CHUNK_SIZE_Z, Chunk.CHUNK_SIZE_X, 1, Chunk.CHUNK_SIZE_Z, beachScale, 1.0D, beachScale);
+        double[] thicknessField = heightNoise.getRegion(null, chunkX * Chunk.CHUNK_SIZE_X, chunkZ * Chunk.CHUNK_SIZE_Z, 0.0D, Chunk.CHUNK_SIZE_X, Chunk.CHUNK_SIZE_Z, 1, beachScale * 2D, beachScale * 2D, beachScale * 2D);
+
+        ChunkTilePos biomeQueryPos = new ChunkTilePos();
+
+        for (int z = 0; z < Chunk.CHUNK_SIZE_Z; z++) {
+            for (int x = 0; x < Chunk.CHUNK_SIZE_X; x++) {
+                boolean generateSoulSand = soulSandField[z + (x * Chunk.CHUNK_SIZE_Z)] + rand.nextDouble() * 0.2D > 0.0D;
+                boolean generateGravel = gravelField[z + (x * Chunk.CHUNK_SIZE_Z)] + rand.nextDouble() * 0.2D > 0.0D;
+                int soilThickness = (int) (thicknessField[z + (x * Chunk.CHUNK_SIZE_Z)] / 3D + 3D + rand.nextDouble() * 0.25D);
+
+                int currentLayerDepth = -1;
+                short topBlock = -1;
+                short fillerBlock = -1;
+
+                Biome lastBiome = null;
+
+                for (int y = maxY; y >= minY; y--) {
+                    if (y >= maxY - rand.nextInt(5) || y <= minY + rand.nextInt(5)) {
+                        result.setBlock(x, y, z, bedrockId);
+                        continue;
+                    }
+
+                    Biome biome = chunk.getBlockBiome(biomeQueryPos.set(x, y, z));
+                    if (biome == null) biome = world.getBiomeProvider().getBiome(chunkX * Chunk.CHUNK_SIZE_X + x, y >> 3, chunkZ * Chunk.CHUNK_SIZE_Z + z);
+
+                    int block = result.getBlock(x, y, z);
+
+                    if ((biome != lastBiome || topBlock == -1 || fillerBlock == -1) && block == 0) {
+                        topBlock = (short) biome.getSurfaceProperties().getTopBlock().id();
+                        fillerBlock = (short) biome.getSurfaceProperties().getFillerBlock().id();
+                    }
+                    lastBiome = biome;
+
+                    if (block == 0) {
+                        currentLayerDepth = -1;
+                        continue;
+                    }
+
+                    if (block != worldFillBlock) {
+                        continue;
+                    }
+
+                    if (currentLayerDepth == -1) {
+                        if (soilThickness <= 0) {
+                            topBlock = 0;
+                            fillerBlock = (short) worldFillBlock;
+                        } else if (y >= bandLevel - 4 && y <= bandLevel + 1) {
+                            topBlock = (short) biome.getSurfaceProperties().getTopBlock().id();
+                            fillerBlock = (short) biome.getSurfaceProperties().getFillerBlock().id();
+                            if (generateGravel) {
+                                topBlock = gravelId;
+                                fillerBlock = (short) worldFillBlock;
+                            }
+                            if (generateSoulSand) {
+                                topBlock = soulSandId;
+                                fillerBlock = soulSandId;
+                            }
+                        }
+
+                        if (y < bandLevel && topBlock == 0) {
+                            topBlock = lavaId;
+                        }
+
+                        currentLayerDepth = soilThickness;
+
+                        if (y >= bandLevel - 1) {
+                            result.setBlock(x, y, z, topBlock);
+                        } else {
+                            result.setBlock(x, y, z, fillerBlock);
+                        }
+                        continue;
+                    }
+
+                    if (currentLayerDepth > 0) {
+                        currentLayerDepth--;
+                        result.setBlock(x, y, z, fillerBlock);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/TerrainGeneratorNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/TerrainGeneratorNetherB173.java
new file mode 100644
index 000000000..8d6b0baa2
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/TerrainGeneratorNetherB173.java
@@ -0,0 +1,45 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.chunk.Chunk;
+import net.minecraft.core.world.generate.chunk.perlin.DensityGenerator;
+import net.minecraft.core.world.generate.chunk.perlin.TerrainGeneratorLerp;
+import org.jetbrains.annotations.NotNull;
+
+public class TerrainGeneratorNetherB173 extends TerrainGeneratorLerp {
+    private final DensityGenerator densityGenerator;
+
+    private final int lavaLevel;
+
+    private final int airId;
+    private final int netherrackId;
+    private final int lavaId;
+
+    public TerrainGeneratorNetherB173(@NotNull World world) {
+        super(world);
+
+        this.densityGenerator = new DensityGeneratorNetherB173(world);
+
+        this.lavaLevel = world.getWorldType().getMinY(world) + world.getWorldType().getOceanY();
+
+        this.airId = Blocks.AIR.id();
+        this.netherrackId = Blocks.COBBLE_NETHERRACK.id();
+        this.lavaId = Blocks.FLUID_LAVA_STILL.id();
+    }
+
+    @Override
+    protected int getBlockAt(@NotNull Chunk chunk, int x, int y, int z, double density) {
+        if (density > 0.0) {
+            return this.netherrackId;
+        } else if (y < this.lavaLevel) {
+            return this.lavaId;
+        }
+        return this.airId;
+    }
+
+    @Override
+    public @NotNull DensityGenerator getDensityGenerator() {
+        return this.densityGenerator;
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureFireB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureFireB173.java
new file mode 100644
index 000000000..8d37d858a
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureFireB173.java
@@ -0,0 +1,26 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.pos.TilePos;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class WorldFeatureFireB173 {
+    public boolean place(@NotNull World world, @NotNull Random random, int x, int y, int z) {
+        final TilePos pos = new TilePos();
+
+        for (int i = 0; i < 64; ++i) {
+            int rx = x + random.nextInt(8) - random.nextInt(8);
+            int ry = y + random.nextInt(4) - random.nextInt(4);
+            int rz = z + random.nextInt(8) - random.nextInt(8);
+
+            if (world.isAirBlock(pos.set(rx, ry, rz)) && world.getBlockType(pos.set(rx, ry - 1, rz)) == Blocks.COBBLE_NETHERRACK) {
+                world.setBlockTypeRaw(pos.set(rx, ry, rz), Blocks.FIRE);
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureGlowstoneB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureGlowstoneB173.java
new file mode 100644
index 000000000..93c35be18
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureGlowstoneB173.java
@@ -0,0 +1,45 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.pos.TilePos;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class WorldFeatureGlowstoneB173 {
+    public boolean place(@NotNull World world, @NotNull Random random, int x, int y, int z) {
+        final TilePos pos = new TilePos();
+
+        if (!world.isAirBlock(pos.set(x, y, z))) {
+            return false;
+        }
+        if (world.getBlockType(pos.set(x, y + 1, z)) != Blocks.COBBLE_NETHERRACK) {
+            return false;
+        }
+
+        world.setBlockTypeNotify(pos.set(x, y, z), Blocks.GLOWSTONE);
+
+        for (int i = 0; i < 1500; ++i) {
+            int rx = x + random.nextInt(8) - random.nextInt(8);
+            int ry = y - random.nextInt(12);
+            int rz = z + random.nextInt(8) - random.nextInt(8);
+
+            if (world.isAirBlock(pos.set(rx, ry, rz))) {
+                int neighbours = 0;
+                if (world.getBlockType(pos.set(rx - 1, ry, rz)) == Blocks.GLOWSTONE) neighbours++;
+                if (world.getBlockType(pos.set(rx + 1, ry, rz)) == Blocks.GLOWSTONE) neighbours++;
+                if (world.getBlockType(pos.set(rx, ry - 1, rz)) == Blocks.GLOWSTONE) neighbours++;
+                if (world.getBlockType(pos.set(rx, ry + 1, rz)) == Blocks.GLOWSTONE) neighbours++;
+                if (world.getBlockType(pos.set(rx, ry, rz - 1)) == Blocks.GLOWSTONE) neighbours++;
+                if (world.getBlockType(pos.set(rx, ry, rz + 1)) == Blocks.GLOWSTONE) neighbours++;
+
+                if (neighbours == 1) {
+                    world.setBlockTypeNotify(pos.set(rx, ry, rz), Blocks.GLOWSTONE);
+                }
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureNetherLavaSpringB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureNetherLavaSpringB173.java
new file mode 100644
index 000000000..e73c72a86
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/nether/b173/WorldFeatureNetherLavaSpringB173.java
@@ -0,0 +1,50 @@
+package net.minecraft.core.world.generate.chunk.perlin.nether.b173;
+
+import net.minecraft.core.block.Block;
+import net.minecraft.core.block.Blocks;
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.pos.TilePos;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class WorldFeatureNetherLavaSpringB173 {
+    private static final int[][] NEIGHBOURS = {{-1, 0, 0}, {1, 0, 0}, {0, 0, -1}, {0, 0, 1}, {0, -1, 0}};
+
+    private final @NotNull Block<?> block;
+
+    public WorldFeatureNetherLavaSpringB173(@NotNull Block<?> block) {
+        this.block = block;
+    }
+
+    public boolean place(@NotNull World world, @NotNull Random random, int x, int y, int z) {
+        final TilePos pos = new TilePos();
+
+        if (world.getBlockType(pos.set(x, y + 1, z)) != Blocks.COBBLE_NETHERRACK) {
+            return false;
+        }
+        if (!world.isAirBlock(pos.set(x, y, z)) && world.getBlockType(pos) != Blocks.COBBLE_NETHERRACK) {
+            return false;
+        }
+
+        int solid = 0;
+        int air = 0;
+        for (int[] offset : NEIGHBOURS) {
+            pos.set(x + offset[0], y + offset[1], z + offset[2]);
+            if (world.getBlockType(pos) == Blocks.COBBLE_NETHERRACK) {
+                solid++;
+            }
+            if (world.isAirBlock(pos)) {
+                air++;
+            }
+        }
+
+        if (solid == 4 && air == 1) {
+            pos.set(x, y, z);
+            world.setBlockTypeNotify(pos, this.block);
+            this.block.updateTick(world, pos, random, false);
+        }
+
+        return true;
+    }
+}
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/SurfaceGeneratorOverworld.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/SurfaceGeneratorOverworld.java
index 97317851a..9f6523e93 100644
--- a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/SurfaceGeneratorOverworld.java
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/SurfaceGeneratorOverworld.java
@@ -257,16 +257,35 @@ public class SurfaceGeneratorOverworld
                     // if reached end of filler layer, fill world with sandstone/permafrost if inside a glacier or desert biome
                     if(currentLayerDepth == 0)
                     {
-                        if(biome == Biomes.OVERWORLD_DESERT && fillerBlock == Blocks.SAND.id()) {
-                            currentLayerDepth = rand.nextInt(8) + 2;
-                            fillerBlock = (short)Blocks.SANDSTONE.id();
-                        } else if(biome == Biomes.OVERWORLD_GLACIER && fillerBlock == Blocks.BLOCK_SNOW.id()){
-                            currentLayerDepth = rand.nextInt(8) + 14;
-                            fillerBlock = (short)Blocks.PERMAFROST.id();
+                        SubSurfaceLayer subSurfaceLayer = getSubSurfaceLayer(biome, fillerBlock, y, minY, oceanY, rand);
+                        if(subSurfaceLayer != null){
+                            currentLayerDepth = subSurfaceLayer.depth;
+                            fillerBlock = subSurfaceLayer.block;
                         }
                     }
                 }
             }
         }
     }
+
+    protected SubSurfaceLayer getSubSurfaceLayer(Biome biome, short fillerBlock, int y, int minY, int oceanY, Random rand)
+    {
+        if(biome == Biomes.OVERWORLD_DESERT && fillerBlock == Blocks.SAND.id()) {
+            return new SubSurfaceLayer((short) Blocks.SANDSTONE.id(), rand.nextInt(8) + 2);
+        } else if(biome == Biomes.OVERWORLD_GLACIER && fillerBlock == Blocks.BLOCK_SNOW.id()) {
+            return new SubSurfaceLayer((short) Blocks.PERMAFROST.id(), rand.nextInt(8) + 14);
+        }
+        return null;
+    }
+
+    protected static final class SubSurfaceLayer {
+        public final short block;
+        public final int depth;
+
+        public SubSurfaceLayer(short block, int depth)
+        {
+            this.block = block;
+            this.depth = depth;
+        }
+    }
 }
diff --git a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/b173/SurfaceGeneratorOverworldB173.java b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/b173/SurfaceGeneratorOverworldB173.java
index 975fe9c46..b1bffb37b 100644
--- a/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/b173/SurfaceGeneratorOverworldB173.java
+++ b/game/core/src/main/java/net/minecraft/core/world/generate/chunk/perlin/overworld/b173/SurfaceGeneratorOverworldB173.java
@@ -1,12 +1,15 @@
 package net.minecraft.core.world.generate.chunk.perlin.overworld.b173;
 
+import net.minecraft.core.block.Blocks;
 import net.minecraft.core.world.World;
+import net.minecraft.core.world.biome.Biome;
 import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld;
-import net.minecraft.core.world.noise.FractalNoise2D;
 import net.minecraft.core.world.noise.FractalNoise3D;
 import net.minecraft.core.world.noise.ImprovedPerlinNoise;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Random;
+
 public class SurfaceGeneratorOverworldB173
     extends SurfaceGeneratorOverworld {
     public SurfaceGeneratorOverworldB173(final @NotNull World world) {
@@ -17,4 +20,12 @@ public class SurfaceGeneratorOverworldB173
             false
         );
     }
+
+    @Override
+    protected SubSurfaceLayer getSubSurfaceLayer(Biome biome, short fillerBlock, int y, int minY, int oceanY, Random rand) {
+        if (fillerBlock == Blocks.SAND.id()) {
+            return new SubSurfaceLayer((short) Blocks.SANDSTONE.id(), rand.nextInt(4));
+        }
+        return null;
+    }
 }
diff --git a/game/core/src/main/java/net/minecraft/core/world/type/WorldTypeGroups.java b/game/core/src/main/java/net/minecraft/core/world/type/WorldTypeGroups.java
index a5e9c23db..af4eccc29 100644
--- a/game/core/src/main/java/net/minecraft/core/world/type/WorldTypeGroups.java
+++ b/game/core/src/main/java/net/minecraft/core/world/type/WorldTypeGroups.java
@@ -45,6 +45,7 @@ public class WorldTypeGroups {
         );
         GROUPS.add(
             new Group(WorldTypes.OVERWORLD_BETA_173)
+                .with(Dimension.NETHER, WorldTypes.NETHER_BETA_173)
         );
         GROUPS.add(
             new Group(WorldTypes.OVERWORLD_CLASSIC)
diff --git a/game/core/src/main/java/net/minecraft/core/world/type/WorldTypes.java b/game/core/src/main/java/net/minecraft/core/world/type/WorldTypes.java
index 96ef6c972..c1e22eb6b 100644
--- a/game/core/src/main/java/net/minecraft/core/world/type/WorldTypes.java
+++ b/game/core/src/main/java/net/minecraft/core/world/type/WorldTypes.java
@@ -5,6 +5,7 @@ import net.minecraft.core.data.registry.Registries;
 import net.minecraft.core.world.config.season.SeasonConfig;
 import net.minecraft.core.world.season.Seasons;
 import net.minecraft.core.world.type.nether.WorldTypeNether;
+import net.minecraft.core.world.type.nether.WorldTypeNetherB173;
 import net.minecraft.core.world.type.nether.WorldTypeNetherSkyblock;
 import net.minecraft.core.world.type.overworld.*;
 import net.minecraft.core.world.type.drift.WorldTypeDrift;
@@ -38,6 +39,18 @@ public abstract class WorldTypes {
                 .withTags(WorldTypeTags.NETHER, WorldTypeTags.HOT, WorldTypeTags.BREAKS_COMPASS, WorldTypeTags.BREAKS_TIMEPIECES)
         )
     );
+    public static final @NotNull WorldType NETHER_BETA_173 = register(
+        "minecraft:nether.beta_173",
+        new WorldTypeNetherB173(
+            WorldTypeNether.defaultProperties("worldType.nether.beta_173")
+                .bounds(0, 127, 32)
+                .oceanBlocks(Blocks.FLUID_LAVA_STILL)
+                .fillerBlock(Blocks.COBBLE_NETHERRACK)
+                .portalBounds(0, 127)
+                .withNoAurora()
+                .withTags(WorldTypeTags.NETHER, WorldTypeTags.HOT, WorldTypeTags.BREAKS_COMPASS, WorldTypeTags.BREAKS_TIMEPIECES)
+        )
+    );
     public static final @NotNull WorldType NETHER_SKYBLOCK = register(
         "minecraft:nether.skyblock",
         new WorldTypeNetherSkyblock(
diff --git a/game/core/src/main/java/net/minecraft/core/world/type/nether/WorldTypeNetherB173.java b/game/core/src/main/java/net/minecraft/core/world/type/nether/WorldTypeNetherB173.java
new file mode 100644
index 000000000..7eafce41f
--- /dev/null
+++ b/game/core/src/main/java/net/minecraft/core/world/type/nether/WorldTypeNetherB173.java
@@ -0,0 +1,30 @@
+package net.minecraft.core.world.type.nether;
+
+import net.minecraft.core.world.World;
+import net.minecraft.core.world.biome.Biome;
+import net.minecraft.core.world.biome.provider.BiomeProvider;
+import net.minecraft.core.world.biome.provider.BiomeProviderNetherB173;
+import net.minecraft.core.world.generate.chunk.ChunkGenerator;
+import net.minecraft.core.world.generate.chunk.perlin.nether.b173.ChunkGeneratorNetherB173;
+import org.jetbrains.annotations.NotNull;
+
+public class WorldTypeNetherB173 extends WorldTypeNether {
+    public WorldTypeNetherB173(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public @NotNull BiomeProvider createBiomeProvider(World world) {
+        return new BiomeProviderNetherB173(world);
+    }
+
+    @Override
+    public @NotNull Biome @NotNull [] allBiomes() {
+        return BiomeProviderNetherB173.allBiomes();
+    }
+
+    @Override
+    public ChunkGenerator createChunkGenerator(World world) {
+        return new ChunkGeneratorNetherB173(world);
+    }
+}
diff --git a/game/core/src/main/resources/assets/minecraft/lang/en_US/biomes.lang b/game/core/src/main/resources/assets/minecraft/lang/en_US/biomes.lang
index 3d5aeee0a..e595ccb5c 100644
--- a/game/core/src/main/resources/assets/minecraft/lang/en_US/biomes.lang
+++ b/game/core/src/main/resources/assets/minecraft/lang/en_US/biomes.lang
@@ -37,4 +37,6 @@ biome.overworld.legacy.taiga=Beta Taiga
 biome.overworld.legacy.shrubland=Beta Shrubland
 biome.overworld.legacy.forest=Beta Forest
 biome.overworld.legacy.seasonal_forest=Beta Seasonal Forest
-biome.overworld.legacy.rainforest=Beta Rainforest
\ No newline at end of file
+biome.overworld.legacy.rainforest=Beta Rainforest
+
+biome.nether.legacy.hell=Beta Hell
\ No newline at end of file
diff --git a/game/core/src/main/resources/assets/minecraft/lang/en_US/strings.lang b/game/core/src/main/resources/assets/minecraft/lang/en_US/strings.lang
index 24a86e707..a02f97277 100644
--- a/game/core/src/main/resources/assets/minecraft/lang/en_US/strings.lang
+++ b/game/core/src/main/resources/assets/minecraft/lang/en_US/strings.lang
@@ -66,6 +66,8 @@ worldType.overworld.skyblock.name=Skyblock
 worldType.overworld.skyblock.desc=Hardcore survival on a tiny\nisland in the sky.
 worldType.overworld.beta_173.name=Beta 1.7.3
 worldType.overworld.beta_173.desc=Terrain generation as similar as possible to\n Minecraft Beta 1.7.3.
+worldType.nether.beta_173.name=Beta 1.7.3
+worldType.nether.beta_173.desc=Terrain generation as similar as possible to\n Minecraft Beta 1.7.3.
 
 disconnect.genericReason=%s
 disconnect.disconnected=Disconnected by Server
diff --git a/game/core/src/main/resources/assets/minecraft/sounds/sounds.json b/game/core/src/main/resources/assets/minecraft/sounds/sounds.json
index 0b9e1b8b5..8e9115c42 100644
--- a/game/core/src/main/resources/assets/minecraft/sounds/sounds.json
+++ b/game/core/src/main/resources/assets/minecraft/sounds/sounds.json
@@ -1281,5 +1281,51 @@
         "stream": true
       }
     ]
+  },
+  "music.bta.nether": {
+    "sounds": [
+      {
+        "name": "btamusic/nether/nether1.ogg",
+        "title": "Venus",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether2.ogg",
+        "title": "Death Coils",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether3.ogg",
+        "title": "Reactor",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether4.ogg",
+        "title": "Outlands",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether5.ogg",
+        "title": "Nematocyst",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether6.ogg",
+        "title": "Alkali Feldspar",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      },
+      {
+        "name": "btamusic/nether/nether7.ogg",
+        "title": "Slip",
+        "author": "FullDisplayCollapse",
+        "stream": true
+      }
+    ]
   }
 }
\ No newline at end of file