History of Evolutionary Computation

The evolutionary algorithms taught today share one loop, described in the evolutionary algorithm loop: a population, selection, variation, and repetition. They were not designed as one family. Evolution strategies, evolutionary programming, genetic algorithms and genetic programming were developed by different people, in different places, for different problems, and for two decades their communities barely met. The differences that remain between them, in representation, in the operators they rely on, and in their theory, are easiest to understand by asking what problem each was built to solve.

This article follows those problems. Many popular accounts reduce the history to a list of names and years; the dates here are taken from the original publications. Fogel (1998) reprints many of the early papers with commentary, and Beyer and Schwefel (2002) give a first-hand account of evolution strategies.

Evolution as a kind of search

The idea that evolution is a search process, and that a machine might use the same process, predates any working implementation. In 1948 Alan Turing wrote a report for the National Physical Laboratory, "Intelligent Machinery," on how a machine might come to show intelligent behaviour. It remained unpublished until 1969 (Turing, 1969). In it Turing distinguished three kinds of search: the intellectual search carried out by a brain, the cultural search carried out by a community, and the "genetical or evolutionary search" by which nature looks for a combination of genes, judged by its survival value.

Turing returned to the analogy in 1950. Rather than programming an adult mind directly, he proposed building a simple "child machine" and educating it, and he compared the search for a good child machine to evolution: the machine's structure corresponded to hereditary material, changes to the machine to mutation, and the judgment of the experimenter to natural selection. He expected the experimenter, applying intelligence, to be faster than blind selection (Turing, 1950). Neither paper described an algorithm, but both framed learning and design as search over a space of candidates guided by a measure of success.

Early attempts, 1955 to 1965

The first concrete uses of the idea came in the 1950s, from people with quite different aims.

Improving a chemical plant. George Box, a statistician at Imperial Chemical Industries, faced a practical problem: a process that ran best at certain conditions in the laboratory rarely ran best at the same conditions in a full-scale plant, and there were too few specialists to run experiments on every plant. His answer, presented in 1955 and published as evolutionary operation (Box, 1957), was to make the plant run its own experiment during normal production. Operators cycled through a small planned set of variants around the standard conditions, such as slightly higher and lower temperatures and concentrations, recorded the results, and moved the standard conditions when the evidence showed that a variant was better. Box drew the analogy with evolution explicitly, comparing the adjustment of process variables to natural selection. The method used no computer at all, but it contained the essential loop: vary, measure, keep what works, repeat.

Simulating genetics. Alex Fraser, a geneticist in Australia, used digital computers to simulate reproduction, segregation and selection in populations of organisms, in order to study how genetic linkage affects the response to selection (Fraser, 1957). His purpose was biological, not to solve engineering problems, but his programs held a population of genotypes in the machine and bred them under selection, which is close to what genetic algorithms would later do.

Evolving programs. Richard Friedberg at IBM attempted something far more ambitious: a machine that would learn to write programs for a simple simulated computer (Friedberg, 1958; Friedberg, Dunham, and North, 1959). Programs were generated at random and run on simple tasks, and individual instructions that appeared in successful programs were made more likely to appear again. The machine learned some very simple tasks, but Minsky (1961) observed that it took about a thousand times longer than pure chance would, and that the later improvements did little more than make the search more random. He attributed the failure to credit assignment: success belongs to groups of instructions working together, not to each instruction in isolation. Program evolution was set aside for a generation.

Optimization by evolution. Hans-Joachim Bremermann, a mathematician at Berkeley, proposed treating evolution, with both mutation and recombination, explicitly as a method of optimization (Bremermann, 1962). The same paper also considered limits that quantum theory places on data processing, a line of work that gave its name to the Bremermann limit on computation.

These efforts had no common community or vocabulary. Each was an isolated answer to a local problem, and computers of the time were too slow and too scarce for most of the ideas to be tested at any scale.

Three schools, three problems

In the 1960s three groups, unaware of one another for years, built lasting traditions.

Evolution strategies: Berlin, from 1964

At the Technical University of Berlin, Ingo Rechenberg and Hans-Paul Schwefel, then students, were trying to optimize shapes in fluid flow experimentally: bodies with minimal drag, or a plate made of jointed segments set in a turbulent air stream. The objective could only be measured, measurements were noisy, and the standard methods borrowed from numerical mathematics, changing one variable at a time or following an estimated gradient, performed badly. The decisive experiment, in June 1964, showed that a simple randomized rule did better than both (Rechenberg, 1965; Beyer and Schwefel, 2002). The rule had two parts: change all variables at once, slightly and at random; keep the new setting if it is not worse, and otherwise go back. With one parent and one offspring per generation, this is what was later called the $(1+1)$ evolution strategy.

