Questions & Answers

What is it?

This is a genetic algorithm related to the infinite monkey theorem.

• a genetic algorithm — “a search heuristic that mimics the process of natural selection” (source of the definition);
• related to — this is not a direct implementation of this theorem;
• the infinite monkey theorem — “If an army of monkeys were strumming on typewriters they might write all the books in the British Museum. The chance of their doing so is decidedly more favourable than the chance of the molecules returning to one half of the vessel.” (A. S. Eddington; source).

My algorithm simulates generations and generations of virtual monkeys randomly typing on a keyboard to produce the Shakespearean tragedy Hamlet.

How does it work? (nontechnically)

1. Twenty virtual monkeys are created.
2. Each of them has a randomly generated binary DNA (10110…).
3. Each of their genes is decoded into a group of three pieces of data (see the example above; on the live page, this data is available in the details of each line typed in your browser):
   • a finger;
   • the condition of this finger (folded, straight…);
   • whether the monkey must press the [shift] key.
4. This data is applied to a virtual standard US keyboard.
5. A character is created (a, Z, 5, @, [tab]…) according to the finger to use and its position over the keyboard (see this example), and to whether the [shift] key is pressed or not.
6. The order of the genes in the DNA gives the sequence of fingers to activate: a sentence is produced.
7. The program, which “knows” Hamlet, compares the sentences generated by the monkeys with the original one and rates the monkeys between 0 and 1. The closer the score is to 1, the closer the generated sentence is to the expected one. The monkeys never have access to the original sentence: the only information they get is this score. If the sentence is found at this stage (in the first generation, that is: never), the loop restarts with new monkeys [goto b].
8. When all the sentences have been produced and rated, the monkeys are ranked. The monkey closest to the original sentence is cloned for the next generation, and is guaranteed the opportunity to reproduce. The other monkeys have a chance of reproducing that is proportional to their score.
9. The selected monkeys have sex with randomly selected monkeys of the group. They have babies. Each baby’s DNA is a mix of the DNA of both parents. [Update v. 2.1: each couple has two babies.]
10. The genes of the babies’ DNA are randomly mutated (1% of the genes). The babies become adults. The process continues [goto c] until the sentence is found.
11. Once the sentence is found, the loop restarts with new monkeys (entirely new DNA) [goto b].
12. Once the whole book has been produced, the loop restarts from the beginning to produce another one [goto a].

Added in 2026What was added in 2026?

You keep insisting on “randomly,” but is it truly random?

Yes and no.

• Yes — In this demonstration, the original book is never in direct contact with the primates. They receive no information about the content of the sentence they have to find. Their sentences are only rated. It is like a game of Hunt the Thimble with scores (.0265, .0444, .25…) instead of verbal hints (“cold, colder, warm, hot, boiling”).

  This is a stochastic process (we do not know how many generations will be necessary; we do not determine the content of the DNA; etc.) with a deterministic output.

  Randomness is explicitly used (that is, “injected”) three times in the process: to generate the DNA of the monkeys of the first generation; to select half of the monkeys that have sex, in each loop; to mutate the genes, in each loop.

• No — This is not true randomness: because this is a computer-based experiment, and because no hardware random number generator is used, it would be more accurate to say pseudorandomness. But this is not a deliberate bias: nothing interferes with the workings of the algorithm’s pseudorandom generator, a Mersenne Twister 19937 (see below), which is a strong one for this context. On this site, “random” therefore means “pseudorandom.”

  Because the monkeys are rated, selected and ranked, and their DNA mixed, this is not a canonical implementation of the infinite monkey theorem. Otherwise, it would be impossible to converge towards the book, sentence by sentence. Randomness is channeled. This is the very purpose of genetic algorithms.

Does it really mimic evolution?

Yes and no.

• Yes — These creatures have a rudimentary data structure that carries information about how they will evolve and reproduce during their short “life.”

  In the early stages, these structures, 840 bits long per creature, are highly diverse: the model allows more than 7 × 10²⁵² different DNA strands.

  The creatures that best fit the environment, which is given by the rating and ranking system, are more likely to reproduce.

  The DNA of the creatures of the next generation is a mix of both parents’ DNA, and has distinctive features of its own (mutation).

• No — In this simulation, as in genetic algorithms in general, creatures do not evolve freely, but towards a goal. I do not believe that such a situation represents a natural process. By creating an artificial evolution, I am not supporting creationism or the pseudoscience of intelligent design.

  This experiment is probably more informative from a technical point of view than from a philosophical angle, because the monkeys, and the way they interact with a certain state of their virtual world, remain (and will remain) too simplistic vis-à-vis the real world.

Does it simulate intelligence?

Not at all.

