Jenetics is a Genetic Algorithm, Evolutionary Algorithm, Grammatical Evolution, Genetic Programming, and Multi-objective Optimization library, written in modern day Java. It is designed with a clear separation of the several concepts of the algorithm, e.g. Gene, Chromosome, Genotype, Phenotype, Population and fitness Function. Jenetics allows you to minimize and maximize the given fitness function without tweaking it. In contrast to other GA implementations, the library uses the concept of an evolution stream (EvolutionStream) for executing the evolution steps. Since the EvolutionStream implements the Java Stream interface, it works smoothly with the rest of the Java Stream API.

Other languages

• Jenetics.Net: Experimental .NET Core port in C# of the base library.
• Helisa: Scala wrapper around the Jenetics library.

The library is fully documented (javadoc) and comes with a user manual (pdf).

Jenetics requires at least Java 21 to compile and run.

Check out the master branch from GitHub.

$ git clone https://github.com/jenetics/jenetics.git <builddir>

Jenetics uses Gradle as a build system and organizes the source into sub-projects (modules). Each subproject is located in its own subdirectory:

Published projects

The following projects/modules are also published to Maven.

• jenetics : This project contains the source code and tests for the Jenetics core-module.
• jenetics.ext : This module contains additional non-standard GA operations and data types. It also contains classes for solving multi-objective problems (MOEA) and doing Grammatical Evolution (GE).
• jenetics.prog : The modules contain classes that allow to do genetic programming (GP). It seamlessly works with the existing EvolutionStream and evolution Engine.
• jenetics.xml : XML marshalling module for the Jenetics base data structures.

Non-published projects

• jenetics.example: This project contains example code for the core-module.
• jenetics.doc: Contains the code of the website and the manual.
• jenetics.tool: This module contains classes used for doing integration testing and algorithmic performance testing. It is also used for creating GA performance measures and creating diagrams from the performance measures.

For building the library change into the <builddir> directory (or one of the module directories) and call one of the available tasks:

