bump version

CLAUDE.md

@@ -0,0 +1,118 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+OpenEvolve is an open-source implementation of Google DeepMind's AlphaEvolve system - an evolutionary coding agent that uses LLMs to optimize code through iterative evolution. The framework can evolve code in multiple languages (Python, R, Rust, etc.) for tasks like scientific computing, optimization, and algorithm discovery.
+
+## Essential Commands
+
+### Development Setup
+```bash
+# Install in development mode with all dependencies
+pip install -e ".[dev]"
+
+# Or use Makefile
+make install
+```
+
+### Running Tests
+```bash
+# Run all tests
+python -m unittest discover tests
+
+# Or use Makefile
+make test
+```
+
+### Code Formatting
+```bash
+# Format with Black
+python -m black openevolve examples tests scripts
+
+# Or use Makefile
+make lint
+```
+
+### Running OpenEvolve
+```bash
+# Basic evolution run
+python openevolve-run.py path/to/initial_program.py path/to/evaluator.py --config path/to/config.yaml --iterations 1000
+
+# Resume from checkpoint
+python openevolve-run.py path/to/initial_program.py path/to/evaluator.py \
+  --config path/to/config.yaml \
+  --checkpoint path/to/checkpoint_directory \
+  --iterations 50
+```
+
+### Visualization
+```bash
+# View evolution tree
+python scripts/visualizer.py --path examples/function_minimization/openevolve_output/checkpoints/checkpoint_100/
+```
+
+## High-Level Architecture
+
+### Core Components
+
+1. **Controller (`openevolve/controller.py`)**: Main orchestrator that manages the evolution process using ProcessPoolExecutor for parallel iteration execution.
+
+2. **Database (`openevolve/database.py`)**: Implements MAP-Elites algorithm with island-based evolution:
+   - Programs mapped to multi-dimensional feature grid
+   - Multiple isolated populations (islands) evolve independently
+   - Periodic migration between islands prevents convergence
+   - Tracks absolute best program separately
+
+3. **Evaluator (`openevolve/evaluator.py`)**: Cascade evaluation pattern:
+   - Stage 1: Quick validation
+   - Stage 2: Basic performance testing  
+   - Stage 3: Comprehensive evaluation
+   - Programs must pass thresholds at each stage
+
+4. **LLM Integration (`openevolve/llm/`)**: Ensemble approach with multiple models, configurable weights, and async generation with retry logic.
+
+5. **Iteration (`openevolve/iteration.py`)**: Worker process that samples from islands, generates mutations via LLM, evaluates programs, and stores artifacts.
+
+### Key Architectural Patterns
+
+- **Island-Based Evolution**: Multiple populations evolve separately with periodic migration
+- **MAP-Elites**: Maintains diversity by mapping programs to feature grid cells
+- **Artifact System**: Side-channel for programs to return debugging data, stored as JSON or files
+- **Process Worker Pattern**: Each iteration runs in fresh process with database snapshot
+- **Double-Selection**: Programs for inspiration differ from those shown to LLM
+- **Lazy Migration**: Islands migrate based on generation counts, not iterations
+
+### Code Evolution Markers
+
+Mark code sections to evolve using:
+```python
+# EVOLVE-BLOCK-START
+# Code to evolve goes here
+# EVOLVE-BLOCK-END
+```
+
+### Configuration
+
+YAML-based configuration with hierarchical structure:
+- LLM models and parameters
+- Evolution strategies (diff-based vs full rewrites)
+- Database and island settings
+- Evaluation parameters
+
+### Important Patterns
+
+1. **Checkpoint/Resume**: Automatic saving of entire system state with seamless resume capability
+2. **Parallel Evaluation**: Multiple programs evaluated concurrently via TaskPool
+3. **Error Resilience**: Individual failures don't crash system - extensive retry logic and timeout protection
+4. **Prompt Engineering**: Template-based system with context-aware building and evolution history
+
+### Development Notes
+
+- Python >=3.9 required
+- Uses OpenAI-compatible APIs for LLM integration
+- Tests use unittest framework
+- Black for code formatting
+- Artifacts threshold: Small (<10KB) stored in DB, large saved to disk
+- Process workers load database snapshots for true parallelism

configs/default_config.yaml

@@ -3,8 +3,8 @@
 # You can use this as a template for your own configuration
 
 # General settings
-max_iterations: 1000                  # Maximum number of evolution iterations
-checkpoint_interval: 50               # Save checkpoints every N iterations
+max_iterations: 100                  # Maximum number of evolution iterations
+checkpoint_interval: 10               # Save checkpoints every N iterations
 log_level: "INFO"                     # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
 log_dir: null                         # Custom directory for logs (default: output_dir/logs)
 random_seed: 42                       # Random seed for reproducibility (null = random, 42 = default)

openevolve/_version.py

@@ -1,3 +1,3 @@
 """Version information for openevolve package."""
 
-__version__ = "0.0.17"
+__version__ = "0.0.18"

pyproject.toml

@@ -47,5 +47,8 @@ disallow_incomplete_defs = true
 [project.scripts]
 openevolve-run = "openevolve.cli:main"
 
+[tool.setuptools.packages.find]
+include = ["openevolve*"]
+
 [tool.setuptools.dynamic]
 version = {attr = "openevolve._version.__version__"}

setup.py

@@ -1,14 +1,3 @@
-from setuptools import setup, find_packages
-import os
-import sys
+from setuptools import setup
 
-# Add the package directory to sys.path to import version
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'openevolve'))
-from _version import __version__
-
-setup(
-    name="openevolve",
-    version=__version__,
-    packages=find_packages(),
-    include_package_data=True,
-)
+setup()  # All config in pyproject.toml