Watch OpenEvolve discover optimal circle packing in real-time:

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

Result: Matches published benchmarks for n=26 circle packing problem.

Before (Baseline):

// Standard attention implementation
kernel void attention_baseline(/* ... */) {
    // Generic matrix multiplication
    float sum = 0.0;
    for (int i = 0; i < seq_len; i++) {
        sum += query[tid] * key[i];
    }
}

After Evolution (2.8x faster):

// OpenEvolve discovered optimization
kernel void attention_evolved(/* ... */) {
    // Hardware-aware tiling + unified memory optimization
    threadgroup float shared_mem[256];
    // ... evolved algorithm exploiting Apple Silicon architecture
}

Performance Impact: 2.8x speedup on Apple M1 Pro, maintaining numerical accuracy.

• Comprehensive Seeding: Every component (LLM, database, evaluation) is seeded
• Default Seed=42: Immediate reproducible results out of the box
• Deterministic Evolution: Exact reproduction of runs across machines
• Component Isolation: Hash-based isolation prevents cross-contamination

• Test-Time Compute: Integration with OptiLLM for MoA and enhanced reasoning
• Universal API: Works with OpenAI, Google, local models
• Plugin Ecosystem: Support for OptiLLM plugins (readurls, executecode, z3_solver)
• Intelligent Ensembles: Weighted combinations with sophisticated fallback

• Double Selection: Different programs for performance vs inspiration
• Adaptive Feature Dimensions: Custom quality-diversity metrics
• Migration Patterns: Ring topology with controlled gene flow
• Multi-Strategy Sampling: Elite, diverse, and exploratory selection

For maximum flexibility with rate limiting, model routing, and test-time compute:

# Install OptiLLM
pip install optillm

# Start OptiLLM proxy
optillm --port 8000

# Point OpenEvolve to OptiLLM
export OPENAI_API_KEY="your-actual-key"

llm:
  api_base: "http://localhost:8000/v1"
  model: "moa&readurls-o3"  # Test-time compute + web access

Evolve prompts instead of code for better LLM performance:

# Example: HotpotQA dataset
Initial Prompt: "Answer the question based on the context."

Evolved Prompt: "As an expert analyst, carefully examine the provided context. 
Break down complex multi-hop reasoning into clear steps. Cross-reference 
information from multiple sources to ensure accuracy. Answer: [question]"

Result: +23% accuracy improvement on HotpotQA benchmark

Full Example

Automatic solution generation for programming contests:

# Problem: Find maximum subarray sum
# OpenEvolve discovers multiple approaches:

# Evolution Path 1: Brute Force → Kadane's Algorithm
# Evolution Path 2: Divide & Conquer → Optimized Kadane's
# Evolution Path 3: Dynamic Programming → Space-Optimized DP

Online Judge Integration

Control how programs are organized in the quality-diversity grid:

database:
  feature_dimensions: 
    - "complexity"      # Built-in: code length
    - "diversity"       # Built-in: structural diversity
    - "performance"     # Custom: from your evaluator
    - "memory_usage"    # Custom: from your evaluator
    
  feature_bins:
    complexity: 10      # 10 complexity levels
    performance: 20     # 20 performance buckets
    memory_usage: 15    # 15 memory usage categories

Important: Return raw values from evaluator, OpenEvolve handles binning automatically.

Advanced prompt engineering with custom templates:

prompt:
  template_dir: "custom_templates/"
  use_template_stochasticity: true
  template_variations:
    greeting:
      - "Let's enhance this code:"
      - "Time to optimize:"
      - "Improving the algorithm:"

See prompt examples for complete template customization.

Cost depends on your LLM provider and iterations:

• o3: ~$0.15-0.60 per iteration (depending on code size)
• o3-mini: ~$0.03-0.12 per iteration (more cost-effective)
• Gemini-2.5-Pro: ~$0.08-0.30 per iteration
• Gemini-2.5-Flash: ~$0.01-0.05 per iteration (fastest and cheapest)
• Local models: Nearly free after setup
• OptiLLM: Use cheaper models with test-time compute for better results

Cost-saving tips:

• Start with fewer iterations (100-200)
• Use o3-mini, Gemini-2.5-Flash or local models for exploration
• Use cascade evaluation to filter bad programs early
• Configure smaller population sizes initially

OpenEvolve shines when you need to explore large solution spaces or optimize for multiple objectives simultaneously.

Yes! OpenEvolve supports any OpenAI-compatible API:

• Commercial: OpenAI, Google, Cohere
• Local: Ollama, vLLM, LM Studio, text-generation-webui
• Advanced: OptiLLM for routing and test-time compute

Just set the api_base in your config to point to your endpoint.

Built-in mechanisms prevent stagnation:

• Island migration: Fresh genes from other populations
• Temperature control: Exploration vs exploitation balance
• Diversity maintenance: MAP-Elites prevents convergence
• Artifact feedback: Error messages guide improvements
• Template stochasticity: Randomized prompts break patterns

Manual interventions:

• Increase num_diverse_programs for more exploration
• Add custom feature dimensions to diversify search
• Use template variations to randomize prompts
• Adjust migration intervals for more cross-pollination

Multiple success metrics:

1. Primary Metric: Your evaluator's combined_score or metric average
2. Convergence: Best score improvement over time
3. Diversity: MAP-Elites grid coverage
4. Efficiency: Iterations to reach target performance
5. Robustness: Performance across different test cases

Use the visualizer to track all metrics in real-time and identify when evolution has converged.