• compileJava: Compiles the Jenetics sources and copies the class files to the <builddir>/<module-dir>/build/classes/main directory.
• jar: Compiles the sources and creates the JAR files. The artifacts are copied to the <builddir>/<module-dir>/build/libs directory.
• javadoc: Generates the API documentation. The Javadoc is stored in the <builddir>/<module-dir>/build/docs directory
• test: Compiles and executes the unit tests. The test results are printed onto the console, and a test-report, created by TestNG, is written to <builddir>/<module-dir> directory.
• clean: Deletes the <builddir>/build/* directories and removes all generated artifacts.

For building the library jar from the source call

$ cd <build-dir>
$ ./gradlew jar

The minimum evolution Engine setup needs a genotype factory, Factory<Genotype<?>>, and a fitness Function. The Genotype implements the Factory interface and can therefore be used as prototype for creating the initial Population and for creating new random Genotypes.

import io.jenetics.BitChromosome;
import io.jenetics.BitGene;
import io.jenetics.Genotype;
import io.jenetics.engine.Engine;
import io.jenetics.engine.EvolutionResult;
import io.jenetics.util.Factory;

public class HelloWorld {
    // 2.) Definition of the fitness function.
    private static Integer eval(Genotype<BitGene> gt) {
        return gt.chromosome()
            .as(BitChromosome.class)
            .bitCount();
    }

    public static void main(String[] args) {
        // 1.) Define the genotype (factory) suitable
        //     for the problem.
        Factory<Genotype<BitGene>> gtf =
            Genotype.of(BitChromosome.of(10, 0.5));

        // 3.) Create the execution environment.
        Engine<BitGene, Integer> engine = Engine
            .builder(HelloWorld::eval, gtf)
            .build();

        // 4.) Start the execution (evolution) and
        //     collect the result.
        Genotype<BitGene> result = engine.stream()
            .limit(100)
            .collect(EvolutionResult.toBestGenotype());

        System.out.println("Hello World:\n" + result);
    }
}

In contrast to other GA implementations, the library uses the concept of an evolution stream (EvolutionStream) for executing the evolution steps. Since the EvolutionStream implements the Java Stream interface, it works smoothly with the rest of the Java streaming API. Now let's have a closer look at the listing above and discuss this simple program step by step:

1. The probably most challenging part, when setting up a new evolution Engine, is to transform the problem domain into a appropriate Genotype (factory) representation. In our example we want to count the number of ones of a BitChromosome. Since we are counting only the ones of one chromosome, we are adding only one BitChromosome to our Genotype. In general, the Genotype can be created with 1 to n chromosomes.

2. Once this is done, the fitness function, which should be maximized, can be defined. Utilizing the new language features introduced in Java 8, we simply write a private static method, which takes the genotype we defined and calculates its fitness value. If we want to use the optimized bit-counting method, bitCount(), we have to cast the Chromosome<BitGene> class to the actual used BitChromosome class. Since we know for sure that we created the Genotype with a BitChromosome, this can be done safely. A reference to the eval method is then used as fitness function and passed to the Engine.build method.

3. In the third step we are creating the evolution Engine, which is responsible for changing, respectively evolving, a given population. The Engine is highly configurable and takes parameters for controlling the evolutionary and the computational environment. For changing the evolutionary behavior, you can set different alterers and selectors. By changing the used Executor service, you control the number of threads; the Engine is allowed to use. A new Engine instance can only be created via its builder, which is created by calling the Engine.builder method.

4. In the last step, we can create a new EvolutionStream from our Engine. The EvolutionStream is the model or view of the evolutionary process. It serves as a »process handle« and also allows you, among other things, to control the termination of the evolution. In our example, we simply truncate the stream after 100 generations. If you don't limit the stream, the EvolutionStream will not terminate and run forever. Since the EvolutionStream extends the java.util.stream.Stream interface, it integrates smoothly with the rest of the Java Stream API. The final result, the best Genotype in our example, is then collected with one of the predefined collectors of the EvolutionResult class.

This example tries to approximate a given image by semitransparent polygons. It comes with a Swing UI, where you can immediately start your own experiments. After compiling the sources with

$ ./gradlew compileTestJava

you can start the example by calling

$ ./jrun io.jenetics.example.image.EvolvingImages

The previous image shows the GUI after evolving the default image for about 4,000 generations. With the »Open« button, it is possible to load other images for polygonization. The »Save« button allows storing polygonized images in PNG format to disk. At the button of the UI, you can change some GA parameters of the example.

• SPEAR: SPEAR (Smart Prognosis of Energy with Allocation of Resources) created an extendable platform for energy and efficiency optimizations of production systems.
• Renaissance Suite: Renaissance is a modern, open, and diversified benchmark suite for the JVM, aimed at testing JIT compilers, garbage collectors, profilers, analyzers and other tools.
• APP4MC: Eclipse APP4MC is a platform for engineering embedded multi- and many-core software systems.

• Schachprobleme komponieren mit evolutionären Algorithmen, by Jakob Leck, Dec 2023, Die Schwalbe 324-2, pp. 373-380. Composition and solving chess problems with a greater number of peaces than usual. Instead of a brute force approach, a GA is used solving the problems (German).
• Solving the Knapsack Problem with the Jenetics Library, by Craftcode Crew, May 13, 2021
• 一种基于Jenetics的遗传算法程序设计, 电脑知识与技术 2018年22期 by 王康, Nov. 26. 2018
• Introduction to Jenetics Library, by baeldung, April 11. 2017
• How to Solve Tough Problems Using Genetic Algorithms, by Tzofia Shiftan, April 6. 2017
• Genetic algorithms with Java, by William Antônio, January 10. 2017
• Jenetics 설치 및 예제, by JDM, May 8. 2015
• 유전 알고리즘 (Genetic Algorithms), by JDM, April 2. 2015

• #822: Improve the build script for generating combined Javadoc.
• #898: Add support for reading data from CSV files or strings. This simplifies the code for regression problems.

static List<Sample<Double>> parseDoubles(final CharSequence csv) {
	return CsvSupport.parseDoubles(csv).stream()
		.map(Sample::ofDouble)
		.toList();
}

• #904: Upgrade to Gradle 8.10 and cleanup of build scripts.
• #907: Add a chapter in the user's manual for optimization strategies: Practical Jenetics.
• #909: Helper methods for converting primitive arrays.

final Codec<int[], DoubleGene> codec = Codecs
    .ofVector(DoubleRange.of(0, 100), 100)
    .map(Conversions::doubleToIntArray);

• #419: Fix flaky statistical tests.

• Java 21 is used for building and using the library.
• #878: Allow Virtual-Threads evaluating the fitness function. Must be enabled when creating an Engine (see code snippet below), the previous behavior has been preserved.

final Engine<DoubleGene, Double> engine = Engine.builder(ff)
	.fitnessExecutor(BatchExecutor.ofVirtualThreads())
	.build();

• #880: Replace code examples in Javadoc with JEP 413.
• #886: Improve CharStore sort.
• #894: New genetic operators: ShiftMutator, ShuffleMutator and UniformOrderBasedCrossover.
• #895: Improve default RandomGenerator selection. The used RandomGenerator is selected in the following order:
  1. Check if the io.jenetics.util.defaultRandomGenerator start parameter is set. If so, take this generator.
  2. Check if the L64X256MixRandom generator is available. If so, take this generator.
  3. Find the best available random generator according to the RandomGeneratorFactory.stateBits() value.
  4. Use the Random generator if no best generator can be found. This generator is guaranteed to be available on every platform.

All Release Notes

The library is licensed under the Apache License, Version 2.0.

Copyright 2007-2024 Franz Wilhelmstötter

Licensed 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

https://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.