Generate the configuration for OpenEvolve with baseline comparison.

Generate the evaluator for OpenEvolve using the actual task implementation with baseline comparison.

Generate a generic method based on problem structure and return type.

Generate the initial program for OpenEvolve based on the actual task implementation.

Generate a generic fallback method when the actual solve method cannot be extracted.

Get size of an artifact value in bytes

Get task-specific data_size values.

GPU-protected application of custom attention hook

GPU-protected baseline measurement with enhanced error handling

GPU-protected removal of custom attention hook

Harmonize the formats between solve() and is_solution() methods. Fixes common mismatches like returning numpy arrays vs expecting lis

Identify improvement areas with proper fitness/feature separation

Imports a Python module from a given file path.

Infer the expected return type from the solve method.

Determine if a program is novel based on diversity to existing programs Args: program: Program to check isla

Lazily initialize expensive components on first use

Use LLM to evaluate code quality Args: program_code: Code to evaluate program_id: Optional ID for logging

Use LLM to judge if a program is novel compared to a similar existing program

Load artifacts from a directory

Load state from a checkpoint directory

Load the evaluation function from the evaluation file

Load the initial program from file

Dynamically load a Python module from an arbitrary filesystem path. This is used to load the evolved/optimized hook program at runtime witho

Load all available AlgoTune tasks.

Manual mode: write a task JSON file and poll for *.answer.json If timeout is provided, we respect it; otherwise we wait indefinitely

Memory-safe correctness testing with GPU protection

Normalize CRLF/CR newlines to LF This makes diff parsing deterministic because OpenEvolve diff regexes use '\n'

Computes the objective function using the unitless norm calculation.

Parse mlx-lm output to extract performance metrics

Print comprehensive bulletproof evaluation results

Reconstruct island assignments from saved metadata Args: saved_islands: List of island program ID lists from metadata

Safely remove attention hook

Reset all error tracking counters

Async implementation of run_evolution

Run evolution with checkpoint saving support

On success: (idx, returncode, elapsed, stdout_or_None, stderr) On timeout: raise RunnerTimeout On non-zero: raise RunnerExitCodeError

Launch one child, send coordinates via stdin, child writes .npy to out_path Returns (idx, out_path_str, elapsed_sec, raw_stdout, raw_stderr)

Sample a parent for exploitation (from archive/elite programs)

Sample a parent from the archive, preferring programs from the specified island Args: island_id: The island to prefer pr

Sample a completely random parent from a specific island (uniform distribution) Args: island_id: The island to sample fr

Sample a parent program from the current island for the next evolution step Returns: Parent program from current island

Save the best program Args: program: Best program (if None, uses the tracked best program)

Save a checkpoint Args: iteration: Current iteration number

Helper for min-max scaling

Serialize config object to a dictionary that can be pickled

Setup Python import paths for AlgoTune modules.

Set up logging

Set up manual task queue directory if llm.manual_mode is enabled Queue directory is always: <openevolve_output>/manual_tas

JIT-compiled function to find polynomial roots using JAX. This function leverages jax.numpy.roots which is a JIT-compatible implementatio

Static analysis of Metal kernel syntax for common safety issues

Store enhanced baseline metrics

Test single sequence with enhanced memory safety

Update the archive of elite programs Args: program: Program to consider for archive

Update the absolute best program tracking Args: program: Program to consider as the new best

Update the best program tracking for a specific island Args: program: Program to consider as the new best for the island

Update running statistics

Validate cascade evaluation configuration and warn about potential issues Args: module: The loaded evaluation module

Comprehensive validation of custom attention class

Pre-execution validation of Metal kernel safety

Return a validation error result.

Write an artifact to a file

Adaptive signal processing algorithm using sliding window approach. Args: x: Input signal (1D array of real-valued samples)

Checks if all inner hexagons are contained within the outer hexagon.

Checks if all inner hexagons are contained within the outer hexagon.

Analyze and compare the benchmark results.

Performs one step of Simulated Annealing (not JIT-compiled).

Append a single trace to a JSONL file Args: trace: Trace object with to_dict() method output_path: Path to the JSONL file

Apply monkey patch to replace Qwen3 attention with custom implementation

Apply MLIR optimization passes based on parameters

Apply optimization parameters to base MLIR

Benchmark Metal kernel optimized GQA attention against MLX baseline.

Benchmark Metal kernel optimized GQA attention against MLX baseline.

Build artifacts that provide useful feedback. In normal mode: Only reveals how many modules are correct, not which ones. In rich feedbac

Distance-first combined score for TSP on [0, 1] x [0, 1] with n cities. For each instance i with tour length d_i and runtime t_i: 1)

Compute total cycle distances for a batch of instances Args: cities: np.ndarray of shape (B, n, 2). All finite. n >= 3 solut

Calculate AlgoTune Score as harmonic mean of speedups. Args: speedups: List of speedup values Returns: Harm

Calculate average tracking error L_avg(θ) over the window Args: filtered_signal: Output of the filter original_signal: Origi

Calculate the composite metric J(θ) = α₁·S(θ) + α₂·L_recent(θ) + α₃·L_avg(θ) + α₄·R(θ) All metrics are normalized and converted to penalties

Calculate false reversal penalty R(θ) - mismatched trend changes Args: filtered_signal: Output of the filter clean_signal: G

Calculates evaluation metrics, correctly handling multi-dimensional outputs. For multi-dimensional targets, metrics (NMSE, NMAE) are calcula

Calculate instantaneous lag error L_recent(θ) = |y[n] - x[n]| Args: filtered_signal: Output of the filter original_signal: O

Calculate pass@k metrics. pass@k = probability of finding solution within k samples For random search on 625 possibilities: - pass@

Calculate slope change penalty S(θ) - counts directional reversals Args: signal_data: 1D array of signal values Returns:

Calculate speedup between baseline and evolved solution. Speedup = (Baseline Time) / (Evolved Time) Higher is better. Args:

Calculate speedup between baseline and evolved solution. Speedup = (Baseline Time) / (Evolved Time) Higher is better. Args: