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

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.

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:

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. Related projects, including EvoX Compiler, carry their own licenses.