# Multi-model ensemble configuration
llm:
  models:
    - provider: "gemini"
      model_name: "gemini-2.0-flash"
      temperature: 0.8
      max_tokens: 4096
      weight: 0.8           # 80% of mutations use this model (breadth)
      role: "explorer"

    - provider: "gemini"
      model_name: "gemini-2.5-pro"
      temperature: 0.5
      max_tokens: 8192
      weight: 0.2           # 20% of mutations use this model (depth)
      role: "refiner"

  # Alternative: Use OpenAI models
  # models:
  #   - provider: "openai"
  #     model_name: "gpt-4o-mini"
  #     weight: 0.85
  #   - provider: "openai"
  #     model_name: "gpt-4o"
  #     weight: 0.15

  # Cost control
  max_tokens_per_run: 10000000     # Total token budget
  max_cost_per_run: 50.0          # USD budget limit

class PromptSampler:
    def __init__(self, config, program_db):
        self.config = config
        self.program_db = program_db
        self.diff_ratio = config.get("diff_ratio", 0.5)

    def sample_prompt(self):
        """Assemble a prompt for the LLM mutation operator."""

        # 1. Select parent(s) from program database
        parents = self.program_db.select_parents(
            n=self.config.get("n_parents", 1),
            strategy=self.config.get("selection_strategy", "map_elites")
        )

        # 2. Choose mutation mode
        use_diff = random.random() < self.diff_ratio

        # 3. Build prompt
        prompt = self._build_prompt(parents, use_diff)

        # 4. Select model from ensemble
        model = self._select_model()

        return prompt, model, use_diff

    def _build_prompt(self, parents, use_diff):
        sections = []
        sections.append(self.config.get("system_prompt",
            "You are an expert algorithm designer..."))
        sections.append(f"## Problem:\n{self.config['problem_description']}")

        for i, parent in enumerate(parents):
            sections.append(
                f"## Parent Program {i+1} (score: {parent.fitness:.4f}):\n"
                f"```python\n{parent.code}\n```"
            )

        if use_diff:
            sections.append(
                "Provide your improvement as a unified diff.")
        else:
            sections.append(
                "Provide the complete improved program.")

        return "\n\n".join(sections)

# Clone the repository
git clone https://github.com/algorithmicsuperintelligence/openevolve.git
cd openevolve

# Install dependencies
pip install -e .

# Set API keys
export GEMINI_API_KEY="your-key-here"
# OR
export OPENAI_API_KEY="your-key-here"
# OR
export ANTHROPIC_API_KEY="your-key-here"

# Run an example
python -m openevolve.run --config examples/sorting/config.yaml

cost_control:
  # Hard budget limits
  max_total_cost_usd: 50.0
  max_tokens_input: 5000000
  max_tokens_output: 2000000

  # Evaluation limits
  max_eval_time_seconds: 60
  max_concurrent_evals: 4

  # Tracking
  log_token_usage: true
  log_cost_per_generation: true

openevolve/
__init__.py
run.py # Main entry point / CLI runner
controller.py # Orchestrates the evolutionary loop
prompt_sampler.py # Constructs prompts, selects parents
program_database.py # MAP-Elites program database
evaluator.py # Sandboxed code evaluation
llm_provider.py # Multi-provider LLM abstraction
diff_engine.py # Diff parsing and application
config.py # Configuration management
utils.py # Utility functions
examples/
sorting/ # Sorting algorithm evolution
config.yaml
evaluate.py
seed_program.py
symbolic_regression/ # Mathematical formula discovery
config.yaml
evaluate.py
seed_program.py
optimization/ # Function optimization
config.yaml
evaluate.py

