Biotechnology · Introductory

Semiconservative replication

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Semiconservative replication is the way cells copy DNA: each double helix is unwound and each old strand serves as a template for a new complementary strand. Every daughter molecule therefore contains one original strand and one newly made strand. This was demonstrated by the Meselson-Stahl experiment in 1958.

Intuition

Picture a zipper that opens and, while it opens, a new matching half is built along each side. Because A always pairs with T and G always pairs with C, each old strand dictates exactly what its new partner must be. Nothing is copied from scratch and nothing is thrown away: each copy keeps half of the original. Compare the alternatives: conservative replication would keep the old helix intact and make an entirely new one, and dispersive replication would scramble old and new pieces along both strands. Only the semiconservative model gives one old plus one new strand in each daughter, and this is what the experiment found.

Key equations

A↔T,G↔C
(1)

Complementary base pairing determines the sequence of each new strand.

fraction of original strands after n rounds=22n+1=12n
(2)

The two original strands persist, but they become a smaller share of all strands.

number of duplexes after n rounds=2n
(3)

Each round doubles the number of double helices.

Derivation

  1. Start with one duplex: two parental strands, each of which is a template.
  2. Helicase unwinds the helix at the origin, forming two replication forks.
  3. DNA polymerase adds nucleotides to the 3' end of a new strand, reading the template strand and following the pairing rules.
  4. Result after round 1: two duplexes, each with one parental and one new strand (4 strands in total... precisely, 2 duplexes = 4 strands, 2 old, 2 new).
  5. Round 2: 4 duplexes = 8 strands. The 2 original strands are still present, each paired with a new strand, so 2 of 8 strands are original, and 2 duplexes are hybrid while 2 are entirely new.
  6. In general, after n rounds there are 2^n duplexes and 2^(n+1) strands, and always exactly 2 original strands.

Worked example

Problem

E. coli is grown for many generations in 15N (heavy) medium, then moved to 14N (light) medium. After two generations, what proportions of DNA duplexes are heavy-light hybrid, and fully light? What is the proportion fully heavy?

  1. Generation 0 (after the switch): 1 duplex, both strands heavy (15N/15N).
  2. Generation 1: 2 duplexes, each with one heavy and one light strand (all hybrid).
  3. Generation 2: 4 duplexes. Each of the 2 hybrids separates: its heavy strand gets a new light partner (hybrid), its light strand gets a new light partner (light/light).
  4. So 2 duplexes are hybrid and 2 are fully light; none are fully heavy.
  5. Proportions: 1/2 hybrid, 1/2 light, 0 heavy.

Answer After two generations: 50% hybrid (15N/14N), 50% fully light (14N/14N), 0% fully heavy. In a CsCl density gradient this appears as two bands.

Common mistakes

  • Thinking the original strands are lost or degraded; they are conserved intact.
  • Believing the number of hybrid duplexes grows; it stays at 2 after the first round while light duplexes increase.
  • Confusing semiconservative with dispersive: strands are not a patchwork of old and new segments.
  • Forgetting that new strands are built 5' to 3', so the template is read 3' to 5'.
  • Saying the fully light band appears in generation 1; it first appears in generation 2.

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(71 lines)
import sys
from manim import *
from blocks import *


def build_generations(n_gen):
    """Track strands per generation: each strand is 'old' or 'new'. Returns list of DNA molecules (pairs)."""
    gens = [[("old", "old")]]
    for _ in range(n_gen):
        nxt = []
        for a, b in gens[-1]:
            # each parent strand is kept and pairs with a newly made strand
            nxt.append((a, "new"))
            nxt.append((b, "new"))
        gens.append(nxt)
    return gens


def duplex(pair, x, y):
    """Draw a DNA duplex as two vertical lines colored by strand origin."""
    col = {"old": C_MAIN, "new": C_ACCENT}
    l1 = Line([x - 0.15, y + 0.5, 0], [x - 0.15, y - 0.5, 0], color=col[pair[0]], stroke_width=8)
    l2 = Line([x + 0.15, y + 0.5, 0], [x + 0.15, y - 0.5, 0], color=col[pair[1]], stroke_width=8)
    return VGroup(l1, l2)


GENS = build_generations(2)


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14161c"
        TitleCard(self, "Semiconservative replication", "Each new DNA keeps one old strand")
        # draw each generation as a row of duplexes
        ys = [1.6, 0.1, -1.4]
        rows = []
        for g, mols in enumerate(GENS):
            n = len(mols)
            xs = [(k - (n - 1) / 2) * 2.2 for k in range(n)]
            row = VGroup(*[duplex(p, x, ys[g]) for p, x in zip(mols, xs)])
            lab = Text(f"Gen {g}", font_size=24, color=C_DIM).move_to([-5.5, ys[g], 0])
            rows.append(VGroup(row, lab))
        legend = VGroup(
            Line(ORIGIN, RIGHT * 0.5, color=C_MAIN, stroke_width=8),
            Text("old", font_size=24),
            Line(ORIGIN, RIGHT * 0.5, color=C_ACCENT, stroke_width=8),
            Text("new", font_size=24),
        ).arrange(RIGHT, buff=0.2).to_corner(UR, buff=0.4).shift(DOWN * 0.6)
        self.play(FadeIn(rows[0]), FadeIn(legend))
        StepCaption(self, "Strands separate; each is a template")
        for g in (1, 2):
            arrows = VGroup(*[Arrow(rows[g - 1][0][0].get_bottom() + DOWN * 0.1,
                                    rows[g][0][0].get_top() + UP * 0.1, buff=0.05, color=C_DIM)])
            self.play(FadeIn(rows[g]), run_time=1.2)
        StepCaption(self, "Every copy has one old and one new strand")
        self.wait(1)
        StepCaption(self, "Old strands are conserved, passed on half-and-half")
        self.wait(1)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert GENS[0] == [("old", "old")]
    for g, mols in enumerate(GENS):
        assert len(mols) == 2 ** g
    # every molecule after gen 0 is half old, half new
    for mols in GENS[1:]:
        assert all(sorted(m) == ["new", "old"] or m == ("new", "new") for m in mols)
    assert all(m.count("old") == 1 for m in GENS[1])
    # total old strands stays 2
    assert sum(m.count("old") for m in GENS[2]) == 2
    print("ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.