The Infrastructure for
Evolutionary AI Systems

Enabling intelligence to adapt, create, and evolve
across digital and physical worlds.

Website · Documentation · Releases · 简体中文

EvoX provides the computing and experimentation foundation for AI that evolves. Generate candidates, execute tasks, evaluate results, and build on what works. Across models, software, control policies, and scientific design, this process turns experimental feedback into continued improvement.

Tensorization and parallel computing scale up exploration. The PyTorch main version in this repository organizes candidates and their evaluation as batched tensor computation on CPUs and GPUs. Composable algorithms, problems, and workflows connect search, execution, and feedback.

View the static diagram

Choose your version

	EvoX 1.x · Main version	EvoX 2.0 alpha · Experimental
Branch	main	evoxc-exp
Foundation	PyTorch	EvoX Compiler (evoxc)
Python import	import evox	import evox_etl
Python version	3.10+	3.11+
Start here for	Applications, experiments, and PyTorch integration	Exploring the new functional API and compiler backends

New to EvoX? Get started with 1.x. The experimental version is a functional rewrite on EvoX Compiler, with a NumPy interpreter and optional IREE, XLA, and TVM backends. Both versions use the evox package name, so try the alpha in a separate environment using its own installation guide.

The earlier JAX implementation is available at v0.9.0.

Part of the EvoX ecosystem

Across digital and physical worlds, the EvoX ecosystem applies evolution to model merging, software development, robot control, and scientific design.

Generative AI	Agentic AI
Evolve the models. EvoGM · Evolutionary model merging	Evolve the software. EvoX Genesis · Recursive agentic system

Physical AI	AI for Science
Evolve the behavior. EvoRL · Evolutionary reinforcement learning	Evolve the design. EvoGO · Generative optimization

Explore the full ecosystem, or follow the experimental compiler work in EvoX Compiler.

Get started

Install PyTorch for your hardware, then install EvoX 1.x with visualization support:

python -m pip install "evox[default]>=1.4,<2"

Run your first search

Optimize the 10-dimensional Ackley function with particle swarm optimization:

import torch
from evox.algorithms import PSO
from evox.problems.numerical import Ackley
from evox.workflows import EvalMonitor, StdWorkflow

torch.set_default_device("cuda" if torch.cuda.is_available() else "cpu")
torch.manual_seed(42)

algorithm = PSO(
    pop_size=100,
    lb=-32 * torch.ones(10),
    ub=32 * torch.ones(10),
)
monitor = EvalMonitor()
workflow = StdWorkflow(algorithm, Ackley(), monitor)

workflow.init_step()
for _ in range(100):
    workflow.step()

print("Best fitness:", monitor.get_best_fitness().item())
# monitor.plot().show()  # Optional: inspect the convergence curve.

Algorithm generates and updates candidates. Problem evaluates a batch. Workflow connects them. Monitor records the results.

Use your own objective

Implement a batched evaluation function. For a single objective, map a tensor of shape (population_size, dimensions) to one fitness value per candidate:

from evox.core import Problem

class Sphere(Problem):
    def evaluate(self, candidates: torch.Tensor) -> torch.Tensor:
        return candidates.square().sum(dim=-1)

Pass Sphere() in place of Ackley() when constructing the workflow. EvoX minimizes by default; use opt_direction="max" in StdWorkflow for maximization.

Optimize multiple objectives

The same workflow supports multi-objective search. This example uses RVEA on DTLZ2:

import torch
from evox.algorithms import RVEA
from evox.problems.numerical import DTLZ2
from evox.workflows import EvalMonitor, StdWorkflow

torch.manual_seed(42)
algorithm = RVEA(
    pop_size=100,
    n_objs=2,
    lb=torch.zeros(12),
    ub=torch.ones(12),
)
monitor = EvalMonitor(multi_obj=True)
workflow = StdWorkflow(algorithm, DTLZ2(m=2), monitor)

workflow.init_step()
for _ in range(100):
    workflow.step()

print("Pareto-front fitness shape:", monitor.get_pf_fitness().shape)
# monitor.plot().show()

Continue with the tutorials, neuroevolution examples, or hyperparameter optimization.

Libraries, benchmarks, and tooling

Algorithm libraries propose candidates. Benchmarks and simulation environments provide evaluation feedback. Workflows organize iteration, while tensorization and compiler tools support execution at scale. Together, these components provide infrastructure for exploration and validation:

Layer	Libraries and resources	What they provide
Algorithm libraries	EvoX · EvoMO · EvoGP · TensorNEAT	Tensorized optimization, multi-objective search, genetic programming, and neural topology evolution.
Benchmarks	EvoXBench · MoRobtrol in EvoMO · EvoX problem library	Neural architecture search, multi-objective robot control, and numerical optimization test suites.
Learning and simulation	EvoRL · EvoX neuroevolution	Evolutionary reinforcement learning, batched policy evaluation, and integration with environments such as Brax and MuJoCo Playground.
Experiment tools	Workflows and monitors · Metrics · Hyperparameter optimization	Compose experiments, track convergence and Pareto fronts, compare results, and tune configurations.
Compilation and migration	EvoX Compiler · EvoCoCo	Compiler backends for the experimental EvoX line; automatic tensorization of MATLAB multi-objective optimization code into PyTorch/EvoX implementations.

For neural and simulation integrations in EvoX 1.x:

python -m pip install "evox[default,neuroevolution]>=1.4,<2"

Execution and hardware

The PyTorch version runs on CPU, NVIDIA GPU (CUDA), AMD GPU (ROCm), and Apple Silicon (MPS, eager execution) through the corresponding PyTorch backend. See the hardware guide for setup.

For supported compilation environments, compile the repeated step before entering the search loop:

from evox import compile

workflow.step = compile(workflow.step)

Multi-GPU and distributed workflows are experimental and require a distributed launch and configuration. See benchmark scripts for reproducible performance experiments.

Community and contributing

• Questions and ideas: GitHub Discussions, Discord, or QQ group 297969717.
• Bugs and contributions: Open an issue or start with the developer guide.
• Research and collaboration: Ran Cheng.

Install the main version from source

git clone --branch main https://github.com/EMI-Group/evox.git
cd evox
python -m pip install -e ".[default]"

Citation

If EvoX supports your research, please cite the framework paper:

@article{evox,
  title = {{EvoX}: A Distributed GPU-accelerated Framework for Scalable Evolutionary Computation},
  author = {Huang, Beichen and Cheng, Ran and Li, Zhuozhao and Jin, Yaochu and Tan, Kay Chen},
  journal = {IEEE Transactions on Evolutionary Computation},
  year = {2024},
  doi = {10.1109/TEVC.2024.3388550}
}

License

EvoX is licensed under GPL-3.0-or-later. Related projects, including EvoX Compiler, carry their own licenses.