The monkeys are not able, in general, to generate grammatically valid or seemingly meaningful sentences. If they do, it is only by accident or as a result of the evolutionary process. Suppose I had hidden how this website works, and said: “Look! I have created virtual monkeys that are able to understand any book and, after some hesitation, to rewrite it without copying it. They internalize the meaning of each sentence. I will not show you the code, but I will ask an indisputable C++ expert to confirm it.” You might reply: “No way! Monkey see, monkey do!” But because this expert, after taking a look at the source code, would say: “Indeed, there are creatures with no copy/paste function, and they produce the sentences by themselves,” you would probably think that such extraordinary creatures understand the English language (well, I know you are not that naive). If I put my program into a black box, I produce an experiment close to the Chinese Room argument, in order to give the (false) impression that my monkeys are smart.

But they are not, I insist. They have no brain; their only purpose is to type a sequence of keys in the hope of having sex with a random peer—like on a dating app.

In the first version, the title read: “. . . Monkeys Writing . . .” I changed it to “. . . Monkeys Typing . . .” because it seems to me that the act of writing has a different meaning from that of typing. Writing implies comprehending the result of the input, while typing focuses more on the input process. Cf. the hyperbolic “That’s not writing, that’s typing” (Capote on Kerouac).

Is such an experiment a new thing?

No (and yes).

• No — Simulating typing monkeys with a genetic algorithm is a classic. Prof. Daniel Shiffman wrote a wonderful chapter on this very subject in The Nature of Code (freely available online). He explains how it works in a video, too:

  9.x: Genetic Algorithms and Evolutionary Computing – The Nature of Code Play the video here. Nothing is loaded from YouTube before you click.

  In 2011, a programmer generated millions of virtual monkeys typing nine-character strings made of the letters a to z (more information). But the current experiment is very different. Here:

  1. only twenty monkeys go into action: a single computer can run the algorithm;
  2. almost all the characters available on a standard keyboard are used (uppercase included);
  3. the book is generated sentence by sentence, in order;
  4. the monkeys are constrained by their DNA: randomness is channeled, whereas the 2011 experiment was closer to the implementation of a string-searching algorithm (the monkeys generated nine-character strings [e.g. “to be or ”] that were compared with the whole book).

• (Shy yes) — My implementation lets people watch the process live, sentence by sentence, with access to detailed information about the monkeys and the sentences they generate.

Are the monkeys able to type any text?

Yes, provided that its lines (lines, not sentences) are no more than 70 characters long and use only characters available on a standard US keyboard. It will work without any modification of the code.

How does it work? (technically)

This is a C++ program. The source code is available online.

Randomness

Engine: std::mt19937. std::uniform_int_distribution<int> randna randomly produces a 0 or a 1 (an int), which is converted to a char ('0', '1') with the formula (int) + '0';

Added in 2026[Update v. 3.0 (2026): the engine is seeded once, when the program starts, from std::random_device: in 2015 that was when the server started, now it is each time the live page is opened. The engine is the same, but the compiler and the C++ library are not, and the C++ standard leaves it to each library how a distribution turns the engine’s output into numbers: from the same seed, the 2015 program would have drawn other numbers.]

DNA

Per monkey: a string of 840 bits (70 genes × 12 bits), initialized to 0 and then randomized.

Genes: 12 bits long. The first 4 bits encode the finger (an int); the next 7 bits encode the condition of the finger (a double, from 0 to 1); the last bit encodes whether the [shift] key is pressed (a bool: 0 [false] or 1 [true]).

Example: 011000010001 is equivalent to 0110 0001000 1, where

0110    => (int)    6    : (6 + 1)th finger, right index
0001000 => (double) .08  : finger very folded
1       => (bool)   true : [shift] pressed

Decode function: makes a tuple(int, double, bool) from the substring of a gene. Decoder: std::stoi(genes, nullptr, 2);

Some genes are repressed because they represent an impossible state of the world. Example: a 12^th finger.

Fingers

From 0, the left pinky, to 9, the right pinky, with the thumbs side by side, that is:

0. left pinky
1. left ring
2. left middle
3. left index
4. left thumb
5. right thumb
6. right index
7. right middle
8. right ring
9. right pinky

Condition of the finger

The closer to the bottom of the keyboard, the closer to 0 (folded finger); the closer to the top of the keyboard (below the function keys), the closer to 1 (straightened finger). This is not a function based on scientific facts: it is a convenient and intuitive way to express the position of a finger above a keyboard and the “effort” needed to reach a key.

0 [folded] -- .5 [half-straightened] -- 1 [fully straightened]

Keyboard

ANSI INCITS 154-1988 (US standard).

All the keys are available, except:

