diff --git a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/RandomSource.java b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/RandomSource.java
index 62b83b3..e8048a4 100644
--- a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/RandomSource.java
+++ b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/RandomSource.java
@@ -490,6 +490,53 @@
     }
 
     /**
+     * Creates a seed suitable for the implementing class represented by this random source.
+     *
+     * <p>The seed will be created as if passing a {@code null} seed to the factory method
+     * {@link #create(RandomSource, Object, Object...)}. It will satisfy the seed size and any
+     * other seed requirements for the implementing class. The seed is converted from the native
+     * type to a byte representation.</p>
+     *
+     * <p>Usage example:</p>
+     * <pre><code>
+     *  RandomSource source = ...;
+     *  byte[] seed = source.createSeed();
+     *  UniformRandomProvider rng = RandomSource.create(source, seed);
+     * </code></pre>
+     *
+     * @return the seed
+     *
+     * @since 1.3
+     */
+    public byte[] createSeed() {
+        return internalIdentifier.createSeedBytes();
+    }
+
+    /**
+     * Creates a seed suitable for the implementing class represented by this random source
+     * using the supplied source of randomness.
+     *
+     * <p>The seed will satisfy the seed size and any other seed requirements for the
+     * implementing class.</p>
+     *
+     * <p>Usage example:</p>
+     * <pre><code>
+     *  RandomSource source = ...;
+     *  UniformRandomProvider seedRng = new JDKRandomWrapper(new SecureRandom());
+     *  byte[] seed = source.createSeed(seedRng);
+     *  UniformRandomProvider rng = RandomSource.create(source, seed);
+     * </code></pre>
+     *
+     * @param rng Source of randomness.
+     * @return the seed
+     *
+     * @since 1.3
+     */
+    public byte[] createSeed(UniformRandomProvider rng) {
+        return internalIdentifier.createSeedBytes(rng);
+    }
+
+    /**
      * Checks whether the implementing class represented by this random source
      * supports the {@link org.apache.commons.rng.JumpableUniformRandomProvider
      * JumpableUniformRandomProvider} interface. If {@code true} the instance returned
diff --git a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/NativeSeedType.java b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/NativeSeedType.java
index 1db19ee..0fe9da5 100644
--- a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/NativeSeedType.java
+++ b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/NativeSeedType.java
@@ -16,6 +16,8 @@
  */
 package org.apache.commons.rng.simple.internal;
 
+import org.apache.commons.rng.core.util.NumberFactory;
+
 /**
  * The native seed type. Contains values for all native seed types and methods
  * to convert supported seed types to the native seed type.
@@ -41,7 +43,7 @@
  */
 public enum NativeSeedType {
     /** The seed type is {@code Integer}. */
-    INT(Integer.class) {
+    INT(Integer.class, 4) {
         @Override
         public Integer createSeed(int size) {
             return SeedFactory.createInt();
@@ -68,7 +70,7 @@
         }
     },
     /** The seed type is {@code Long}. */
-    LONG(Long.class) {
+    LONG(Long.class, 8) {
         @Override
         public Long createSeed(int size) {
             return SeedFactory.createLong();
@@ -95,7 +97,7 @@
         }
     },
     /** The seed type is {@code int[]}. */
-    INT_ARRAY(int[].class) {
+    INT_ARRAY(int[].class, 4) {
         @Override
         public int[] createSeed(int size) {
             // Limit the number of calls to the synchronized method. The generator
@@ -124,7 +126,7 @@
         }
     },
     /** The seed type is {@code long[]}. */
-    LONG_ARRAY(long[].class) {
+    LONG_ARRAY(long[].class, 8) {
         @Override
         public long[] createSeed(int size) {
             // Limit the number of calls to the synchronized method. The generator
@@ -153,6 +155,8 @@
         }
     };
 
+    /** Error message for unrecognised seed types. */
+    private static final String UNRECOGNISED_SEED = "Unrecognized seed type: ";
     /** Maximum length of the seed array (for creating array seeds). */
     private static final int RANDOM_SEED_ARRAY_SIZE = 128;
     /** Convert {@code Long} to {@code Integer}. */
@@ -180,10 +184,20 @@
     private final Class<?> type;
 
     /**
-     * @param type Define the class type of the native seed.
+     * Define the number of bytes required to represent the native seed. If the type is
+     * an array then this represents the size of a single value of the type.
      */
-    NativeSeedType(Class<?> type) {
+    private final int bytes;
+
+    /**
+     * Instantiates a new native seed type.
+     *
+     * @param type Define the class type of the native seed.
+     * @param bytes Define the number of bytes required to represent the native seed.
+     */
+    NativeSeedType(Class<?> type, int bytes) {
         this.type = type;
+        this.bytes = bytes;
     }
 
     /**
@@ -196,6 +210,16 @@
     }
 
     /**
+     * Gets the number of bytes required to represent the native seed type. If the type is
+     * an array then this represents the size of a single value of the type.
+     *
+     * @return the number of bytes
+     */
+    public int getBytes() {
+        return bytes;
+    }
+
+    /**
      * Creates the seed. The output seed type is determined by the native seed type. If the
      * output is an array the required size of the array can be specified.
      *
@@ -230,7 +254,7 @@
             return convert((byte[]) seed, size);
         }
 
-        throw new UnsupportedOperationException("Unrecognized seed type: " + seed);
+        throw new UnsupportedOperationException(UNRECOGNISED_SEED + seed);
     }
 
     /**
@@ -277,4 +301,27 @@
      * @return the native seed.
      */
     protected abstract Object convert(byte[] seed, int size);
+
+    /**
+     * Converts the input seed from any of the supported seed types to bytes.
+     *
+     * @param seed Input seed.
+     * @return the seed bytes.
+     * @throws UnsupportedOperationException if the {@code seed} type is invalid.
+     */
+    public static byte[] convertSeedToBytes(Object seed) {
+        if (seed instanceof Integer) {
+            return NumberFactory.makeByteArray((Integer) seed);
+        } else if (seed instanceof Long) {
+            return NumberFactory.makeByteArray((Long) seed);
+        } else if (seed instanceof int[]) {
+            return NumberFactory.makeByteArray((int[]) seed);
+        } else if (seed instanceof long[]) {
+            return NumberFactory.makeByteArray((long[]) seed);
+        } else if (seed instanceof byte[]) {
+            return (byte[]) seed;
+        }
+
+        throw new UnsupportedOperationException(UNRECOGNISED_SEED + seed);
+    }
 }
diff --git a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/ProviderBuilder.java b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/ProviderBuilder.java
index 59b9271..02af9fc 100644
--- a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/ProviderBuilder.java
+++ b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/ProviderBuilder.java
@@ -272,20 +272,35 @@
                 return super.convertSeed(seed);
             }
 
+            @Override
+            protected byte[] createByteArraySeed(UniformRandomProvider source) {
+                return NativeSeedType.convertSeedToBytes(createMswsSeed(source));
+            }
+
             /**
-             * Creates the full length seed array from the input seed using the method
-             * recommended for the generator. This is a high quality Weyl increment composed
-             * of a hex character permutation.
+             * Creates the full length seed array from the input seed.
              *
              * @param seed the seed
              * @return the seed array
              */
             private long[] createMswsSeed(long seed) {
-                final long increment = SeedUtils.createLongHexPermutation(new SplitMix64(seed));
+                return createMswsSeed(new SplitMix64(seed));
+            }
+
+            /**
+             * Creates the full length seed array from the input seed using the method
+             * recommended for the generator. This is a high quality Weyl increment composed
+             * of a hex character permutation.
+             *
+             * @param source Source of randomness.
+             * @return the seed array
+             */
+            private long[] createMswsSeed(UniformRandomProvider source) {
+                final long increment = SeedUtils.createLongHexPermutation(source);
                 // The initial state should not be low complexity but the Weyl
                 // state can be any number.
                 final long state = increment;
-                final long weylState = seed;
+                final long weylState = source.nextLong();
                 return new long[] {state, weylState, increment};
             }
         },
@@ -383,6 +398,16 @@
         }
 
         /**
+         * Gets the number of seed bytes required to seed the implementing class represented by
+         * this random source.
+         *
+         * @return the number of seed bytes
+         */
+        private int getSeedByteSize() {
+            return nativeSeedSize * nativeSeedType.getBytes();
+        }
+
+        /**
          * Creates a RNG instance.
          *
          * <p>This method can be over-ridden to allow fast construction of a generator
@@ -442,8 +467,10 @@
         /**
          * Creates a native seed.
          *
-         * <p>This method should be over-ridden to satisfy seed requirements for the generator,
-         * for example if a seed must contain non-zero bits.</p>
+         * <p>The default implementation creates a seed of the native type and, for array seeds,
+         * ensures not all bits are zero.</p>
+         *
+         * <p>This method should be over-ridden to satisfy seed requirements for the generator.</p>
          *
          * @return the native seed
          */
@@ -452,6 +479,21 @@
         }
 
         /**
+         * Creates a {@code byte[]} seed using the provided source of randomness.
+         *
+         * <p>The default implementation creates a full-length seed and ensures not all bits
+         * are zero.</p>
+         *
+         * <p>This method should be over-ridden to satisfy seed requirements for the generator.</p>
+         *
+         * @param source Source of randomness.
+         * @return the byte[] seed
+         */
+        protected byte[] createByteArraySeed(UniformRandomProvider source) {
+            return SeedFactory.createByteArray(source, getSeedByteSize());
+        }
+
+        /**
          * Converts a seed from any of the supported seed types to a native seed.
          *
          * @param seed Input seed (must not be null).
@@ -476,6 +518,39 @@
         }
 
         /**
+         * Creates a seed suitable for the implementing class represented by this random source.
+         *
+         * <p>It will satisfy the seed size and any other seed requirements for the
+         * implementing class. The seed is converted from the native type to bytes.</p>
+         *
+         * @return the seed bytes
+         *
+         * @since 1.3
+         */
+        public final byte[] createSeedBytes() {
+            // Custom implementations can override createSeed
+            final Object seed = createSeed();
+            return NativeSeedType.convertSeedToBytes(seed);
+        }
+
+        /**
+         * Creates a seed suitable for the implementing class represented by this random source
+         * using the supplied source of randomness.
+         *
+         * <p>It will satisfy the seed size and any other seed requirements for the
+         * implementing class. The seed is converted from the native type to bytes.</p>
+         *
+         * @param source Source of randomness.
+         * @return the seed bytes
+         *
+         * @since 1.3
+         */
+        public final byte[] createSeedBytes(UniformRandomProvider source) {
+            // Custom implementations can override createByteArraySeed
+            return createByteArraySeed(source);
+        }
+
+        /**
          * Gets the constructor.
          *
          * @return the RNG constructor.
@@ -492,6 +567,7 @@
             }
             return constructor;
         }
+
         /**
          * Creates a constructor.
          *
diff --git a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/SeedFactory.java b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/SeedFactory.java
index 170c978..4b336ea 100644
--- a/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/SeedFactory.java
+++ b/commons-rng-simple/src/main/java/org/apache/commons/rng/simple/internal/SeedFactory.java
@@ -203,6 +203,25 @@
     }
 
     /**
+     * Creates an array of {@code byte} numbers for use as a seed using the supplied source of
+     * randomness. The result will not be all zeros.
+     *
+     * @param source Source of randomness.
+     * @param n Size of the array to create.
+     * @return an array of {@code n} random numbers.
+     */
+    static byte[] createByteArray(UniformRandomProvider source,
+                                  int n) {
+        final byte[] seed = new byte[n];
+        source.nextBytes(seed);
+        // If the seed is zero it is assumed the input source RNG is either broken
+        // or the seed is small and it was zero by chance. Revert to the built-in
+        // source of randomness to ensure it is non-zero.
+        ensureNonZero(seed);
+        return seed;
+    }
+
+    /**
      * Ensure the seed is non-zero at the first position in the array.
      *
      * <p>This method will replace a zero at index 0 in the array with
@@ -243,6 +262,42 @@
     }
 
     /**
+     * Ensure the seed is not zero at all positions in the array.
+     *
+     * <p>This method will check all positions in the array and if all
+     * are zero it will replace index 0 in the array with
+     * a non-zero random number. The method ensures any length seed
+     * contains non-zero bits. The output seed is suitable for generators
+     * that cannot be seeded with all zeros.</p>
+     *
+     * @param seed Seed array (modified in place).
+     * @see #createInt()
+     */
+    private static void ensureNonZero(byte[] seed) {
+        // Since zero occurs 1 in 2^8 for a single byte this checks the entire array for zeros.
+        if (seed.length != 0 && isAllZero(seed)) {
+            do {
+                seed[0] = (byte) createInt();
+            } while (seed[0] == 0);
+        }
+    }
+
+    /**
+     * Test if each position in the array is zero.
+     *
+     * @param array Array data.
+     * @return true if all position are zero
+     */
+    private static boolean isAllZero(byte[] array) {
+        for (final byte value : array) {
+            if (value != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
      * Ensure the value is non-zero.
      *
      * <p>This method will replace a zero with a non-zero random number from the random source.</p>
diff --git a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/ProvidersCommonParametricTest.java b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/ProvidersCommonParametricTest.java
index 4641937..aa403da 100644
--- a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/ProvidersCommonParametricTest.java
+++ b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/ProvidersCommonParametricTest.java
@@ -39,6 +39,7 @@
 import org.apache.commons.rng.RandomProviderState;
 import org.apache.commons.rng.RestorableUniformRandomProvider;
 import org.apache.commons.rng.core.RandomProviderDefaultState;
+import org.apache.commons.rng.core.source64.SplitMix64;
 
 /**
  * Tests which all generators must pass.
@@ -155,6 +156,20 @@
         checkNextIntegerInRange(rng, 10, 10000);
     }
 
+    @Test
+    public void testRandomSourceCreateSeed() {
+        final byte[] seed = originalSource.createSeed();
+        final UniformRandomProvider rng = RandomSource.create(originalSource, seed, originalArgs);
+        checkNextIntegerInRange(rng, 10, 10000);
+    }
+
+    @Test
+    public void testRandomSourceCreateSeedFromRNG() {
+        final byte[] seed = originalSource.createSeed(new SplitMix64(RandomSource.createLong()));
+        final UniformRandomProvider rng = RandomSource.create(originalSource, seed, originalArgs);
+        checkNextIntegerInRange(rng, 10, 10000);
+    }
+
     // State save and restore tests.
 
     @Test
diff --git a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeParametricTest.java b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeParametricTest.java
index 9a2ebf3..3913341 100644
--- a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeParametricTest.java
+++ b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeParametricTest.java
@@ -112,6 +112,28 @@
     }
 
     /**
+     * Test the seed can be created, converted to a byte[] and then back to the native type.
+     */
+    @Test
+    public void testConvertSeedToBytes() {
+        final int size = 3;
+        final Object seed = nativeSeedType.createSeed(size);
+        Assert.assertNotNull("Null seed", seed);
+
+        final byte[] bytes = NativeSeedType.convertSeedToBytes(seed);
+        Assert.assertNotNull("Null byte[] seed", bytes);
+
+        final Object seed2 = nativeSeedType.convertSeed(bytes, size);
+        if (type.isArray()) {
+            // This handles nested primitive arrays
+            Assert.assertArrayEquals("byte[] seed was not converted back",
+                                     new Object[] {seed}, new Object[] {seed2});
+        } else {
+            Assert.assertEquals("byte[] seed was not converted back", seed, seed2);
+        }
+    }
+
+    /**
      * Test the seed can be converted to the correct type from any of the supported input types.
      */
     @Test
diff --git a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeTest.java b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeTest.java
new file mode 100644
index 0000000..be699ae
--- /dev/null
+++ b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/NativeSeedTypeTest.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.rng.simple.internal;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests for the {@link NativeSeedType} factory seed conversions.
+ */
+public class NativeSeedTypeTest {
+    /**
+     * Test the conversion throws for an unsupported type. All supported types are
+     * tested in the {@link NativeSeedTypeParametricTest}.
+     */
+    @Test(expected = UnsupportedOperationException.class)
+    public void testConvertSeedToBytesUsingNullThrows() {
+        NativeSeedType.convertSeedToBytes(null);
+    }
+
+    /**
+     * Test the conversion passes through a byte[]. This hits the edge case of a seed
+     * that can be converted that is not a native type.
+     */
+    @Test
+    public void testConvertSeedToBytesUsingByteArray() {
+        final byte[] seed = {42, 78, 99};
+        Assert.assertSame(seed, NativeSeedType.convertSeedToBytes(seed));
+    }
+}
diff --git a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/RandomSourceInternalParametricTest.java b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/RandomSourceInternalParametricTest.java
index 69736f2..e58f4ff 100644
--- a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/RandomSourceInternalParametricTest.java
+++ b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/RandomSourceInternalParametricTest.java
@@ -16,6 +16,7 @@
  */
 package org.apache.commons.rng.simple.internal;
 
+import org.apache.commons.rng.core.source64.SplitMix64;
 import org.apache.commons.rng.simple.internal.ProviderBuilder.RandomSourceInternal;
 import org.junit.Assert;
 import org.junit.Test;
@@ -23,6 +24,8 @@
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
+import java.util.EnumMap;
+
 /**
  * Tests for the {@link ProviderBuilder.RandomSourceInternal} seed conversions. This test
  * ensures that all random sources can create a seed or convert any supported seed to the
@@ -43,6 +46,53 @@
         null,
         Double.valueOf(Math.PI),
     };
+    /** The expected byte size of the seed for each RandomSource. */
+    private static final EnumMap<RandomSourceInternal, Integer> EXPECTED_SEED_BYTES =
+            new EnumMap<RandomSourceInternal, Integer>(RandomSourceInternal.class);
+
+    static {
+        final int intBytes = 4;
+        final int longBytes = 8;
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.JDK, longBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_512_A, intBytes * 16);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_1024_A, intBytes * 32);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_19937_A, intBytes * 624);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_19937_C, intBytes * 624);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_44497_A, intBytes * 1391);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.WELL_44497_B, intBytes * 1391);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.MT, intBytes * 624);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.ISAAC, intBytes * 256);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.SPLIT_MIX_64, longBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XOR_SHIFT_1024_S, longBytes * 16);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.TWO_CMRES, intBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.TWO_CMRES_SELECT, intBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.MT_64, longBytes * 312);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.MWC_256, intBytes * 257);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.KISS, intBytes * 4);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XOR_SHIFT_1024_S_PHI, longBytes * 16);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_RO_SHI_RO_64_S, intBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_RO_SHI_RO_64_SS, intBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_128_PLUS, intBytes * 4);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_128_SS, intBytes * 4);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_RO_SHI_RO_128_PLUS, longBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_RO_SHI_RO_128_SS, longBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_256_PLUS, longBytes * 4);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_256_SS, longBytes * 4);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_512_PLUS, longBytes * 8);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.XO_SHI_RO_512_SS, longBytes * 8);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.PCG_XSH_RR_32, longBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.PCG_XSH_RS_32, longBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.PCG_RXS_M_XS_64, longBytes * 2);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.PCG_MCG_XSH_RR_32, longBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.PCG_MCG_XSH_RS_32, longBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.MSWS, longBytes * 3);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.SFC_32, intBytes * 3);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.SFC_64, longBytes * 3);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.JSF_32, intBytes * 1);
+        EXPECTED_SEED_BYTES.put(RandomSourceInternal.JSF_64, longBytes * 1);
+        // ... add more here.
+        // Verify the seed byte size is reflected in the enum javadoc for RandomSource.
+    }
 
     /** Internal identifier for the random source. */
     private final RandomSourceInternal randomSourceInternal;