+=====================================================================================+
|                          OpenEvolve System Architecture                              |
+=====================================================================================+
|                                                                                     |
|   +----------------------------------------------------------------------+          |
|   |                      CONTROLLER (controller.py)                      |          |
|   |  Orchestrates the evolutionary loop:                                 |          |
|   |  for generation in range(max_generations):                           |          |
|   |      prompt, model = prompt_sampler.sample()                         |          |
|   |      response = llm_provider.generate(prompt, model)                 |          |
|   |      candidate = diff_engine.apply(response, parent)                 |          |
|   |      score = evaluator.evaluate(candidate)                           |          |
|   |      program_database.insert(candidate, score)                       |          |
|   +----------------------------------------------------------------------+          |
|         |              |                |              |              |              |
|         v              v                v              v              v              |
|   +-----------+  +----------+  +---------------+  +---------+  +----------+         |
|   | PROMPT    |  | LLM      |  | DIFF ENGINE   |  | EVAL    |  | PROGRAM  |         |
|   | SAMPLER   |  | PROVIDER |  |               |  | UATOR   |  | DATABASE |         |
|   |           |  |          |  | - Parse diffs |  |         |  |          |         |
|   | - Select  |  | - Gemini |  | - Parse code  |  | - Sand- |  | - MAP-   |         |
|   |   parents |  | - OpenAI |  | - Apply patch |  |   boxed |  |   Elites |         |
|   | - Build   |  | - Claude |  | - Validate    |  |   exec  |  | - Islands|         |
|   |   prompt  |  | - Local  |  |               |  | - Score |  | - Elite  |         |
|   | - Choose  |  |          |  |               |  | - Cache |  |   archive|         |
|   |   model   |  |          |  |               |  |         |  |          |         |
|   +-----------+  +----------+  +---------------+  +---------+  +----------+         |
|                                                                                     |
|   +----------------------------------------------------------------------+          |
|   |                    CONFIGURATION (config.yaml)                        |          |
|   |  - LLM models, weights, temperatures                                 |          |
|   |  - Evolution: population size, generations, selection strategy        |          |
|   |  - Evaluation: timeout, sandbox settings                             |          |
|   |  - Cost control: budget limits, token tracking                       |          |
|   +----------------------------------------------------------------------+          |
|                                                                                     |
+=====================================================================================+

+------------------------+
                        |    config.yaml         |
                        |    seed_program.py     |
                        |    evaluate.py         |
                        +-----------+------------+
                                    |
                                    v
                        +------------------------+
                        |    Controller.run()    |
                        +-----------+------------+
                                    |
                   +----------------+----------------+
                   |                                 |
                   v                                 |
          +----------------+                         |
          | PromptSampler  |                         |
          | .sample()      |                         |
          +-------+--------+                         |
                  |                                  |
       +----------+-----------+                      |
       |                      |                      |
       v                      v                      |
+------------+        +-------------+                |
| Program    |        | Model       |                |
| Database   |        | Selection   |                |
| .select()  |        | (weighted)  |                |
+------+-----+        +------+------+                |
       |                      |                      |
       v                      v                      |
+-----------------------------------------+          |
|        LLM Provider.generate()          |          |
|        (Gemini / OpenAI / Claude /      |          |
|         Local via Ollama)               |          |
+-------------------+---------------------+          |
                    |                                |
                    v                                |
          +------------------+                       |
          | DiffEngine       |                       |
          | .parse_and_apply |                       |
          +--------+---------+                       |
                   |                                 |
                   v                                 |
          +------------------+                       |
          | Evaluator        |                       |
          | .evaluate()      |                       |
          | (sandboxed)      |                       |
          +--------+---------+                       |
                   |                                 |
                   v                                 |
          +------------------+                       |
          | ProgramDatabase  |<----------------------+
          | .insert()        |    (next generation)
          +------------------+

class Controller:
    def __init__(self, config):
        self.config = config
        self.prompt_sampler = PromptSampler(config)
        self.llm_provider = LLMProvider(config)
        self.diff_engine = DiffEngine()
        self.evaluator = Evaluator(config)
        self.program_db = ProgramDatabase(config)
        self.cost_tracker = CostTracker(config)

    def run(self, seed_program, evaluation_fn):
        """Run the full evolutionary loop."""
        # Initialize with seed program
        seed_score = self.evaluator.evaluate(seed_program, evaluation_fn)
        self.program_db.insert(seed_program, seed_score)

        for gen in range(self.config["max_generations"]):
            # Check budget
            if self.cost_tracker.budget_exceeded():
                break

            # Sample prompt and model
            prompt, model_name, is_diff = self.prompt_sampler.sample_prompt()

            # Generate mutation via LLM
            response = self.llm_provider.generate(
                prompt, model=model_name
            )
            self.cost_tracker.update(response.usage)

            # Apply mutation
            parent = self.prompt_sampler.last_selected_parent
            if is_diff:
                candidate = self.diff_engine.apply_diff(
                    parent.code, response.text)
            else:
                candidate = self.diff_engine.extract_code(response.text)

            if candidate is None:
                continue  # Failed to parse

            # Evaluate
            score = self.evaluator.evaluate(candidate, evaluation_fn)

            # Update database
            self.program_db.insert(candidate, score)

            # Log progress
            self._log_generation(gen, score, self.program_db.best_score())

        return self.program_db.get_best_program()

