diff --git a/camellia-server/src/main/java/su/plo/matter/Globals.java b/camellia-server/src/main/java/su/plo/matter/Globals.java
new file mode 100644
index 0000000..6d55f08
--- /dev/null
+++ b/camellia-server/src/main/java/su/plo/matter/Globals.java
@@ -0,0 +1,95 @@
+package su.plo.matter;
+
+import com.google.common.collect.Iterables;
+import me.earthme.luminol.config.modules.function.SecureSeedConfig;
+import net.minecraft.server.level.ServerLevel;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.Optional;
+
+public class Globals {
+    public static final int WORLD_SEED_LONGS = 16;
+    public static final int WORLD_SEED_BITS = WORLD_SEED_LONGS * 64;
+
+    public static final long[] worldSeed = new long[WORLD_SEED_LONGS];
+    public static final ThreadLocal<Integer> dimension = ThreadLocal.withInitial(() -> 0);
+
+    public enum Salt {
+        UNDEFINED,
+        BASTION_FEATURE,
+        WOODLAND_MANSION_FEATURE,
+        MINESHAFT_FEATURE,
+        BURIED_TREASURE_FEATURE,
+        NETHER_FORTRESS_FEATURE,
+        PILLAGER_OUTPOST_FEATURE,
+        GEODE_FEATURE,
+        NETHER_FOSSIL_FEATURE,
+        OCEAN_MONUMENT_FEATURE,
+        RUINED_PORTAL_FEATURE,
+        POTENTIONAL_FEATURE,
+        GENERATE_FEATURE,
+        JIGSAW_PLACEMENT,
+        STRONGHOLDS,
+        POPULATION,
+        DECORATION,
+        SLIME_CHUNK
+    }
+
+    public static void setupGlobals(ServerLevel world) {
+        if (!SecureSeedConfig.enabled) return;
+
+        long[] seed = world.worldGenSettings.options().featureSeed();
+        System.arraycopy(seed, 0, worldSeed, 0, WORLD_SEED_LONGS);
+        int worldIndex = Iterables.indexOf(world.getServer().levelKeys(), it -> it == world.dimension());
+        if (worldIndex == -1)
+            worldIndex = world.getServer().levelKeys().size(); // if we are in world construction it may not have been added to the map yet
+        dimension.set(worldIndex);
+    }
+
+    public static long[] createRandomWorldSeed() {
+        long[] seed = new long[WORLD_SEED_LONGS];
+        SecureRandom rand = new SecureRandom();
+        for (int i = 0; i < WORLD_SEED_LONGS; i++) {
+            seed[i] = rand.nextLong();
+        }
+        return seed;
+    }
+
+    // 1024-bit string -> 16 * 64 long[]
+    public static Optional<long[]> parseSeed(String seedStr) {
+        if (seedStr.isEmpty()) return Optional.empty();
+
+        if (seedStr.length() != WORLD_SEED_BITS) {
+            throw new IllegalArgumentException("Secure seed length must be " + WORLD_SEED_BITS + "-bit but found " + seedStr.length() + "-bit.");
+        }
+
+        long[] seed = new long[WORLD_SEED_LONGS];
+
+        for (int i = 0; i < WORLD_SEED_LONGS; i++) {
+            int start = i * 64;
+            int end = start + 64;
+            String seedSection = seedStr.substring(start, end);
+
+            BigInteger seedInDecimal = new BigInteger(seedSection, 2);
+            seed[i] = seedInDecimal.longValue();
+        }
+
+        return Optional.of(seed);
+    }
+
+    // 16 * 64 long[] -> 1024-bit string
+    public static String seedToString(long[] seed) {
+        StringBuilder sb = new StringBuilder();
+
+        for (long longV : seed) {
+            // Convert to 64-bit binary string per long
+            // Use format to keep 64-bit length, and use 0 to complete space
+            String binaryStr = String.format("%64s", Long.toBinaryString(longV)).replace(' ', '0');
+
+            sb.append(binaryStr);
+        }
+
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/camellia-server/src/main/java/su/plo/matter/Hashing.java b/camellia-server/src/main/java/su/plo/matter/Hashing.java
new file mode 100644
index 0000000..6f0fca1
--- /dev/null
+++ b/camellia-server/src/main/java/su/plo/matter/Hashing.java
@@ -0,0 +1,73 @@
+package su.plo.matter;
+
+public class Hashing {
+    // https://en.wikipedia.org/wiki/BLAKE_(hash_function)
+    // https://github.com/bcgit/bc-java/blob/master/core/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java
+
+    private final static long[] blake2b_IV = {
+            0x6a09e667f3bcc908L, 0xbb67ae8584caa73bL, 0x3c6ef372fe94f82bL,
+            0xa54ff53a5f1d36f1L, 0x510e527fade682d1L, 0x9b05688c2b3e6c1fL,
+            0x1f83d9abfb41bd6bL, 0x5be0cd19137e2179L
+    };
+
+    private final static byte[][] blake2b_sigma = {
+            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
+            {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
+            {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
+            {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
+            {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
+            {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
+            {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
+            {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
+            {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
+            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}
+    };
+
+    public static long[] hashWorldSeed(long[] worldSeed) {
+        long[] result = blake2b_IV.clone();
+        result[0] ^= 0x01010040;
+        hash(worldSeed, result, new long[16], 0, false);
+        return result;
+    }
+
+    public static void hash(long[] message, long[] chainValue, long[] internalState, long messageOffset, boolean isFinal) {
+        assert message.length == 16;
+        assert chainValue.length == 8;
+        assert internalState.length == 16;
+
+        System.arraycopy(chainValue, 0, internalState, 0, chainValue.length);
+        System.arraycopy(blake2b_IV, 0, internalState, chainValue.length, 4);
+        internalState[12] = messageOffset ^ blake2b_IV[4];
+        internalState[13] = blake2b_IV[5];
+        if (isFinal) internalState[14] = ~blake2b_IV[6];
+        internalState[15] = blake2b_IV[7];
+
+        for (int round = 0; round < 12; round++) {
+            G(message[blake2b_sigma[round][0]], message[blake2b_sigma[round][1]], 0, 4, 8, 12, internalState);
+            G(message[blake2b_sigma[round][2]], message[blake2b_sigma[round][3]], 1, 5, 9, 13, internalState);
+            G(message[blake2b_sigma[round][4]], message[blake2b_sigma[round][5]], 2, 6, 10, 14, internalState);
+            G(message[blake2b_sigma[round][6]], message[blake2b_sigma[round][7]], 3, 7, 11, 15, internalState);
+            G(message[blake2b_sigma[round][8]], message[blake2b_sigma[round][9]], 0, 5, 10, 15, internalState);
+            G(message[blake2b_sigma[round][10]], message[blake2b_sigma[round][11]], 1, 6, 11, 12, internalState);
+            G(message[blake2b_sigma[round][12]], message[blake2b_sigma[round][13]], 2, 7, 8, 13, internalState);
+            G(message[blake2b_sigma[round][14]], message[blake2b_sigma[round][15]], 3, 4, 9, 14, internalState);
+        }
+
+        for (int i = 0; i < 8; i++) {
+            chainValue[i] ^= internalState[i] ^ internalState[i + 8];
+        }
+    }
+
+    private static void G(long m1, long m2, int posA, int posB, int posC, int posD, long[] internalState) {
+        internalState[posA] = internalState[posA] + internalState[posB] + m1;
+        internalState[posD] = Long.rotateRight(internalState[posD] ^ internalState[posA], 32);
+        internalState[posC] = internalState[posC] + internalState[posD];
+        internalState[posB] = Long.rotateRight(internalState[posB] ^ internalState[posC], 24); // replaces 25 of BLAKE
+        internalState[posA] = internalState[posA] + internalState[posB] + m2;
+        internalState[posD] = Long.rotateRight(internalState[posD] ^ internalState[posA], 16);
+        internalState[posC] = internalState[posC] + internalState[posD];
+        internalState[posB] = Long.rotateRight(internalState[posB] ^ internalState[posC], 63); // replaces 11 of BLAKE
+    }
+}
\ No newline at end of file
diff --git a/camellia-server/src/main/java/su/plo/matter/HashingV2.java b/camellia-server/src/main/java/su/plo/matter/HashingV2.java
new file mode 100644
index 0000000..89ffd1b
--- /dev/null
+++ b/camellia-server/src/main/java/su/plo/matter/HashingV2.java
@@ -0,0 +1,519 @@
+package su.plo.matter;
+
+import me.earthme.luminol.config.modules.function.SecureSeedConfig;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+public class HashingV2 {
+    private static final int BLOCK_LEN = 64;
+    private static final int CHUNK_LEN = 1024;
+    private static final int OUT_LEN = 32;
+    private static final int KEY_LEN = 32;
+
+    private static final int CHUNK_START = 1 << 0;
+    private static final int CHUNK_END = 1 << 1;
+    private static final int PARENT = 1 << 2;
+    private static final int ROOT = 1 << 3;
+    private static final int KEYED_HASH = 1 << 4;
+    private static final int DERIVE_KEY_CONTEXT = 1 << 5;
+    private static final int DERIVE_KEY_MATERIAL = 1 << 6;
+
+    private static final int[] IV = {
+            0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+            0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
+    };
+
+    private static final int[] MSG_PERMUTATION = {2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8};
+
+    private static final ThreadLocal<SaltHolder> saltHolderLocal = ThreadLocal.withInitial(() -> {
+        final SaltHolder newHolder = new SaltHolder();
+
+        newHolder.init(SecureSeedConfig.salt);
+
+        return newHolder;
+    });
+    private static final ThreadLocal<byte[]> threadBuffer = ThreadLocal.withInitial(() -> new byte[128]);
+    private static final ThreadLocal<ByteBuffer> threadByteBuffer = ThreadLocal.withInitial(() -> ByteBuffer.allocate(128).order(ByteOrder.LITTLE_ENDIAN));
+
+    private static int rotr32(int x, int k) {
+        return ((x >>> k) | (x << (32 - k))) >>> 0;
+    }
+
+    private static void g(int[] state, int a, int b, int c, int d, int mx, int my) {
+        state[a] = (state[a] + state[b] + mx) >>> 0;
+        state[d] = rotr32(state[d] ^ state[a], 16);
+        state[c] = (state[c] + state[d]) >>> 0;
+        state[b] = rotr32(state[b] ^ state[c], 12);
+        state[a] = (state[a] + state[b] + my) >>> 0;
+        state[d] = rotr32(state[d] ^ state[a], 8);
+        state[c] = (state[c] + state[d]) >>> 0;
+        state[b] = rotr32(state[b] ^ state[c], 7);
+    }
+
+    private static void round(int[] state, int[] m) {
+        g(state, 0, 4, 8, 12, m[0], m[1]);
+        g(state, 1, 5, 9, 13, m[2], m[3]);
+        g(state, 2, 6, 10, 14, m[4], m[5]);
+        g(state, 3, 7, 11, 15, m[6], m[7]);
+        g(state, 0, 5, 10, 15, m[8], m[9]);
+        g(state, 1, 6, 11, 12, m[10], m[11]);
+        g(state, 2, 7, 8, 13, m[12], m[13]);
+        g(state, 3, 4, 9, 14, m[14], m[15]);
+    }
+
+    private static int[] permute(int[] m) {
+        int[] permuted = new int[16];
+        for (int i = 0; i < 16; i++) {
+            permuted[i] = m[MSG_PERMUTATION[i]];
+        }
+        return permuted;
+    }
+
+    private static int[] compress(int[] chainingValue, int[] blockWords, long counter, int blockLen, int flags) {
+        int counterLow = (int) (counter >>> 0);
+        int counterHigh = (int) ((counter / 0x100000000L) >>> 0);
+
+        int[] state = new int[16];
+        System.arraycopy(chainingValue, 0, state, 0, 8);
+        state[8] = IV[0];
+        state[9] = IV[1];
+        state[10] = IV[2];
+        state[11] = IV[3];
+        state[12] = counterLow;
+        state[13] = counterHigh;
+        state[14] = blockLen;
+        state[15] = flags;
+
+        int[] block = Arrays.copyOf(blockWords, 16);
+
+        for (int i = 0; i < 7; i++) {
+            round(state, block);
+            block = permute(block);
+        }
+
+        int[] output = new int[16];
+        for (int i = 0; i < 8; i++) {
+            output[i] = state[i] ^ state[i + 8];
+            output[i + 8] = state[i + 8] ^ chainingValue[i];
+        }
+
+        return output;
+    }
+
+    private static int[] first8Words(int[] compressionOutput) {
+        return Arrays.copyOfRange(compressionOutput, 0, 8);
+    }
+
+    private static int[] wordsFromLittleEndianBytes(byte[] bytes) {
+        int[] words = new int[bytes.length / 4];
+        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
+        for (int i = 0; i < words.length; i++) {
+            words[i] = buffer.getInt(i * 4);
+        }
+        return words;
+    }
+
+    private static byte[] wordsToLittleEndianBytes(int[] words, int outputLen) {
+        byte[] output = new byte[outputLen];
+        ByteBuffer buffer = ByteBuffer.wrap(output).order(ByteOrder.LITTLE_ENDIAN);
+        for (int i = 0; i < words.length && i * 4 < outputLen; i++) {
+            buffer.putInt(i * 4, words[i]);
+        }
+        return output;
+    }
+
+    private static class ChunkState {
+        int[] chainingValue;
+        long chunkCounter;
+        byte[] block;
+        int blockLen;
+        int blocksCompressed;
+        int flags;
+
+        ChunkState(int[] keyWords, long chunkCounter, int flags) {
+            this.chainingValue = keyWords.clone();
+            this.chunkCounter = chunkCounter;
+            this.block = new byte[BLOCK_LEN];
+            this.blockLen = 0;
+            this.blocksCompressed = 0;
+            this.flags = flags;
+        }
+
+        int len() {
+            return BLOCK_LEN * this.blocksCompressed + this.blockLen;
+        }
+
+        int startFlag() {
+            return this.blocksCompressed == 0 ? CHUNK_START : 0;
+        }
+
+        void update(byte[] input) {
+            int offset = 0;
+
+            while (offset < input.length) {
+                if (this.blockLen == BLOCK_LEN) {
+                    int[] blockWords = wordsFromLittleEndianBytes(this.block);
+                    this.chainingValue = first8Words(compress(
+                            this.chainingValue,
+                            blockWords,
+                            this.chunkCounter,
+                            BLOCK_LEN,
+                            this.flags | this.startFlag()
+                    ));
+                    this.blocksCompressed++;
+                    this.block = new byte[BLOCK_LEN];
+                    this.blockLen = 0;
+                }
+
+                int want = BLOCK_LEN - this.blockLen;
+                int take = Math.min(want, input.length - offset);
+                System.arraycopy(input, offset, this.block, this.blockLen, take);
+                this.blockLen += take;
+                offset += take;
+            }
+        }
+
+        int[] outputBlockWords() {
+            int[] blockWords = new int[16];
+            for (int i = 0; i < 16 && i * 4 < this.blockLen; i++) {
+                blockWords[i] = ((this.block[i * 4 + 0] & 0xFF)) |
+                        ((this.block[i * 4 + 1] & 0xFF) << 8) |
+                        ((this.block[i * 4 + 2] & 0xFF) << 16) |
+                        ((this.block[i * 4 + 3] & 0xFF) << 24);
+            }
+            return blockWords;
+        }
+
+        Output output() {
+            return new Output(
+                    this.chainingValue,
+                    outputBlockWords(),
+                    this.chunkCounter,
+                    this.blockLen,
+                    this.flags | this.startFlag() | CHUNK_END
+            );
+        }
+    }
+
+    private static class Output {
+        int[] inputChainingValue;
+        int[] blockWords;
+        long counter;
+        int blockLen;
+        int flags;
+
+        Output(int[] inputChainingValue, int[] blockWords, long counter, int blockLen, int flags) {
+            this.inputChainingValue = inputChainingValue;
+            this.blockWords = blockWords;
+            this.counter = counter;
+            this.blockLen = blockLen;
+            this.flags = flags;
+        }
+
+        int[] chainingValue() {
+            return first8Words(compress(
+                    this.inputChainingValue,
+                    this.blockWords,
+                    this.counter,
+                    this.blockLen,
+                    this.flags
+            ));
+        }
+
+        byte[] rootOutputBytes(int outLen) {
+            byte[] output = new byte[outLen];
+            long outputBlockCounter = 0;
+
+            for (int offset = 0; offset < outLen; offset += 2 * OUT_LEN) {
+                int[] words = compress(
+                        this.inputChainingValue,
+                        this.blockWords,
+                        outputBlockCounter,
+                        this.blockLen,
+                        this.flags | ROOT
+                );
+
+                byte[] blockOutput = wordsToLittleEndianBytes(words, 64);
+
+                int remaining = outLen - offset;
+                int copyLen = Math.min(remaining, 64);
+                System.arraycopy(blockOutput, 0, output, offset, copyLen);
+
+                outputBlockCounter++;
+            }
+
+            return output;
+        }
+    }
+
+    private static Output parentOutput(int[] leftChildCv, int[] rightChildCv, int[] keyWords, int flags) {
+        int[] blockWords = new int[16];
+        System.arraycopy(leftChildCv, 0, blockWords, 0, 8);
+        System.arraycopy(rightChildCv, 0, blockWords, 8, 8);
+
+        return new Output(
+                keyWords,
+                blockWords,
+                0,
+                BLOCK_LEN,
+                PARENT | flags
+        );
+    }
+
+    private static int[] parentCv(int[] leftChildCv, int[] rightChildCv, int[] keyWords, int flags) {
+        return parentOutput(leftChildCv, rightChildCv, keyWords, flags).chainingValue();
+    }
+
+    private static class SaltHolder {
+        private long[] cachedSaltHash = null;
+        private String lastSalt = null;
+
+        public void init(String currentSalt) {
+            if (cachedSaltHash == null || !currentSalt.equals(lastSalt)) {
+                byte[] saltBytes = currentSalt.getBytes();
+                byte[] hashBytes = blake3(saltBytes);
+                int[] hashInts = bytesToIntsLittleEndian(hashBytes);
+
+                cachedSaltHash = new long[8];
+                for (int i = 0; i < 8; i++) {
+                    cachedSaltHash[i] = (hashInts[i] & 0xFFFFFFFFL);
+                }
+                lastSalt = currentSalt;
+            }
+        }
+    }
+
+    private static class Hasher {
+        ChunkState chunkState;
+        int[] keyWords;
+        java.util.ArrayList<int[]> cvStack;
+        int flags;
+
+        Hasher(int[] keyWords, int flags) {
+            this.chunkState = new ChunkState(keyWords, 0, flags);
+            this.keyWords = keyWords.clone();
+            this.cvStack = new java.util.ArrayList<>();
+            this.flags = flags;
+        }
+
+        static Hasher createNew() {
+            int[] iv = {IV[0], IV[1], IV[2], IV[3], IV[4], IV[5], IV[6], IV[7]};
+            return new Hasher(iv, 0);
+        }
+
+        static Hasher createKeyed(byte[] key) {
+            if (key.length != KEY_LEN) {
+                throw new IllegalArgumentException("Key must be " + KEY_LEN + " bytes");
+            }
+            int[] keyWords = wordsFromLittleEndianBytes(key);
+            return new Hasher(keyWords, KEYED_HASH);
+        }
+
+        void pushStack(int[] cv) {
+            cvStack.add(cv);
+        }
+
+        int[] popStack() {
+            return cvStack.remove(cvStack.size() - 1);
+        }
+
+        void addChunkChainingValue(int[] newCv, long totalChunks) {
+            int[] cv = newCv;
+            long chunks = totalChunks;
+
+            while ((chunks & 1) == 0) {
+                cv = parentCv(popStack(), cv, this.keyWords, this.flags);
+                chunks >>>= 1;
+            }
+
+            pushStack(cv);
+        }
+
+        void update(byte[] input) {
+            int offset = 0;
+
+            while (offset < input.length) {
+                if (this.chunkState.len() == CHUNK_LEN) {
+                    int[] chunkCv = this.chunkState.output().chainingValue();
+                    long totalChunks = this.chunkState.chunkCounter + 1;
+                    addChunkChainingValue(chunkCv, totalChunks);
+                    this.chunkState = new ChunkState(this.keyWords, totalChunks, this.flags);
+                }
+
+                int want = CHUNK_LEN - this.chunkState.len();
+                int take = Math.min(want, input.length - offset);
+                byte[] chunk = new byte[take];
+                System.arraycopy(input, offset, chunk, 0, take);
+                this.chunkState.update(chunk);
+                offset += take;
+            }
+        }
+
+        byte[] finalize(int outLen) {
+            Output output = this.chunkState.output();
+            int parentNodesRemaining = this.cvStack.size();
+
+            while (parentNodesRemaining > 0) {
+                parentNodesRemaining--;
+                output = parentOutput(
+                        this.cvStack.get(parentNodesRemaining),
+                        output.chainingValue(),
+                        this.keyWords,
+                        this.flags
+                );
+            }
+
+            return output.rootOutputBytes(outLen);
+        }
+    }
+
+    private static byte[] blake3(byte[] data) {
+        Hasher hasher = Hasher.createNew();
+        hasher.update(data);
+        return hasher.finalize(OUT_LEN);
+    }
+
+    private static byte[] blake3Keyed(byte[] data, byte[] key) {
+        Hasher hasher = Hasher.createKeyed(key);
+        hasher.update(data);
+        return hasher.finalize(OUT_LEN);
+    }
+
+    private static byte[] blake3Keyed(byte[] data, byte[] key, int outLen) {
+        Hasher hasher = Hasher.createKeyed(key);
+        hasher.update(data);
+        return hasher.finalize(outLen);
+    }
+
+    private static int[] bytesToIntsLittleEndian(byte[] bytes) {
+        int[] ints = new int[bytes.length / 4];
+        for (int i = 0; i < ints.length; i++) {
+            ints[i] = ((bytes[i * 4 + 0] & 0xFF)) |
+                    ((bytes[i * 4 + 1] & 0xFF) << 8) |
+                    ((bytes[i * 4 + 2] & 0xFF) << 16) |
+                    ((bytes[i * 4 + 3] & 0xFF) << 24);
+        }
+        return ints;
+    }
+
+    private static int[] blake3Ints(byte[] data, int outLen) {
+        byte[] result = blake3(data);
+        if (outLen <= 32) {
+            return bytesToIntsLittleEndian(Arrays.copyOf(result, outLen));
+        }
+        return bytesToIntsLittleEndian(result);
+    }
+
+    private static long[] getSaltHash() {
+        final SaltHolder currHolder = saltHolderLocal.get();
+
+        return currHolder.cachedSaltHash;
+    }
+
+    private static long[] hashWorldSeedInternal(long[] worldSeed) {
+        byte[] seedBytes = new byte[worldSeed.length * 8];
+        ByteBuffer buffer = ByteBuffer.wrap(seedBytes).order(ByteOrder.LITTLE_ENDIAN);
+        for (long l : worldSeed) {
+            buffer.putLong(l);
+        }
+
+        byte[] hashBytes = blake3(seedBytes);
+        int[] hashInts = bytesToIntsLittleEndian(hashBytes);
+
+        long[] result = new long[8];
+        for (int i = 0; i < 8; i++) {
+            result[i] = hashInts[i] & 0xFFFFFFFFL;
+        }
+        return result;
+    }
+
+    public static long[] hashWorldSeed(long[] worldSeed) {
+        if (!SecureSeedConfig.enabled && SecureSeedConfig.version == 2) {
+            return worldSeed.clone();
+        }
+
+        long[] saltHashValue = getSaltHash();
+        long[] saltedSeed = new long[worldSeed.length];
+
+        for (int i = 0; i < worldSeed.length; i++) {
+            saltedSeed[i] = worldSeed[i] ^ saltHashValue[i % saltHashValue.length];
+        }
+
+        return hashWorldSeedInternal(saltedSeed);
+    }
+
+    public static long[] expandLevelSeedTo1024Bits(long levelSeed) {
+        if (!SecureSeedConfig.enabled && SecureSeedConfig.version == 2) {
+            long[] result = new long[Globals.WORLD_SEED_LONGS];
+            for (int i = 0; i < Globals.WORLD_SEED_LONGS; i++) {
+                result[i] = levelSeed ^ (i * 0x9E3779B97F4A7C15L);
+            }
+            return result;
+        }
+
+        String salt = SecureSeedConfig.salt;
+        byte[] saltBytes = salt.getBytes(java.nio.charset.StandardCharsets.UTF_8);
+        byte[] saltKey = blake3(saltBytes);
+
+        long[] result = new long[Globals.WORLD_SEED_LONGS];
+
+        for (int segment = 0; segment < Globals.WORLD_SEED_LONGS; segment++) {
+            byte[] input = new byte[16];
+            ByteBuffer buf = ByteBuffer.wrap(input).order(ByteOrder.LITTLE_ENDIAN);
+            buf.putLong(0, levelSeed);
+            buf.putLong(8, segment);
+
+            byte[] hash = blake3Keyed(input, saltKey, 32);
+            int[] hashInts = bytesToIntsLittleEndian(hash);
+
+            result[segment] = ((long) hashInts[0] & 0xFFFFFFFFL) |
+                    (((long) hashInts[1] & 0xFFFFFFFFL) << 32);
+        }
+
+        return result;
+    }
+
+    public static long getTerrainSeed(long[] hashedSeed, TerrainType type) {
+        return hashedSeed[type.ordinal() % hashedSeed.length];
+    }
+
+    public enum TerrainType {
+        BASE_TERRAIN,
+        BIOME_NOISE,
+        CLIMATE,
+        AQUIFER,
+        ORE,
+        SURFACE,
+        VEGETATION,
+        SHIFT
+    }
+
+    public static void hash(long[] message, long[] output, long[] state, int outputBytes, boolean finalBlock) {
+        int len = message.length * 8;
+        byte[] buffer = threadBuffer.get();
+        if (buffer.length < len) {
+            buffer = new byte[len];
+            threadBuffer.set(buffer);
+        }
+
+        ByteBuffer buf = threadByteBuffer.get();
+        if (buf.capacity() < len) {
+            buf = ByteBuffer.allocate(len).order(ByteOrder.LITTLE_ENDIAN);
+            threadByteBuffer.set(buf);
+        }
+        buf.clear();
+
+        for (long l : message) {
+            buf.putLong(l);
+        }
+
+        byte[] hashBytes = blake3(Arrays.copyOf(buffer, len));
+        int[] hashInts = bytesToIntsLittleEndian(hashBytes);
+
+        for (int i = 0; i < Math.min(hashInts.length, output.length); i++) {
+            output[i] = hashInts[i] & 0xFFFFFFFFL;
+        }
+    }
+}
diff --git a/camellia-server/src/main/java/su/plo/matter/WorldgenCryptoRandom.java b/camellia-server/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
new file mode 100644
index 0000000..dc53035
--- /dev/null
+++ b/camellia-server/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
@@ -0,0 +1,190 @@
+package su.plo.matter;
+
+import me.earthme.luminol.config.modules.function.SecureSeedConfig;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.levelgen.LegacyRandomSource;
+import net.minecraft.world.level.levelgen.WorldgenRandom;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public class WorldgenCryptoRandom extends WorldgenRandom {
+    // hash the world seed to guard against badly chosen world seeds
+    private static final long[] HASHED_ZERO_SEED = Hashing.hashWorldSeed(new long[Globals.WORLD_SEED_LONGS]);
+    private static final ThreadLocal<long[]> LAST_SEEN_WORLD_SEED = ThreadLocal.withInitial(() -> new long[Globals.WORLD_SEED_LONGS]);
+    private static final ThreadLocal<long[]> HASHED_WORLD_SEED = ThreadLocal.withInitial(() -> HASHED_ZERO_SEED);
+
+    private final long[] worldSeed = new long[Globals.WORLD_SEED_LONGS];
+    private final long[] randomBits = new long[8];
+    private int randomBitIndex;
+    private static final int MAX_RANDOM_BIT_INDEX = 64 * 8;
+    private static final int LOG2_MAX_RANDOM_BIT_INDEX = 9;
+    private long counter;
+    private final long[] message = new long[16];
+    private final long[] cachedInternalState = new long[16];
+
+    public WorldgenCryptoRandom(int x, int z, Globals.Salt typeSalt, long salt) {
+        super(new LegacyRandomSource(0L));
+
+        if (typeSalt == null) {
+            return;
+        }
+
+        if (SecureSeedConfig.enabled) {
+            this.setSecureSeed(x, z, typeSalt, salt);
+        } else {
+            super.setSeed(((long) x << 32) | ((long) z & 0xffffffffL) ^ salt);
+        }
+    }
+
+    public void setSecureSeed(int x, int z, Globals.Salt typeSalt, long salt) {
+        if (!SecureSeedConfig.enabled) {
+            super.setSeed(((long) x << 32) | ((long) z & 0xffffffffL) ^ salt);
+            return;
+        }
+
+        System.arraycopy(Globals.worldSeed, 0, this.worldSeed, 0, Globals.WORLD_SEED_LONGS);
+        message[0] = ((long) x << 32) | ((long) z & 0xffffffffL);
+        message[1] = ((long) Globals.dimension.get() << 32) | ((long) salt & 0xffffffffL);
+        message[2] = typeSalt.ordinal();
+        message[3] = counter = 0;
+        randomBitIndex = MAX_RANDOM_BIT_INDEX;
+    }
+
+    private long[] getHashedWorldSeed() {
+        if (!Arrays.equals(worldSeed, LAST_SEEN_WORLD_SEED.get())) {
+            HASHED_WORLD_SEED.set(Hashing.hashWorldSeed(worldSeed));
+            System.arraycopy(worldSeed, 0, LAST_SEEN_WORLD_SEED.get(), 0, Globals.WORLD_SEED_LONGS);
+        }
+        return HASHED_WORLD_SEED.get();
+    }
+
+    private void moreRandomBits() {
+        message[3] = counter++;
+        System.arraycopy(getHashedWorldSeed(), 0, randomBits, 0, 8);
+        Hashing.hash(message, randomBits, cachedInternalState, 64, true);
+    }
+
+    private long getBits(int count) {
+        if (randomBitIndex >= MAX_RANDOM_BIT_INDEX) {
+            moreRandomBits();
+            randomBitIndex -= MAX_RANDOM_BIT_INDEX;
+        }
+
+        int alignment = randomBitIndex & 63;
+        if ((randomBitIndex >>> 6) == ((randomBitIndex + count) >>> 6)) {
+            long result = (randomBits[randomBitIndex >>> 6] >>> alignment) & ((1L << count) - 1);
+            randomBitIndex += count;
+            return result;
+        } else {
+            long result = (randomBits[randomBitIndex >>> 6] >>> alignment) & ((1L << (64 - alignment)) - 1);
+            randomBitIndex += count;
+            if (randomBitIndex >= MAX_RANDOM_BIT_INDEX) {
+                moreRandomBits();
+                randomBitIndex -= MAX_RANDOM_BIT_INDEX;
+            }
+            alignment = randomBitIndex & 63;
+            result <<= alignment;
+            result |= (randomBits[randomBitIndex >>> 6] >>> (64 - alignment)) & ((1L << alignment) - 1);
+
+            return result;
+        }
+    }
+
+    @Override
+    public @NotNull RandomSource fork() {
+        if (!SecureSeedConfig.enabled) {
+            return super.fork();
+        }
+
+        WorldgenCryptoRandom fork = new WorldgenCryptoRandom(0, 0, null, 0);
+
+        System.arraycopy(Globals.worldSeed, 0, fork.worldSeed, 0, Globals.WORLD_SEED_LONGS);
+        fork.message[0] = this.message[0];
+        fork.message[1] = this.message[1];
+        fork.message[2] = this.message[2];
+        fork.message[3] = this.message[3];
+        fork.randomBitIndex = this.randomBitIndex;
+        fork.counter = this.counter;
+        fork.nextLong();
+
+        return fork;
+    }
+
+    @Override
+    public int next(int bits) {
+        return SecureSeedConfig.enabled ? (int) getBits(bits) : super.next(bits);
+    }
+
+    @Override
+    public void consumeCount(int count) {
+        if (!SecureSeedConfig.enabled) {
+            return;
+        }
+
+        randomBitIndex += count;
+        if (randomBitIndex >= MAX_RANDOM_BIT_INDEX * 2) {
+            randomBitIndex -= MAX_RANDOM_BIT_INDEX;
+            counter += randomBitIndex >>> LOG2_MAX_RANDOM_BIT_INDEX;
+            randomBitIndex &= MAX_RANDOM_BIT_INDEX - 1;
+            randomBitIndex += MAX_RANDOM_BIT_INDEX;
+        }
+    }
+
+    @Override
+    public int nextInt(int bound) {
+        if (!SecureSeedConfig.enabled) {
+            return super.nextInt(bound);
+        }
+        int bits = Mth.ceillog2(bound);
+        int result;
+        do {
+            result = (int) getBits(bits);
+        } while (result >= bound);
+
+        return result;
+    }
+
+    @Override
+    public long nextLong() {
+        return SecureSeedConfig.enabled ? getBits(64) : super.nextLong();
+    }
+
+    @Override
+    public double nextDouble() {
+        return SecureSeedConfig.enabled ? (getBits(53) * 0x1.0p-53) : super.nextDouble();
+    }
+
+    @Override
+    public long setDecorationSeed(long worldSeed, int blockX, int blockZ) {
+        if (!SecureSeedConfig.enabled) {
+            return super.setDecorationSeed(worldSeed, blockX, blockZ);
+        }
+        setSecureSeed(blockX, blockZ, Globals.Salt.POPULATION, 0);
+        return ((long) blockX << 32) | ((long) blockZ & 0xffffffffL);
+    }
+
+    @Override
+    public void setFeatureSeed(long populationSeed, int index, int step) {
+        if (!SecureSeedConfig.enabled) {
+            super.setFeatureSeed(populationSeed, index, step);
+            return;
+        }
+        setSecureSeed((int) (populationSeed >> 32), (int) populationSeed, Globals.Salt.DECORATION, index + 10000L * step);
+    }
+
+    @Override
+    public void setLargeFeatureSeed(long worldSeed, int chunkX, int chunkZ) {
+        super.setLargeFeatureSeed(worldSeed, chunkX, chunkZ);
+    }
+
+    @Override
+    public void setLargeFeatureWithSalt(long worldSeed, int regionX, int regionZ, int salt) {
+        super.setLargeFeatureWithSalt(worldSeed, regionX, regionZ, salt);
+    }
+
+    public static RandomSource seedSlimeChunk(int chunkX, int chunkZ) {
+        return new WorldgenCryptoRandom(chunkX, chunkZ, Globals.Salt.SLIME_CHUNK, 0);
+    }
+}
\ No newline at end of file