evox

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. Across models, software, control policies, and scientific design, it connects population-based search with scalable evaluation.

How evolution works

Retain what works, then explore new variations. EvoX scales this loop through batched evaluation and parallel computing.

Open full animation · Static diagram

Scaling the search

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.

Open full animation · Static diagram

Choose your version

EvoX 1.x · Main version

• Branch: main
• Foundation: PyTorch
• Python import: import evox
• Python version: 3.10+
• Start here for: Applications, experiments, and PyTorch integration

EvoX 2.0 alpha · Experimental

• Branch: evoxc-exp
• Foundation: EvoX Compiler (evoxc)
• Python import: import evox_etl
• Python version: 3.11+
• Start here for: 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

The same loop takes different forms across the EvoX ecosystem: model weights, code, control policies, or geometry become the candidates. Each illustration below follows two generations, showing how retained traits and local changes shape the next round of search.

Generative AI

Evolve the models. Retain useful weights and explore small changes.

EvoGM · Evolutionary model merging

Open full animation · Static diagram

Agentic AI

Evolve the software. Compare code variants against shared tests.

EvoX Genesis · Recursive agentic system

Open full animation · Static diagram

Physical AI

Evolve the behavior. Inherit control policies and vary their parameters.

EvoRL · Evolutionary reinforcement learning

Open full animation · Static diagram

AI for Science

Evolve the design. Inherit geometry and evaluate shape changes.

EvoGO · Generative optimization

Open full animation · Static diagram

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.

from evox.core import Problem

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

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:

Algorithm libraries

Tensorized optimization, multi-objective search, genetic programming, and neural topology evolution.

EvoX · EvoMO · EvoGP · TensorNEAT

Benchmarks

Neural architecture search, multi-objective robot control, and numerical optimization test suites.

EvoXBench · MoRobtrol in EvoMO · EvoX problem library

Learning and simulation

Evolutionary reinforcement learning, batched policy evaluation, and integration with environments such as Brax and MuJoCo Playground.

EvoRL · EvoX neuroevolution

Experiment tools

Compose experiments, track convergence and Pareto fronts, compare results, and tune configurations.

Workflows and monitors · Metrics · Hyperparameter optimization

Compilation and migration

Compiler backends for the experimental EvoX line; automatic tensorization of MATLAB multi-objective optimization code into PyTorch/EvoX implementations.

EvoX Compiler · EvoCoCo

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.

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.