class ProgramDatabase:
    def __init__(self, config):
        self.config = config
        self.population_size = config.get("population_size", 100)
        self.selection_strategy = config.get("selection_strategy", "map_elites")

        # MAP-Elites grid
        self.n_descriptor_dims = config.get("n_descriptor_dims", 2)
        self.bins_per_dim = config.get("bins_per_dim", 10)
        self.grid = {}  # (bin_indices) -> Program

        # Island model
        self.n_islands = config.get("n_islands", 1)
        self.migration_interval = config.get("migration_interval", 50)
        self.islands = [{} for _ in range(self.n_islands)]

        # Elite archive
        self.elite_archive = []
        self.max_elite_size = config.get("max_elite_size", 20)

        # Generation counter
        self.generation = 0

    def insert(self, program, fitness, descriptors=None):
        """Insert a program into the database."""
        if descriptors is None:
            descriptors = self._auto_compute_descriptors(program)

        cell = self._discretize(descriptors)
        island_id = self.generation % self.n_islands

        # MAP-Elites insertion
        if cell not in self.islands[island_id] or \
           fitness > self.islands[island_id][cell].fitness:
            self.islands[island_id][cell] = Program(
                code=program, fitness=fitness,
                descriptors=descriptors, generation=self.generation
            )

        # Update elite archive
        self._update_elite(program, fitness)
        self.generation += 1

        # Periodic migration
        if self.generation % self.migration_interval == 0:
            self._migrate()

    def select_parents(self, n=1, strategy=None):
        """Select parent programs for mutation."""
        strategy = strategy or self.selection_strategy
        all_programs = self._get_all_programs()

        if strategy == "map_elites":
            # Uniform random from occupied cells
            return random.sample(all_programs, min(n, len(all_programs)))
        elif strategy == "tournament":
            return [self._tournament_select(all_programs) for _ in range(n)]
        elif strategy == "fitness_proportional":
            return self._fitness_proportional_select(all_programs, n)

    def _migrate(self):
        """Migrate top programs between islands."""
        for i in range(self.n_islands):
            source = self.islands[i]
            target = self.islands[(i + 1) % self.n_islands]
            # Get top-k from source
            top_k = sorted(source.values(), key=lambda p: p.fitness,
                          reverse=True)[:3]
            for prog in top_k:
                cell = self._discretize(prog.descriptors)
                if cell not in target or prog.fitness > target[cell].fitness:
                    target[cell] = prog

class LLMProvider:
    def __init__(self, config):
        self.models = []
        self.weights = []

        for model_config in config["llm"]["models"]:
            provider = model_config["provider"]
            if provider == "gemini":
                client = GeminiClient(model_config)
            elif provider == "openai":
                client = OpenAIClient(model_config)
            elif provider == "anthropic":
                client = AnthropicClient(model_config)
            elif provider == "openai_compatible":
                client = OpenAICompatibleClient(model_config)
            else:
                raise ValueError(f"Unknown provider: {provider}")

            self.models.append(client)
            self.weights.append(model_config.get("weight", 1.0))

        # Normalize weights
        total = sum(self.weights)
        self.weights = [w / total for w in self.weights]

    def generate(self, prompt, model=None):
        """Generate a response using the selected or randomly chosen model."""
        if model is None:
            # Weighted random selection
            model_idx = random.choices(
                range(len(self.models)), weights=self.weights, k=1
            )[0]
        else:
            model_idx = self._find_model_by_name(model)

        return self.models[model_idx].generate(prompt)