The method was soon used on other experiments, most strikingly the design of a supersonic two-phase flow nozzle, whose segments could be duplicated or deleted so that the number of variables itself evolved (Schwefel, 1968; Klockgether and Schwefel, 1970). Schwefel's diploma thesis (1965) found that mutations restricted to small discrete steps could leave the search stuck, which led to continuous variables with Gaussian mutations (Beyer and Schwefel, 2002). Rechenberg's dissertation of 1971, published as a book in 1973, analysed the $(1+1)$ strategy on model functions and found that the best mutation size corresponds to a success probability of about one fifth, the basis of the one-fifth success rule for adapting it. Rechenberg also simulated a first strategy with several parents and recombination. Schwefel's dissertation (1975) compared evolution strategies with classical numerical optimization methods and introduced the $(\mu + \lambda)$ and $(\mu, \lambda)$ strategies with many offspring per generation, together with the self-adaptation of mutation parameters; his book appeared in English as Numerical Optimization of Computer Models (Schwefel, 1981).

The origin explains the character of evolution strategies: real-valued parameters, mutation as the main operator, and a strong emphasis on controlling step sizes, all inherited from experimental engineering optimization.

Evolutionary programming: San Diego, 1960s

Lawrence Fogel, working in San Diego, approached the problem from artificial intelligence. He treated the ability to predict an environment as central to intelligent behaviour, and asked whether a machine could evolve that ability rather than be programmed with it (Fogel, 1962). In evolutionary programming, as he, Alvin Owens and Michael Walsh presented it in their 1966 book Artificial Intelligence through Simulated Evolution, the environment was a sequence of symbols and the individuals were finite-state machines that tried to predict the next symbol. Offspring were produced by mutating a parent machine, for example by adding or deleting a state or changing a transition, and parents and offspring competed on their predictions for a place in the next population. The original experiments used mutation alone.

Genetic algorithms: Ann Arbor, 1960s and 1970s

John Holland at the University of Michigan was less interested in solving a particular problem than in a theory of adaptation: how any system, natural or artificial, could improve its performance in an environment it does not fully know (Holland, 1962). His students tested the ideas in dissertations, among them Bagley (1967), whose title already spoke of "genetic and correlation algorithms." Holland's book Adaptation in Natural and Artificial Systems (1975) set out the genetic algorithm: a population of fixed-length strings, selection in proportion to fitness, and crossover as the main source of new candidates, with mutation in a supporting role. It also gave the schema theorem, an account of how selection and crossover together process the many patterns of bits shared by strings in the population.

The same year, Kenneth De Jong's dissertation studied how genetic algorithms behave in practice, measuring the effect of population size, mutation rate and crossover on a suite of test functions that became a standard benchmark (De Jong, 1975; see De Jong test functions). David Goldberg's textbook (1989) brought genetic algorithms to a wide audience of engineers, and for many people outside the field "genetic algorithm" became the name for the whole subject.

Genetic programming

Friedberg's goal of evolving programs returned in the 1980s with a different representation. Cramer (1985) presented two languages for evolving programs at the first International Conference on Genetic Algorithms; in the second, programs had a tree structure and crossover exchanged subtrees, because he judged the first too sensitive to the position of each element for crossover to pass on useful substructures. John Koza developed the idea into genetic programming: programs represented as trees of functions and terminals, in the style of Lisp expressions, with crossover that swaps subtrees between parents. His book Genetic Programming: On the Programming of Computers by Means of Natural Selection (Koza, 1992) demonstrated the method on a wide range of problems and established it as a fourth branch. Where Friedberg had credited individual instructions, tree crossover moves whole subexpressions, the functional groups that Minsky had argued were the real carriers of credit. The program trees article describes the representation.

The schools side by side

Each school's defaults follow from its first problem. The table restates the sections above; the evolutionary algorithm loop shows how the same scheme accommodates all four.

Read by column, the table suggests a reason for the slow merger beyond the language and geography described below, though this is an interpretation rather than a documented cause. Evolution strategies came from experimental optimization of a few real-valued variables, and their early theory concerned the size of mutation steps, as in Rechenberg's one-fifth rule. Genetic algorithms came from a theory of adaptation, and their early theory concerned how selection and crossover process patterns of bits, as in Holland's schema theorem. The two communities were answering different questions with what turned out to be the same loop.

One field

Through the 1970s and much of the 1980s the schools developed separately. The European work on evolution strategies was published mostly in German, and the American genetic algorithm and evolutionary programming communities had little contact with each other. A series of conferences and journals then brought them together:

• 1985: the first International Conference on Genetic Algorithms, at Carnegie-Mellon University in Pittsburgh, with Holland as conference chair (Grefenstette, 1985).
• 1990: the first workshop on Parallel Problem Solving from Nature (PPSN), in Dortmund (Schwefel and Männer, 1991).
• 1993: the first issue of the journal Evolutionary Computation, from MIT Press. By then the umbrella term had come into use, and the journal's title adopted it.
• 1994: the first IEEE Conference on Evolutionary Computation, held within the IEEE World Congress on Computational Intelligence.
• 1997: the first issue of IEEE Transactions on Evolutionary Computation. It opened with a survey of the field's history by Bäck, Hammel, and Schwefel (1997) and, in the same issue, Wolpert and Macready's no free lunch theorems.
• 1999: the first Congress on Evolutionary Computation (CEC), in Washington, D.C., and the first Genetic and Evolutionary Computation Conference (GECCO), in Orlando, a joint meeting of the genetic algorithms conference and the annual genetic programming conference.

Contact between the schools changed each of them. Genetic algorithms adopted real-valued representations and the selection schemes of evolution strategies; evolution strategies added recombination; and textbooks such as Eiben and Smith (2015, chs. 2–3) now present the four branches as dialects of one scheme, distinguished mainly by their customary representations and operators.

The field today

The main lines since the merger extend rather than replace the classical algorithms.

• Adaptive search distributions. The covariance matrix adaptation evolution strategy, CMA-ES (Hansen and Ostermeier, 2001), learns the shape of the mutation distribution from the path of the search and is now a standard method for difficult continuous optimization.
• Several objectives. Algorithms such as NSGA-II (Deb, Pratap, Agarwal, and Meyarivan, 2002) evolve a whole set of trade-off solutions in one run.
• Theory. Runtime analysis now gives exact bounds for simple algorithms on defined problems; for example, the $(1+1)$ EA needs $\Theta(n \log n)$ evaluations in expectation on any linear function of $n$ bits (Droste, Jansen, and Wegener, 2002).
• Evolution and machine learning. Salimans, Ho, Chen, Sidor, and Sutskever (2017) showed that an evolution strategy could train neural network policies for reinforcement learning benchmarks, scaling to over a thousand parallel workers, learning 3D humanoid walking in about ten minutes, and reaching results competitive with standard reinforcement learning on most Atari games after an hour of training. Neuroevolution evolves the structure of networks as well as their weights.
• Language models as variation operators. AlphaEvolve (Novikov et al., 2025) runs an evolutionary loop in which a large language model proposes changes to programs and automated evaluators score them. Among its reported results is a procedure for multiplying two $4 \times 4$ complex-valued matrices with 48 scalar multiplications. In the terms of this article, it is a new answer to Friedberg's problem: a far more capable mutation operator for programs. The AlphaEvolve article examines its results.

The questions that separated the early schools, which representation, how much to rely on recombination, how to control mutation, are still the questions an algorithm designer faces. The history shows why there is no single answer: each school chose well for the problem in front of it.

References

