@@ -633,6 +633,7 @@ Let us look at some examples.
 PyGAD applies the same conversion rules to generated and supplied initial populations, mutation candidates, and custom operator outputs. `on_parents`, `on_crossover`, and `on_mutation` receive converted values; any replacements returned or made in place by these callbacks are converted again before use. These rules apply whether `allow_duplicate_genes` is `True` or `False`.
 
 - Integer conversion truncates the fractional part towards zero. For example, `1.9` becomes `1` and `-1.9` becomes `-1`. Additive mutation adds the random value before converting the result.
+- Random and adaptive mutation clip generated values to the limits of a NumPy integer gene type before casting. This applies to both additive and replacement mutation, including random candidates from `None` gene-space entries, constraint checks, and duplicate repair. For example, a `numpy.uint8` gene at `0` with an offset of `-1` stays at `0`, and a `numpy.int8` gene at `127` with an offset of `1` stays at `127`. Values within the type's limits keep the same conversion behavior. Python `int`, floating-point, and `object` genes keep their existing behavior.
 - Floating-point precision rounds before casting to the requested type. This avoids rounding in a narrow type such as `numpy.float16` before the final conversion.
 - Precision must be an integer or `None`. `None` keeps the value unrounded, `0` rounds to whole numbers, and a negative precision rounds to positions before the decimal point. For example, `[float, -1]` rounds to tens. Integer types may only be paired with `None`.
 - Rounding uses NumPy's nearest-even rule at halfway points: `0.5` rounds to `0.0` and `1.5` rounds to `2.0` with precision `0`.
 
@@ -381,6 +381,8 @@ A bool that controls how `random` and `adaptive` mutation change a gene when dra
 - `True`: replace the gene with the randomly generated value.
 - `False` (default): add the random value to the gene.
 
