CodeEvolve: LLM進化的最適化による多言語コード強化 CodeEvolve: LLM-Driven Evolutionary Optimization with Runtime-Enriched Target Selection for Multi-Language Code Enhancement

Automatically evolving source code with large language models has become an active research direction, building on the success of systems like FunSearch and AlphaEvolve. CodeEvolve positions itself in this lineage, proposing an evolutionary optimization framework that aims to improve code across multiple programming languages rather than being tied to a single ecosystem.

At its core, the framework treats an LLM as a mutation and crossover operator inside a classical evolutionary algorithm. A population of candidate programs is maintained, the LLM rewrites or recombines them to produce offspring, and a fitness function — typically combining correctness checks with runtime measurements — drives selection across generations. Over many iterations, this loop is expected to converge toward higher-performing variants of the original program.

The distinctive contribution highlighted by the authors is what they call runtime-enriched target selection. Rather than picking mutation targets uniformly or purely from static features, CodeEvolve appears to use runtime signals — such as profiling data, hot paths, or observed behavior — to decide which code regions the LLM should attempt to rewrite. This kind of feedback-guided targeting may allow the search to concentrate compute on genuine bottlenecks, which is often where the largest performance gains lie. The multi-language angle suggests the system is designed to be reasonably agnostic to the underlying toolchain, although in practice supporting heterogeneous build and execution environments is nontrivial.

The broader context here is worth noting. Google DeepMind's AlphaEvolve demonstrated that LLM-driven evolutionary search can discover novel algorithms and optimize low-level kernels, while FunSearch showed similar promise on mathematical problems. Open-source efforts such as OpenEvolve have made the paradigm more accessible to independent researchers. CodeEvolve can be read as another data point in this trend, with a particular emphasis on generality across languages and on grounding mutation choices in execution data.

Several practical challenges remain open. LLM-based evolution can be expensive in tokens and wall-clock time, and the quality of results depends heavily on the evaluation harness — flaky benchmarks or weak correctness oracles can mislead selection. Multi-language support amplifies these issues because each language brings its own compilation, sandboxing, and measurement quirks. Security is another concern when arbitrary LLM-generated code is executed during the search loop. CodeEvolve's runtime-aware targeting plausibly mitigates some of these costs by focusing effort where it matters, though independent reproduction will be needed to assess how robustly the gains transfer beyond the benchmarks reported in the paper.

If the approach holds up, it points toward a future where performance engineering is increasingly co-driven by LLMs and lightweight evolutionary loops, complementing rather than replacing human optimization expertise.