• Bäck, T., Hammel, U., and Schwefel, H.-P. (1997). Evolutionary computation: Comments on the history and current state. IEEE Transactions on Evolutionary Computation, 1(1), 3–17.
• Bagley, J. D. (1967). The Behavior of Adaptive Systems Which Employ Genetic and Correlation Algorithms. Doctoral dissertation, University of Michigan.
• Beyer, H.-G., and Schwefel, H.-P. (2002). Evolution strategies: A comprehensive introduction. Natural Computing, 1(1), 3–52.
• Box, G. E. P. (1957). Evolutionary operation: A method for increasing industrial productivity. Applied Statistics, 6(2), 81–101.
• Bremermann, H. J. (1962). Optimization through evolution and recombination. In M. C. Yovits, G. T. Jacobi, and G. D. Goldstein (eds.), Self-Organizing Systems 1962, 93–106. Spartan Books.
• Cramer, N. L. (1985). A representation for the adaptive generation of simple sequential programs. In J. J. Grefenstette (ed.), Proceedings of the First International Conference on Genetic Algorithms and Their Applications, 183–187. Lawrence Erlbaum.
• De Jong, K. A. (1975). An Analysis of the Behavior of a Class of Genetic Adaptive Systems. Doctoral dissertation, University of Michigan.
• Deb, K., Pratap, A., Agarwal, S., and Meyarivan, T. (2002). A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Transactions on Evolutionary Computation, 6(2), 182–197.
• Droste, S., Jansen, T., and Wegener, I. (2002). On the analysis of the (1+1) evolutionary algorithm. Theoretical Computer Science, 276(1–2), 51–81.
• Eiben, A. E., and Smith, J. E. (2015). Introduction to Evolutionary Computing, 2nd ed., chapters 2 and 3. Springer.
• Fogel, D. B. (ed.) (1998). Evolutionary Computation: The Fossil Record. IEEE Press.
• Fogel, L. J. (1962). Autonomous automata. Industrial Research, 4, 14–19.
• Fogel, L. J., Owens, A. J., and Walsh, M. J. (1966). Artificial Intelligence through Simulated Evolution. Wiley.
• Fraser, A. S. (1957). Simulation of genetic systems by automatic digital computers. I. Introduction. Australian Journal of Biological Sciences, 10(4), 484–491.
• Friedberg, R. M. (1958). A learning machine: Part I. IBM Journal of Research and Development, 2(1), 2–13.
• Friedberg, R. M., Dunham, B., and North, J. H. (1959). A learning machine: Part II. IBM Journal of Research and Development, 3(3), 282–287.
• Goldberg, D. E. (1989). Genetic Algorithms in Search, Optimization, and Machine Learning. Addison-Wesley.
• Grefenstette, J. J. (ed.) (1985). Proceedings of the First International Conference on Genetic Algorithms and Their Applications. Lawrence Erlbaum.
• Hansen, N., and Ostermeier, A. (2001). Completely derandomized self-adaptation in evolution strategies. Evolutionary Computation, 9(2), 159–195.
• Holland, J. H. (1962). Outline for a logical theory of adaptive systems. Journal of the ACM, 9(3), 297–314.
• Holland, J. H. (1975). Adaptation in Natural and Artificial Systems. University of Michigan Press.
• Klockgether, J., and Schwefel, H.-P. (1970). Two-phase nozzle and hollow core jet experiments. In D. G. Elliott (ed.), Proceedings of the 11th Symposium on Engineering Aspects of Magnetohydrodynamics, 141–148. California Institute of Technology.
• Koza, J. R. (1992). Genetic Programming: On the Programming of Computers by Means of Natural Selection. MIT Press.
• Minsky, M. (1961). Steps toward artificial intelligence. Proceedings of the IRE, 49(1), 8–30.
• Novikov, A., Vũ, N., Eisenberger, M., Dupont, E., Huang, P.-S., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J. R., Mehrabian, A., Kumar, M. P., See, A., Chaudhuri, S., Holland, G., Davies, A., Nowozin, S., Kohli, P., and Balog, M. (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery. arXiv:2506.13131.
• Rechenberg, I. (1965). Cybernetic Solution Path of an Experimental Problem. Royal Aircraft Establishment, Library Translation 1122.
• Rechenberg, I. (1973). Evolutionsstrategie: Optimierung technischer Systeme nach Prinzipien der biologischen Evolution. Frommann-Holzboog.
• Salimans, T., Ho, J., Chen, X., Sidor, S., and Sutskever, I. (2017). Evolution strategies as a scalable alternative to reinforcement learning. arXiv:1703.03864.
• Schwefel, H.-P. (1965). Kybernetische Evolution als Strategie der experimentellen Forschung in der Strömungstechnik. Diploma thesis, Technical University of Berlin.
• Schwefel, H.-P. (1968). Experimentelle Optimierung einer Zweiphasendüse, Teil I. Technical Report 35, AEG Research Institute, Berlin.
• Schwefel, H.-P. (1975). Evolutionsstrategie und numerische Optimierung. Doctoral dissertation, Technical University of Berlin.
• Schwefel, H.-P. (1981). Numerical Optimization of Computer Models. Wiley.
• Schwefel, H.-P., and Männer, R. (eds.) (1991). Parallel Problem Solving from Nature: 1st Workshop, PPSN I, Dortmund, October 1–3, 1990. Lecture Notes in Computer Science 496. Springer.
• Turing, A. M. (1950). Computing machinery and intelligence. Mind, 59(236), 433–460.
• Turing, A. M. (1969). Intelligent machinery. In B. Meltzer and D. Michie (eds.), Machine Intelligence 5, 3–23. Edinburgh University Press. (Written in 1948.)