import subprocess
import tempfile
import os

class Evaluator:
    def __init__(self, config):
        self.timeout = config.get("eval_timeout", 60)
        self.cache = {}  # hash(code) -> score

    def evaluate(self, code, evaluation_fn_path):
        """Evaluate a candidate program in a sandbox."""

        # Check cache
        code_hash = hash(code)
        if code_hash in self.cache:
            return self.cache[code_hash]

        # Stage 1: Syntax check
        try:
            compile(code, "<candidate>", "exec")
        except SyntaxError:
            return -float('inf')

        # Stage 2: Sandboxed execution
        with tempfile.NamedTemporaryFile(
            mode='w', suffix='.py', delete=False
        ) as f:
            f.write(code)
            candidate_path = f.name

        try:
            result = subprocess.run(
                ["python", evaluation_fn_path, candidate_path],
                capture_output=True,
                text=True,
                timeout=self.timeout,
                env={**os.environ, "SANDBOX": "1"}
            )
            if result.returncode != 0:
                score = -float('inf')
            else:
                score = float(result.stdout.strip())
        except (subprocess.TimeoutExpired, ValueError):
            score = -float('inf')
        finally:
            os.unlink(candidate_path)

        self.cache[code_hash] = score
        return score

# OpenEvolve Full Configuration

# Problem specification
problem:
  description: "Evolve a sorting algorithm that minimizes comparisons"
  seed_program: "examples/sorting/seed_program.py"
  evaluation_fn: "examples/sorting/evaluate.py"

# Evolution parameters
evolution:
  max_generations: 1000
  population_size: 100
  selection_strategy: "map_elites"    # or "tournament", "fitness_proportional"
  n_islands: 3
  migration_interval: 50
  tournament_size: 3

# MAP-Elites configuration
map_elites:
  n_descriptor_dims: 2
  bins_per_dim: 10
  descriptor_names:
    - "code_length"
    - "avg_comparisons"

# Mutation settings
mutation:
  diff_ratio: 0.5                  # 50% diff, 50% full rewrite
  n_parents: 1                     # Number of parents per mutation
  include_history: true            # Include mutation history in prompt
  max_history_length: 5            # Last N successful mutations

# LLM configuration
llm:
  models:
    - provider: "gemini"
      model_name: "gemini-2.0-flash"
      temperature: 0.8
      max_tokens: 4096
      weight: 0.8
    - provider: "gemini"
      model_name: "gemini-2.5-pro"
      temperature: 0.5
      max_tokens: 8192
      weight: 0.2

# Evaluation settings
evaluation:
  timeout_seconds: 60
  n_test_cases: 100
  cache_results: true
  sandbox_mode: "subprocess"      # or "docker"

# Cost control
cost_control:
  max_total_cost_usd: 50.0
  log_usage: true

# Logging
logging:
  level: "INFO"
  save_all_programs: false
  save_improvements_only: true
  output_dir: "./results"

import re

class DiffEngine:
    def apply_diff(self, original_code, llm_response):
        """Parse and apply a unified diff from LLM output."""

        # Extract diff from markdown code blocks or raw text
        diff_text = self._extract_diff(llm_response)
        if diff_text is None:
            return None

        # Parse unified diff hunks
        hunks = self._parse_hunks(diff_text)

        # Apply hunks to original code
        lines = original_code.split('\n')
        offset = 0

        for hunk in hunks:
            start = hunk.original_start + offset - 1
            # Remove old lines
            for _ in range(hunk.original_count):
                if start < len(lines):
                    lines.pop(start)
            # Insert new lines
            for i, line in enumerate(hunk.new_lines):
                lines.insert(start + i, line)
            offset += len(hunk.new_lines) - hunk.original_count

        result = '\n'.join(lines)

        # Validate syntax
        try:
            compile(result, "<modified>", "exec")
        except SyntaxError:
            return None  # Reject invalid code

        return result

    def extract_code(self, llm_response):
        """Extract full program from LLM response."""
        # Look for ```python ... ``` blocks
        pattern = r'```(?:python)?\s*\n(.*?)```'
        matches = re.findall(pattern, llm_response, re.DOTALL)
        if matches:
            code = matches[-1].strip()  # Take last code block
            try:
                compile(code, "<extracted>", "exec")
                return code
            except SyntaxError:
                return None
        return None

    def _extract_diff(self, text):
        """Extract diff block from LLM response."""
        # Try markdown code block first
        pattern = r'```(?:diff)?\s*\n(.*?)```'
        matches = re.findall(pattern, text, re.DOTALL)
        if matches:
            return matches[0]
        # Try raw diff (starts with --- or @@)
        if '---' in text and '+++' in text:
            return text
        return None

Improvement Rate = |{mutations that improve fitness}| / |{mutations that compile and run}|



Efficiency = Improvement Rate * avg(fitness improvement) / avg(API cost per mutation)

def tournament_select(programs, k=3):
    """Tournament selection: pick best of k random candidates."""
    tournament = random.sample(programs, min(k, len(programs)))
    return max(tournament, key=lambda p: p.fitness)

def fitness_proportional_select(programs, n=1):
    """Roulette wheel selection weighted by fitness."""
    fitnesses = [p.fitness for p in programs]
    min_f = min(fitnesses)
    weights = [f - min_f + 1e-8 for f in fitnesses]
    total = sum(weights)
    probs = [w / total for w in weights]
    return random.choices(programs, weights=probs, k=n)

def map_elites_select(grid):
    """Uniform random from occupied MAP-Elites cells."""
    occupied = list(grid.values())
    return random.choice(occupied)

where Di = discretized behavioral descriptor dimension i



Insertion rule: grid[cell] = argmax(fitness) among all programs mapping to cell

def migrate_ring(islands, k=3):
    """Ring migration: top-k from each island go to the next."""
    n = len(islands)
    migrants = []

    # Collect migrants from each island
    for i in range(n):
        top_k = sorted(
            islands[i].values(),
            key=lambda p: p.fitness,
            reverse=True
        )[:k]
        migrants.append(top_k)

    # Insert migrants into next island
    for i in range(n):
        target = (i + 1) % n
        for prog in migrants[i]:
            cell = discretize(prog.descriptors)
            if cell not in islands[target] or \
               prog.fitness > islands[target][cell].fitness:
                islands[target][cell] = prog

# In evaluate.py, users define behavioral descriptors:

def evaluate_and_describe(candidate_code):
    """Return both fitness score and behavioral descriptors."""

    # Run the candidate
    results = run_on_test_cases(candidate_code)

    # Fitness: how good is the solution
    fitness = compute_score(results)

    # Behavioral descriptors: what kind of solution is it
    descriptors = {
        "code_length": len(candidate_code.split('\n')),
        "time_complexity_proxy": measure_scaling(results),
        "uses_recursion": 1.0 if "def " in candidate_code
                            and is_recursive(candidate_code) else 0.0,
        "memory_usage": measure_peak_memory(results)
    }

    return fitness, descriptors

class AdaptiveModelSelector:
    def __init__(self, models, initial_weights, alpha=0.05):
        self.models = models
        self.weights = initial_weights.copy()
        self.success_counts = [0] * len(models)
        self.total_counts = [0] * len(models)
        self.alpha = alpha

    def select(self):
        # UCB1-inspired selection
        total = sum(self.total_counts) + 1
        scores = []
        for i in range(len(self.models)):
            if self.total_counts[i] == 0:
                scores.append(float('inf'))  # Explore untried
            else:
                exploit = self.success_counts[i] / self.total_counts[i]
                explore = ((2 * math.log(total)) / self.total_counts[i]) ** 0.5
                scores.append(exploit + self.alpha * explore)

        return self.models[scores.index(max(scores))]

    def update(self, model_idx, was_improvement):
        self.total_counts[model_idx] += 1
        if was_improvement:
            self.success_counts[model_idx] += 1

import sys
import time
import importlib.util
import random

def evaluate(candidate_path):
    """Evaluate a candidate sorting algorithm."""

    # Load candidate module
    spec = importlib.util.spec_from_file_location("candidate", candidate_path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)

    # Generate test cases
    test_cases = [
        random.sample(range(1000), k=n)
        for n in [10, 50, 100, 500, 1000]
        for _ in range(10)
    ]

    total_time = 0.0
    correct = 0

    for tc in test_cases:
        arr = tc.copy()
        expected = sorted(tc)

        start = time.perf_counter()
        result = module.sort(arr)
        elapsed = time.perf_counter() - start

        if result == expected:
            correct += 1
            total_time += elapsed

    # Score: correctness is critical, then speed
    correctness_ratio = correct / len(test_cases)
    if correctness_ratio < 1.0:
        score = correctness_ratio * 0.01  # Heavy penalty
    else:
        score = 1.0 / (1.0 + total_time)  # Faster = higher score

    print(score)

if __name__ == "__main__":
    evaluate(sys.argv[1])

You are an expert programmer tasked with improving algorithms.

## Problem Description:
{problem_description}

## Current Program (fitness score: {parent_score}):
```python
{parent_code}

--- a/program.py
+++ b/program.py
@@ line numbers @@
 context
-removed
+added

#### Prompt Customization

Users can fully customize prompts via the YAML configuration, including:

- System prompt (defining the LLM's role)
- Problem description
- Output format instructions (diff vs. full program)
- Whether to include mutation history
- Whether to include multiple parents (crossover-like)

### 11.9 Cost Control

Python (Cost Tracking)

    self.total_cost = 0.0
    self.total_input_tokens = 0
    self.total_output_tokens = 0
    self.calls_per_model = {}

    # Pricing per 1M tokens (approximate)
    self.pricing = {
        "gemini-2.0-flash": {"input": 0.10, "output": 0.40},
        "gemini-2.5-pro": {"input": 1.25, "output": 10.00},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "gpt-4o": {"input": 2.50, "output": 10.00},
        "claude-3-5-sonnet": {"input": 3.00, "output": 15.00},
    }

def update(self, model_name, input_tokens, output_tokens):
    self.total_input_tokens += input_tokens
    self.total_output_tokens += output_tokens

    if model_name in self.pricing:
        p = self.pricing[model_name]
        cost = (input_tokens * p["input"] + output_tokens * p["output"]) / 1e6
        self.total_cost += cost

def budget_exceeded(self):
    return (
        self.total_cost >= self.max_cost or
        self.total_input_tokens >= self.max_input_tokens or
        self.total_output_tokens >= self.max_output_tokens
    )

### 11.10 Meta-Level Improvement

Unlike AlphaEvolve (which has a self-improvement loop via Gemini training), OpenEvolve does not have a built-in meta-level improvement mechanism. However, it supports several forms of cross-run learning:

- **Seed program transfer:** The best program from one run can be used as the seed for a subsequent run
- **Database persistence:** The program database can be saved and loaded, allowing experiments to be resumed
- **Configuration tuning:** Results from one run inform hyperparameter choices for the next
- **Prompt refinement:** Observing what kinds of prompts produce improvements can guide prompt engineering

> **No model fine-tuning:** Like AlphaEvolve, OpenEvolve does not fine-tune the LLMs during evolution. The LLMs are used as frozen inference-time mutation operators. All "learning" happens at the population level.

### 11.11 Mathematical Framework

#### Evolutionary Loop Formalization


$$
Given: Problem specification S, seed program p0, evaluation function f: P --> R



    For t = 1, 2, ..., T:


      1. Select parent: pparent ~ Select(DBt-1)


      2. Choose model: m ~ Categorical(w1, ..., wK)


      3. Generate mutation: pcandidate = LLMm(pparent, S)


      4. Evaluate: s = f(pcandidate)


      5. Update: DBt = MapElitesInsert(DBt-1, pcandidate, s, desc(pcandidate))



    Return: argmaxp in DBT f(p)
$$

#### MAP-Elites Coverage


$$
Coverage(DB) = |{non-empty cells}| / prod(bins_per_dimi)



    Quality(DB) = (1/|{non-empty cells}|) * sum of f(DB[cell]) for all non-empty cells
$$

#### Expected Mutation Improvement


$$
E[improvement] = sum over models m: wm * P(f(child) > f(parent) | model=m) * E[f(child) - f(parent) | improvement, model=m]
$$

#### Cost-Per-Improvement


$$
CPI = Total API Cost / Number of Fitness Improvements Found



    Marginal CPI at generation t: CPIt = cost(generation t) / max(0, n_improvements at generation t, epsilon)
$$

## 12 Programming Language

| Aspect | Language | Notes |
| --- | --- | --- |
| OpenEvolve framework | **Python 3.8+** | Pure Python implementation |
| Evolved programs | **Python** (primarily) | Framework is Python-centric but extensible to other languages |
| Configuration | **YAML** | Human-readable configuration files |
| Dependencies | Standard Python ecosystem | google-generativeai, openai, anthropic, pyyaml, etc. |

### Extensibility to Other Languages

While the default evaluation pipeline assumes Python programs, the evaluation function is user-defined and can invoke any external process. Users could evolve programs in any language by:

1. Defining the seed program in the target language
2. Writing an evaluation function that compiles and runs the target language
3. Adjusting the prompt templates to request output in the target language

## 13 Memory Management

### Program Database

- **Sparse MAP-Elites grid:** Implemented as a Python dictionary; only occupied cells consume memory
- **In-memory storage:** The entire population is kept in RAM (typical populations of 100-1000 programs are easily manageable)
- **Disk persistence:** Database can be serialized to disk (pickle/JSON) for resuming experiments
- **Elite archive:** Fixed-size list of best programs (configurable max size, default 20)

### Evaluation Cache

- **Hash-based cache:** Programs are hashed and their scores cached to avoid re-evaluation
- **LRU eviction:** For long runs, the cache can be bounded with LRU eviction policy

### LLM Context Management

- **Token counting:** Prompts are checked against the model's context window limit before sending
- **Truncation:** Long programs or histories are truncated to fit within context limits
- **Selective inclusion:** Only the most relevant parent programs and recent history are included

### Memory Estimation


$$
Memory = O(P * S + C * S + E * S)



    where P = population size, S = average program size (bytes),


    C = cache size, E = elite archive size



    Typical: 1000 programs * 10KB each = ~10MB (negligible)
$$

## 14 Continued Learning

### Within-Run

- **Population evolution:** The program database continuously improves over generations
- **Mutation history:** Successful mutations are recorded and included in future prompts, allowing the LLM to learn from what has worked
- **Adaptive model selection:** If enabled, the system learns which models are more effective and routes more traffic to them

### Cross-Run

- **Database persistence:** Save and load the program database to resume evolution
- **Seed transfer:** Best programs from one run can seed subsequent runs
- **Configuration refinement:** Observing run metrics guides future configuration choices

### Limitations vs. AlphaEvolve

- No self-improvement loop (OpenEvolve does not train its own LLMs)
- No automatic infrastructure optimization (no Borg, no TPU, no Google-scale feedback)
- Learning is bounded to the population and prompt level, not the model weight level

## 15 Applications and Examples

### 15.1 Sorting Algorithm Evolution

> The sorting example evolves a Python sorting function starting from a basic implementation (e.g., bubble sort) toward faster algorithms. The evaluation function measures wall-clock time on benchmark arrays of varying sizes, with correctness as a hard constraint.

Python (examples/sorting/seed_program.py)

Through evolution, OpenEvolve can discover quicksort, mergesort, timsort-like algorithms, or novel hybrid approaches that outperform the seed on the specific benchmark.

### 15.2 Symbolic Regression

Given data points (x, y), evolve a mathematical function f such that f(x) closely approximates y. The evaluation function computes mean squared error on held-out data, rewarding both accuracy and simplicity.

### 15.3 Mathematical Optimization

Evolve algorithms for combinatorial optimization problems. The user provides an evaluation function that scores the quality of the solution found by the candidate algorithm.

### 15.4 Custom Applications

OpenEvolve's modular design enables any application where:

1. Solutions can be expressed as Python code (or code callable from Python)
2. An automatic evaluation function can score solution quality
3. The search space is rich enough to benefit from evolutionary exploration

### How to Create a Custom Application

Bash

score = benchmark(mod.solve)
print(score)