@@ -109,4 +159,49 @@
             }
         }
     }
+
+    /**
+     * Test the seed byte size is reported as the size of a int/long primitive for Int/Long
+     * seed types and a multiple of it for int[]/long[] types.
+     */
+    @Test
+    public void testCreateSeedBytesSizeIsPositiveAndMultipleOf4Or8() {
+        // This should be the full length seed
+        final byte[] seed = randomSourceInternal.createSeedBytes(new SplitMix64(12345L));
+
+        final int size = seed.length;
+        Assert.assertNotEquals("Seed is empty", 0, size);
+
+        if (randomSourceInternal.isNativeSeed(Integer.valueOf(0))) {
+            Assert.assertEquals("Expect 4 bytes for Integer", 4, size);
+        } else if (randomSourceInternal.isNativeSeed(Long.valueOf(0))) {
+            Assert.assertEquals("Expect 8 bytes for Long", 8, size);
+        } else if (randomSourceInternal.isNativeSeed(new int[0])) {
+            Assert.assertEquals("Expect 4n bytes for int[]", 0, size % 4);
+        } else if (randomSourceInternal.isNativeSeed(new long[0])) {
+            Assert.assertEquals("Expect 8n bytes for long[]", 0, size % 8);
+        } else {
+            Assert.fail("Unknown native seed type");
+        }
+    }
+
+    /**
+     * Test the seed byte size against the expected value.
+     *
+     * <p>The expected values are maintained in a table and must be manually updated
+     * for new generators. This test forms an additional cross-reference check that the
+     * seed size in RandomSourceInternal has been correctly set and the size should map to
+     * the array size in the RandomSource javadoc (if applicable).
+     */
+    @Test
+    public void testCreateSeedBytes() {
+        // This should be the full length seed
+        final byte[] seed = randomSourceInternal.createSeedBytes(new SplitMix64(12345L));
+        final int size = seed.length;
+
+        final Integer expected = EXPECTED_SEED_BYTES.get(randomSourceInternal);
+        Assert.assertNotNull("Missing expected seed byte size: " + randomSourceInternal, expected);
+        Assert.assertEquals(randomSourceInternal.toString(),
+                            expected.intValue(), size);
+    }
 }
