Island-Model GA

A genetic algorithm (GA) mimics natural selection: keep a population of candidate solutions, score each one, let the fitter ones reproduce and mutate, repeat. The trouble is that a single big population tends to converge — everyone ends up sharing the same genes, the algorithm settles into a local optimum, and no amount of mutation shakes it loose.

The island model (also called a distributed GA or parallel GA) borrows a trick from biogeography. Instead of one soup, you run several smaller populations in parallel — the islands. Each island evolves independently for a few generations, then a handful of individuals migrate: copies of the island's best solutions travel to neighboring islands and join their gene pool.

That periodic exchange of migrants does two things at once. First, it preserves diversity — islands that took different evolutionary paths keep their differences alive longer. Second, it spreads discoveries — when one island stumbles onto a good trait, migration gradually shares it with the rest.

The result is an optimizer that escapes local traps far more reliably than a single-population GA, and that maps naturally onto multi-core machines and distributed clusters. Related ideas appear in evolutionary algorithms and simulated annealing, which tackle the same local-optimum problem with different metaphors.

Below are four islands, each holding a small population of bit-strings trying to maximize the number of 1-bits (a simple fitness function). Each island evolves on its own — selection, crossover, mutation — generation by generation. Watch how quickly they diverge, then click Migrate to send each island's best individual to the next island and see the elites spread.

<!-- {{c_html_intro}} -->
<div class="hint-bar">{{hint_para}}</div>
<div id="islands-grid"></div>
<div id="status" class="status"></div>
<div class="btns">
  <button id="btn-step" type="button">{{btn_step}}</button>
  <button id="btn-run" type="button">{{btn_run}}</button>
  <button id="btn-migrate" type="button">{{btn_migrate}}</button>
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
</div>

/* {{c_css_reset}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 14px; }
.hint-bar { font-size: .85rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
#islands-grid {
  display: grid;
  grid-template-columns: repeat(4, 1fr);
  gap: 8px;
  margin-bottom: .5rem;
}
/* {{c_css_island}} */
.island {
  border: 2px solid #c8d6e3;
  border-radius: 8px;
  padding: 6px 8px;
  background: #f4f8fb;
}
.island.migrated { border-color: #2196a8; background: #e8f7f9; }
.island-title {
  font-size: .78rem;
  font-weight: 700;
  color: #1d3557;
  margin-bottom: 4px;
  display: flex;
  justify-content: space-between;
}
.island-fitness { color: #0a7d33; }
/* {{c_css_bar}} */
.bars { display: flex; flex-direction: column; gap: 2px; }
.bar-row { display: flex; align-items: center; gap: 4px; }
.bar-bg { flex: 1; height: 8px; background: #dde5ec; border-radius: 4px; overflow: hidden; }
.bar-fill { height: 100%; background: #1d3557; border-radius: 4px; transition: width .2s; }
.bar-fill.best { background: #0a7d33; }
.bar-label { font-size: .65rem; color: #888; width: 24px; text-align: right; }
/* {{c_css_status}} */
.status { font-size: .9rem; font-weight: 600; min-height: 1.3em; margin: .3rem 0; }
.status.ok { color: #0a7d33; }
.status.info { color: #1d3557; }
.btns { display: flex; gap: .4rem; flex-wrap: wrap; }
button {
  font: 600 13px system-ui, sans-serif;
  padding: .4rem .8rem;
  border: 1px solid #1d3557;
  background: #1d3557;
  color: #fff;
  border-radius: 8px;
  cursor: pointer;
}
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }

// Code not found

Notice the pattern: islands that got lucky early race ahead; islands that fell behind catch up after migration delivers a good solution into their gene pool. That catching-up moment is the island model's core trick — isolated diversity followed by targeted knowledge transfer.

The island model looks simple — run GAs in parallel, swap migrants — but its behavior depends on two parameters that interact in subtle ways.

Migration interval (how many generations between migrations) controls the isolation-vs-contact trade-off:

• Too frequent: islands are never truly isolated, diversity collapses, you get a slow single-population GA.
• Too infrequent: islands converge on their own local optima before they can help each other.

Migration topology (which islands talk to which) shapes how quickly good solutions spread:

• A ring ($k$ islands each connected to two neighbors) spreads discoveries slowly but keeps populations diverse longer.
• A complete graph spreads discoveries fast but risks premature convergence.
• Random or hierarchical topologies balance both and are common in practice.

Migration size (the number of migrants per event) adds a third knob. Sending a single elite per migration keeps disruption low; sending a large wave homogenizes islands quickly.

Theoretically, the island model can be analyzed as a Markov chain over combined population states, but the state space is exponential and tight convergence bounds are hard to derive. In practice, empirical tuning — running the algorithm on benchmark problems and measuring diversity versus fitness — is the standard approach.

One useful rule of thumb: the takeover time (how long it takes for a single fit individual to dominate all islands through migration) should be much longer than the time needed for any island to meaningfully explore its local neighborhood. Keep the islands truly isolated long enough, and they behave like independent experiments; make migration just frequent enough, and the best experiment wins.

The island model's combination of diversity and knowledge transfer makes it the go-to evolutionary strategy whenever the search space is rugged and a single GA keeps getting stuck:

• Chip layout and VLSI design: placing millions of transistors to minimize wire length is a combinatorial nightmare; island-model GAs have been used since the 1990s to find layouts that single-population methods miss.
• Neural architecture search (NAS): evolving network topologies across islands lets different islands specialize in depth, width, or skip connections before sharing good building blocks.
• Drug discovery: candidate molecules explored by different islands sample chemically diverse regions of a vast search space; migration prevents the population from fixating on one chemical scaffold.
• Multi-objective optimization: each island can target a different part of the Pareto front; migration then assembles a diverse set of trade-off solutions that no single run would find.
• Game AI and strategy bots: co-evolution on islands produces agents that have faced diverse opponents, making them more robust than agents trained against a single fixed pool.

The island model is essentially a meta-heuristic for avoiding local optima — the same structural problem that motivates simulated annealing and that makes non-convex optimization hard in general.

The island model encodes a deep insight: diversity and communication must be balanced, not maximized simultaneously. A single big population communicates perfectly but loses diversity fast. Fully isolated populations keep their differences but never share discoveries. The island model sits in between — isolated enough for diversity, connected enough for knowledge transfer.

That balance turns out to be surprisingly general. It shows up in ensemble learning, in multi-agent reinforcement learning, and in the way research communities work: teams work independently, then share results at conferences, and science advances faster than if everyone sat in one room.

So the next time you see an optimizer stuck in a valley, consider splitting it into islands. Sometimes the best way to explore is to explore separately — then compare notes.