+For NumPy integer gene types, both modes clip the resulting value to the type's limits before casting. For example, a `numpy.uint8` gene at `0` stays at `0` when adding `-1`. See [Conversion and Rounding Rules](gene_values.md#conversion-and-rounding-rules).
+
 Supported in [PyGAD 2.2.2](https://pygad.readthedocs.io/en/latest/releases.html#pygad-2-2-2) and higher. See the [PyGAD 2.2.2](https://pygad.readthedocs.io/en/latest/releases.html#pygad-2-2-2) release notes for an example.
 
 </details>
 
@@ -6,7 +6,7 @@ Release notes are listed from newest to oldest. Unreleased contains changes plan
 
 ## Unreleased
 
-No changes yet.
+1. Random and adaptive mutation clip generated values to NumPy integer type limits before casting, fixing overflow errors and wraparound with types such as `numpy.uint8` and `numpy.int8`. The same rule covers additive and replacement mutation, `None` gene-space entries, constraint candidates, and duplicate repair. Python `int`, floating-point, and `object` genes retain their existing behavior. See [issue #379](https://github.com/ahmedfgad/GeneticAlgorithmPython/issues/379) and [Conversion and Rounding Rules](gene_values.md#conversion-and-rounding-rules). The `pygad.helper` submodule version is `1.4.5`.
 
 ## PyGAD 3.8.0
 
 
@@ -1,4 +1,4 @@
 from pygad.helper import unique
 from pygad.helper import misc
 
-__version__ = "1.4.4"
+__version__ = "1.4.5"
@@ -397,12 +397,13 @@ def mutation_change_gene_dtype_and_round(self,
         Apply a random mutation value to a gene and cast / round the
         result. If ``mutation_by_replacement`` is True, the random
         value replaces the gene; otherwise it is added to the
-        existing value.
+        existing value. NumPy integer results are clipped to the
+        destination type's limits before casting.
 
         Parameters
         ----------
-        random_value : numeric
-            The freshly drawn mutation value.
+        random_value : numeric or numpy.ndarray
+            The freshly drawn mutation value or array of candidates.
         gene_index : int
             Index of the gene being mutated.
         gene_value : numeric
@@ -414,8 +415,9 @@ def mutation_change_gene_dtype_and_round(self,
 
         Returns
         -------
-        gene_value_new : numeric
-            The mutated value after casting and rounding.
+        gene_value_new : numeric or numpy.ndarray
+            The mutated value or candidates after clipping NumPy
+            integer values, casting, and rounding.
         """
 
         if mutation_by_replacement:
@@ -431,6 +433,14 @@ def mutation_change_gene_dtype_and_round(self,
                 mutated_value = gene_value + random_value
             else:
                 mutated_value = gene_value + numpy.asarray(random_value, dtype=object)
+        gene_dtype = self.get_gene_dtype(gene_index)[0]
+        if gene_dtype is not int and numpy.issubdtype(numpy.dtype(gene_dtype), numpy.integer):
+            type_limits = numpy.iinfo(gene_dtype)
+            # Object storage and Python bounds keep 64-bit integers exact.
+            # Clip the final sum or replacement, so an unsigned gene can
+            # still use negative offsets without wrapping or overflowing.
+            mutated_value = numpy.clip(numpy.asarray(mutated_value, dtype=object),
+                                       int(type_limits.min), int(type_limits.max))
         return self.change_gene_dtype_and_round(gene_index, mutated_value)
 
     def validate_gene_constraint_callable_output(self,
 
@@ -0,0 +1,143 @@
+"""Random mutation respects NumPy integer limits before converting candidates."""
+
+import numpy
+import pytest
+
+import pygad
+
+
+def fitness_func(ga_instance, solution, solution_index):
+    return float(sum(int(value) for value in solution))
+
+
+def make_ga(**options):
+    parameters = dict(num_generations=2, num_parents_mating=2,
+                      fitness_func=fitness_func, sol_per_pop=4, num_genes=3,
+                      gene_type=numpy.uint8, init_range_low=0, init_range_high=3,
+                      random_seed=7, suppress_warnings=True)
+    parameters.update(options)
+    return pygad.GA(**parameters)
+
+
+integer_types = [numpy.int8, numpy.int16, numpy.int32, numpy.int64,
+                 numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]
+
+
+@pytest.mark.parametrize("gene_type", integer_types)
+@pytest.mark.parametrize("mutation_by_replacement", [False, True])
+def test_mutation_clamps_scalar_and_array_values_at_both_integer_limits(gene_type, mutation_by_replacement):
+    ga_instance = make_ga(gene_type=gene_type)
+    type_limits = numpy.iinfo(gene_type)
+    for boundary, offset in [(int(type_limits.min), -1), (int(type_limits.max), 1)]:
+        random_value = boundary + offset if mutation_by_replacement else offset
+        converted = ga_instance.mutation_change_gene_dtype_and_round(
+            random_value, 0, gene_type(boundary), mutation_by_replacement)
+        assert type(converted) is gene_type
+        assert int(converted) == boundary
+
+        random_values = numpy.array([[random_value, boundary if mutation_by_replacement else 0]], dtype=object)
+        original_values = random_values.copy()
+        converted = ga_instance.mutation_change_gene_dtype_and_round(
+            random_values, 0, gene_type(boundary), mutation_by_replacement)
+        assert converted.dtype == numpy.dtype(gene_type)
+        numpy.testing.assert_array_equal(converted, [[boundary, boundary]])
+        numpy.testing.assert_array_equal(random_values, original_values)
+
+
+@pytest.mark.parametrize("random_values", [numpy.array(-1), numpy.array([-1, 0], dtype=object),
+                                            numpy.empty((0, 2), dtype=object)])
+def test_unsigned_mutation_preserves_candidate_shape(random_values):
+    ga_instance = make_ga()
+    converted = ga_instance.mutation_change_gene_dtype_and_round(
+        random_values, 0, numpy.uint8(0), False)
+    assert numpy.shape(converted) == random_values.shape
+    numpy.testing.assert_array_equal(converted, numpy.zeros(random_values.shape, dtype=numpy.uint8))
+
+
+@pytest.mark.parametrize("gene_type", integer_types)
+def test_fractional_offsets_are_added_before_integer_truncation(gene_type):
+    ga_instance = make_ga(gene_type=gene_type)
+    converted = ga_instance.mutation_change_gene_dtype_and_round(
+        [-0.2, 0.2, 1.9], 0, gene_type(1), False)
+    numpy.testing.assert_array_equal(converted, [0, 1, 2])
+
+
+@pytest.mark.parametrize("gene_type", [int, float, object, numpy.float32])
+@pytest.mark.parametrize("mutation_by_replacement", [False, True])
+def test_other_gene_types_keep_values_outside_narrow_integer_limits(gene_type, mutation_by_replacement):
+    ga_instance = make_ga(gene_type=gene_type)
+    random_values = [-2**20, 2**20]
+    converted = ga_instance.mutation_change_gene_dtype_and_round(
+        random_values, 0, 0, mutation_by_replacement)
+    numpy.testing.assert_array_equal(converted, random_values)
+
+
+@pytest.mark.parametrize("gene_type", [int, object])
+def test_python_integer_mutation_keeps_unbounded_scalar_values(gene_type):
+    ga_instance = make_ga(gene_type=gene_type)
+    converted = ga_instance.mutation_change_gene_dtype_and_round(1, 0, 2**80, False)
+    assert converted == 2**80 + 1
+
+
+@pytest.mark.parametrize("random_seed", range(20))
+def test_reported_unsigned_population_runs_with_default_mutation(random_seed):
+    ga_instance = make_ga(num_generations=30, num_parents_mating=4,
+                          sol_per_pop=10, num_genes=6, random_seed=random_seed)
+    ga_instance.run()
+    assert ga_instance.generations_completed == 30
+    assert ga_instance.population.dtype == numpy.dtype(numpy.uint8)
+
+
+@pytest.mark.parametrize("mutation_type", ['random', 'adaptive'])
+@pytest.mark.parametrize("use_probability", [False, True])
+@pytest.mark.parametrize("gene_space", [None, [None, None, None], [[None, 1], [None, 1], [None, 1]]])
+@pytest.mark.parametrize("mutation_by_replacement", [False, True])
+def test_mutation_backends_share_integer_limits(mutation_type, use_probability, gene_space, mutation_by_replacement):
+    parameters = dict(mutation_type=mutation_type, gene_space=gene_space,
+                      mutation_by_replacement=mutation_by_replacement,
+                      gene_type=[numpy.uint8, numpy.int8, numpy.uint64],
+                      initial_population=[[0, 127, 2**64 - 1]] * 4,
+                      random_mutation_min_val=[-2, 1, 1],
+                      random_mutation_max_val=[-1, 2, 2],
+                      crossover_type=None, keep_elitism=0, keep_parents=0)
+    if use_probability:
+        parameters['mutation_probability'] = [1.0, 1.0] if mutation_type == 'adaptive' else 1.0
+    else:
+        parameters['mutation_num_genes'] = [3, 3] if mutation_type == 'adaptive' else 3
+    ga_instance = make_ga(**parameters)
+    ga_instance.run()
+    for solution in ga_instance.population:
+        for gene_index, gene_type in enumerate([numpy.uint8, numpy.int8, numpy.uint64]):
+            assert type(solution[gene_index]) is gene_type
+        assert int(solution[0]) in [0, 1]
+        if gene_space is None:
+            numpy.testing.assert_array_equal(solution, [0, 1, 1] if mutation_by_replacement else [0, 127, 2**64 - 1])
+
+
+def test_constraints_receive_clamped_mutation_candidates():
+    candidate_batches = []
+
+    def gene_constraint(solution, values):
+        candidate_batches.append(values.copy())
+        assert all(type(value) is numpy.uint8 and int(value) == 0 for value in values)
+        return values
+
+    ga_instance = make_ga(initial_population=[[0, 0, 0]] * 4,
+                          gene_constraint=[gene_constraint] * 3,
+                          random_mutation_min_val=-2, random_mutation_max_val=-1,
+                          mutation_num_genes=3, keep_elitism=0, keep_parents=0)
+    ga_instance.run()
+    assert candidate_batches
+    numpy.testing.assert_array_equal(ga_instance.population, 0)
+
+
+@pytest.mark.parametrize("mutation_by_replacement", [False, True])
+def test_duplicate_repair_uses_representable_mutation_candidates(mutation_by_replacement):
+    ga_instance = make_ga(allow_duplicate_genes=False)
+    solution, duplicate_indices, num_unsolved_duplicates = ga_instance.solve_duplicate_genes_randomly(
+        numpy.array([0, 0, 255], dtype=numpy.uint8), -2, 2,
+        mutation_by_replacement=mutation_by_replacement, gene_type=ga_instance.gene_type)
+    assert not duplicate_indices
+    assert num_unsolved_duplicates == 0
+    assert solution.dtype == numpy.dtype(numpy.uint8)
+    numpy.testing.assert_array_equal(numpy.sort(solution), [0, 1, 255])