• the function keys ([F1]…);
• [Esc], [Ctrl], [Caps Lock], [Alt];
• the navigation keys ([←], [End]…);
• the numeric keypad (the numbers are available on the alphanumeric keys);
• [Backspace];
• [Enter];
• the Windows key.

Thus, the monkeys use 96 different characters, including [Tab] and the grave accent.

The keyboard is hard-coded. Each finger has access to only a subset of the keyboard, like this.

If an impossible finger (> 9) or position (> 1) is given, it means that there is an anomaly in the gene: it is repressed, and the keyboard returns char(0), that is, null (because no action is performed on it).

Added in 2026[Update v. 3.0 (2026): this is not true of the thumbs. In the code, a thumb presses the space bar whatever its condition, even above 1: the seven bits of a condition, divided by 100, go up to 1.27.]

Evaluation

The sentence generated by each monkey, once its DNA has been decoded and the keys pressed, is compared, char by char, with the original sentence. The two sentences are kept strictly apart: they only come into contact in an rvalue, the computation of the absolute distance between them.

The monkeys’ “intelligence” (a convenient but probably biased way of saying “fitness”) is evaluated as a double:

1 divided by (absolute distance between the generated sentence and the reference sentence + 1)²

This lvalue does not contain any direct information about the content of the reference sentence. Only this double, between 0 and 1.

That’s it.

Selection

The monkeys are ranked according to their intelligence.

Reproduction

Two modes are combined: elite and roulette.

Elite: the best monkey is cloned twice, and its two clones are monkeys 0 and 1 of the next generation. Clone 0’s DNA remains intact in the next generation; clone 1’s DNA can be mutated before the next generation. This may look like a waste, but the best monkey quickly ends up being monkey 0 or monkey 1, so it clones into itself and one other monkey.

Roulette: statistically, the chance that a monkey becomes a breeder is proportional to its intelligence.

Reproduction (50/50 crossover): the baby monkeys (temporary monkeys 20 to 39) receive the first half of their DNA from a breeder, and the second half from a random monkey (std::uniform_int_distribution<int> randomonkey).

[Update v. 2.1: and vice versa. Each couple has two babies. The first baby gets its DNA from parent A and parent B, in that order; the second baby gets its DNA from parent B and parent A, in that order.]

Parent A: 10011 . . . 01010 (selected breeder)
Parent B: 00101 . . . 11101 (random monkey)
Baby A  : 10011 . . . 11101
Baby B  : 00101 . . . 01010 < update v. 2.1

Fun facts: the monkeys are neither male nor female (no identified sex), and a monkey can mate with itself. You may think that this is useless, until you realize that the resulting DNA can be mutated.

Mutation

No mutation = no genetic algorithm.

The mutation rate is set at 1%.

For each position of a character in a sentence (length: 70), a random number from 0 (included) to 100 (excluded) is generated (std::uniform_int_distribution<int> randomutation). If this number is strictly less than the mutation rate, the whole gene at this position is mutated at random: the finger can change, the condition of the finger can change, the state of [shift] can change.

Example:

0110    => (int)    6    : (6 + 1)th finger, right index
0001000 => (double) .08  : finger very folded
1       => (bool)   true : [shift] pressed

becomes (arbitrary example):

0100    => (int)    4    : (4 + 1)th finger, left thumb
1011101 => (double) .93  : finger very straightened
0       => (bool)   false: [shift] NOT pressed

Is it useful?

No. Or perhaps to illustrate the myth of Sisyphus.

Do you simulate primate bones, hand muscles…?

No. Do not expect a VR-ready 3D simulation of the monkeys either. There is nothing beyond the 2D, 44 × 11 px, non-animated fingers on the statistics pages. My monkeys are nothing more than hands and implicit, unidentified genitals.

(Misc.)

What are the numbers next to the sentences, on the statistics page?

These numbers are the “intelligence” (that is, the fitness) of the monkey that produced the sentence, from .000… to 1.

Sometimes, chunks of characters jump to the left or to the right. Why?

(0.00000776)  MJCH<<Id   llklmd kg wxk ickc0
(0.00000935)  MJCH<<Id    llklmd kg wxk ickc0

(0.00000776)  MJCH<<Id  [nothing] llklmd kg wxk ickc0
(0.00000935)  MJCH<<Id    llklmd kg wxk ickc0

Some genes are not expressed (because they represent an impossible finger or an impossible condition of the finger). When a gene is repressed, the keyboard returns “nothing” (char(0), null) because no action is performed on it. Sometimes, a mutation turns a repressed gene into an expressed one. When this new gene means that the hand presses [space] or [tab], a null char is replaced by this space: a jump to the right occurs. And vice versa, when a mutation represses a gene.

Can I ask more questions, or correct you?

Sure!

Feel free to contact me. I may add your (anonymized) question here, along with my answer.