OpenEvolve

The most advanced open-source evolutionary coding agent

Turn your LLMs into autonomous code optimizers that discover breakthrough algorithms

Quick Start • Used In Research • Examples • Docs • Discussions

---

OpenEvolve is an open-source implementation of Google DeepMind's AlphaEvolve. It uses LLMs to mutate programs and evolves them with MAP-Elites and island populations, so you can point it at any problem you can score. It has become a standard tool and baseline for LLM-driven algorithm discovery: cited in hundreds of research papers, with 7,600+ GitHub stars, 1,200+ forks, 80+ contributors and 17,000+ monthly PyPI downloads.

Used In Research

Producing new results

Paper	How OpenEvolve is used
New Bounds for Zarankiewicz Numbers via Reinforced LLM Evolutionary Search	New bounds in extremal combinatorics, obtained with OpenEvolve
Let the Barbarians In: How AI Can Accelerate Systems Performance Research	Ten systems performance case studies, using OpenEvolve among other tools
Algorithmic Algorithm Development with LLMs	Contraction order optimization for tensor networks
Even with AI, Bijection Discovery is Still Hard	Combinatorial bijection discovery

Security research

Paper	How OpenEvolve is used
Trojan Hippo Bench	Adaptive red-teaming benchmark for persistent memory attacks on LLM agents
Divide and Inject	Refining indirect prompt injection fragments
LLM-Guided Prompt Evolution for Password Guessing	Evolving prompts that maximize cracking rate
Targeted Black-Box Attacks on Perceptual Hash Algorithms	Evolutionary attack framework based on GigaEvo and OpenEvolve

Building on OpenEvolve

Paper	Relationship
Hill Sampling for Test-Time Scaling	Builds on OpenEvolve's problems and evaluators
CodeEvolve: Runtime-Enriched Target Selection	Extends OpenEvolve for Java and Salesforce Apex
GraphIR	Neural architecture search states integrated into OpenEvolve
SwarmEvolve: Latent Agent Swarms for Evolutionary Discovery and Optimization · Code	Uses OpenEvolve's problems and evaluators for 16 AlphaEvolve problems, and benchmarks against OpenEvolve

New evolutionary agents also routinely benchmark against OpenEvolve, including HarnessTTT, FrugalEvo, SEDIMA, EvoDuet, LoongFlow and AscendOptimizer.

Using OpenEvolve in your work? Open a pull request to add it here, and see Citation.

Results

Domain	Achievement	Example
GPU optimization	Hardware-optimized kernel discovery, with 2-3x speedups on real hardware	MLX Metal Kernels
Mathematics	State-of-the-art circle packing (n=26)	Circle Packing
Algorithm design	Adaptive sorting algorithms	Rust Adaptive Sort
Scientific computing	Automated filter design	Signal Processing
Multi-language	Python, Rust, R, Metal shaders	All Examples

Generation 1	Generation 190	Generation 460 (final)
Random placement	Learning structure	State-of-the-art result

Compared with manual optimization:

Aspect	Manual Optimization	OpenEvolve
Time to solution	Days to weeks	Hours
Exploration breadth	Limited by human creativity	Unlimited LLM creativity
Reproducibility	Hard to replicate	Fully deterministic
Multi-objective	Complex tradeoffs	Automatic Pareto optimization
Scaling	Doesn't scale	Parallel evolution across islands

Quick Start

Requires Python 3.10+ and access to an LLM.

git clone https://github.com/algorithmicsuperintelligence/openevolve.git
cd openevolve
pip install -e .

# The example uses Google Gemini by default (free tier available)
# Get your API key from: https://aistudio.google.com/apikey
export OPENAI_API_KEY="your-gemini-api-key"  # Yes, use OPENAI_API_KEY

python openevolve-run.py examples/function_minimization/initial_program.py \
  examples/function_minimization/evaluator.py \
  --config examples/function_minimization/config.yaml \
  --iterations 50

To use another provider, change api_base and the model in config.yaml. See LLM Providers.

Or use it as a library (pip install openevolve):

from openevolve import evolve_function

def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(len(arr) - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

if __name__ == "__main__":
    result = evolve_function(
        bubble_sort,
        test_cases=[([3, 1, 2], [1, 2, 3]), ([5, 2, 8], [2, 5, 8])],
        iterations=50,
    )
    print(result.best_code)

This is the beginning of the README. Read the rest at the original. Read the full README ↗