diff --git a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/SeedFactoryTest.java b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/SeedFactoryTest.java
index 842bdaa..b936d81 100644
--- a/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/SeedFactoryTest.java
+++ b/commons-rng-simple/src/test/java/org/apache/commons/rng/simple/internal/SeedFactoryTest.java
@@ -20,6 +20,8 @@
 import java.util.HashMap;
 import org.junit.Assert;
 import org.junit.Test;
+import org.apache.commons.rng.UniformRandomProvider;
+import org.apache.commons.rng.core.source32.IntProvider;
 import org.apache.commons.rng.core.source64.RandomLongSource;
 import org.apache.commons.rng.core.util.NumberFactory;
 
@@ -206,6 +208,63 @@
     }
 
     @Test
+    public void testCreateByteArrayWithSizeZero() {
+        assertCreateByteArray(new byte[0]);
+    }
+
+    @Test
+    public void testCreateByteArrayIgnoresNonZeroPositions() {
+        final byte position = 123;
+        int n = 3;
+        for (int i = 0; i < n; i++) {
+            final byte[] expected = new byte[n];
+            expected[i] = position;
+            assertCreateByteArray(expected);
+        }
+    }
+
+    /**
+     * Assert that the SeedFactory uses the bytes exactly as generated by the
+     * {@link UniformRandomProvider#nextBytes(byte[])} method (assuming they are not all zero).
+     *
+     * @param expected the expected
+     */
+    private static void assertCreateByteArray(final byte[] expected) {
+        final UniformRandomProvider rng = new IntProvider() {
+            @Override
+            public int next() {
+                Assert.fail("This method should not be used");
+                return 0;
+            }
+
+            @Override
+            public void nextBytes(byte[] bytes) {
+                System.arraycopy(expected, 0, bytes, 0, Math.min(expected.length, bytes.length));
+            }
+        };
+
+        final byte[] seed = SeedFactory.createByteArray(rng, expected.length);
+        Assert.assertArrayEquals(expected, seed);
+    }
+
+    @Test
+    public void testCreateByteArrayWithAllZeroBytesUpdatesPosition0() {
+        final UniformRandomProvider rng = new IntProvider() {
+            @Override
+            public int next() {
+                // Deliberately produce zero
+                return 0;
+            }
+        };
+        // Test the method only replaces position 0
+        final byte[] seed = SeedFactory.createByteArray(rng, 4);
+        Assert.assertNotEquals("Zero at position 0 should be modified", 0, seed[0]);
+        for (int i = 1; i < seed.length; i++) {
+            Assert.assertEquals("Position above 0 should be unmodified", 0, seed[i]);
+        }
+    }
+
+    @Test
     public void testEnsureNonZeroIntArrayIgnoresEmptySeed() {
         final int[] seed = new int[0];
         SeedFactory.ensureNonZero(seed);