Chemistry · Introductory

VSEPR molecular shapes

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

VSEPR theory predicts the three-dimensional shape of a molecule by assuming that regions of electron density around a central atom repel each other and spread as far apart as possible. The number of electron domains sets the electron geometry, and the number of lone pairs then determines the molecular shape. Shape in turn influences bond angles and polarity.

Intuition

Imagine tying balloons together at their knots. Two balloons point in opposite directions, three spread flat like a triangle, four form a tetrahedron. Electron domains (bonding pairs, lone pairs, or multiple bonds counted as one domain) behave like those balloons: negatively charged clouds that push each other away. Lone pairs are fatter balloons because they are held by only one nucleus, so they take up more room and squeeze the bonded atoms closer together. We name the shape by looking only at where the atoms are, not the lone pairs.

Key equations

Steric number=(atoms bonded to central atom)+(lone pairs on central atom)
(1)

Counts electron domains; each single, double or triple bond to one atom counts as one domain.

Lone pairs=V−B−Cadj2
(2)

Approximate count for a neutral central atom: V valence electrons minus electrons used in bonds (B = number of bond-electrons the central atom contributes, one per single bond equivalent); adjust for charge.

Repulsion: LP-LP>LP-BP>BP-BP
(3)

Order of repulsive strength, explaining why lone pairs compress bond angles.

Derivation

  1. Step 1: Draw the Lewis structure and identify the central atom.
  2. Step 2: Count electron domains around it (bonded atoms plus lone pairs).
  3. Step 3: Arrange domains to maximise separation: 2 linear (180°), 3 trigonal planar (120°), 4 tetrahedral (109.5°), 5 trigonal bipyramidal (90°, 120°), 6 octahedral (90°).
  4. Step 4: Place lone pairs first in positions with most room (equatorial in trigonal bipyramidal).
  5. Step 5: Name the molecular shape from the atoms only: e.g. 4 domains with 1 lone pair is trigonal pyramidal; with 2 lone pairs is bent.
  6. Step 6: Adjust angles slightly downward because lone pairs repel more strongly.

Worked example

Problem

Predict the shape and approximate bond angle of water, H2O.

  1. Oxygen has 6 valence electrons and forms 2 single bonds to hydrogen.
  2. Remaining electrons: 6 - 2 = 4, which is 2 lone pairs.
  3. Steric number = 2 bonded atoms + 2 lone pairs = 4, so electron geometry is tetrahedral.
  4. Two of the four positions are lone pairs, so the atoms form a bent shape.
  5. Lone pairs squeeze the H-O-H angle below 109.5°.

Answer Bent, with an H-O-H angle of about 104.5°.

Common mistakes

  • Confusing electron geometry with molecular shape; water is tetrahedral in electron geometry but bent in shape.
  • Counting a double or triple bond as two or three domains instead of one.
  • Forgetting to include lone pairs on the central atom.
  • Assuming bond angles are exactly the ideal values even when lone pairs are present.
  • Assuming any molecule with polar bonds is polar, ignoring symmetry (CO2 is nonpolar).

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(160 lines)
from manim import *
from blocks import *
import numpy as np
import sys


def get_vsepr_coords(shape_name):
    """
    Returns a list of (label, position) tuples for a specific VSEPR shape.
    Positions are normalized to fit in a unit sphere roughly.
    """
    if shape_name == "linear":
        # 180 degrees
        return [("X", np.array([-2.0, 0, 0])), ("A", np.array([0, 0, 0])), ("X", np.array([2.0, 0, 0]))]
    elif shape_name == "trigonal_planar":
        # 120 degrees in XY plane
        angles = [0, 2 * np.pi / 3, 4 * np.pi / 3]
        r = 2.0
        coords = [("A", np.array([0, 0, 0]))]
        for a in angles:
            coords.append(("X", np.array([r * np.cos(a), r * np.sin(a), 0])))
        return coords
    elif shape_name == "tetrahedral":
        # Regular tetrahedron centered at origin
        # Vertices of a cube: (1,1,1), (1,-1,-1), (-1,1,-1), (-1,-1,1)
        # Normalized and scaled
        verts = [
            np.array([1, 1, 1]),
            np.array([1, -1, -1]),
            np.array([-1, 1, -1]),
            np.array([-1, -1, 1])
        ]
        norm = np.linalg.norm(verts[0])
        scaled_verts = [v * (2.0 / norm) for v in verts]
        coords = [("A", np.array([0, 0, 0]))]
        for i, v in enumerate(scaled_verts):
            coords.append(("X", v))
        return coords
    elif shape_name == "octahedral":
        # Axes aligned
        r = 2.0
        coords = [("A", np.array([0, 0, 0]))]
        coords.append(("X", np.array([r, 0, 0])))
        coords.append(("X", np.array([-r, 0, 0])))
        coords.append(("X", np.array([0, r, 0])))
        coords.append(("X", np.array([0, -r, 0])))
        coords.append(("X", np.array([0, 0, r])))
        coords.append(("X", np.array([0, 0, -r])))
        return coords
    return []


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#111111"
        
        shapes = ["linear", "trigonal_planar", "tetrahedral", "octahedral"]
        shape_names = ["Linear", "Trigonal Planar", "Tetrahedral", "Octahedral"]
        
        # Title
        TitleCard(self, "VSEPR Shapes", "Electron Domain Geometry")
        
        for i, shape in enumerate(shapes):
            coords = get_vsepr_coords(shape)
            if not coords:
                continue
            
            # Clear previous
            self.clear()
            
            # Re-add title small at top
            title_text = Text(shape_names[i], font_size=40, color=C_ACCENT)
            title_text.to_edge(UP, buff=0.5)
            self.add(title_text)
            
            # Draw Central Atom
            central_atom = Circle(radius=0.3, color=C_MAIN, fill_color=C_MAIN, fill_opacity=1)
            central_atom.move_to(coords[1][1])
            self.play(Create(central_atom))
            
            # Draw Bonds and Terminal Atoms
            bonds = VGroup()
            atoms = VGroup()
            
            for label, pos in coords:
                if label == "A":
                    continue
                
                start_pos = coords[1][1]
                end_pos = pos
                
                bond = Line(start_pos, end_pos, color=C_DIM, stroke_width=4)
                atom = Circle(radius=0.2, color=C_ACCENT, fill_color=C_ACCENT, fill_opacity=1)
                atom.move_to(end_pos)
                
                self.play(Create(bond), Create(atom), run_time=0.5)
                bonds.add(bond)
                atoms.add(atom)
            
            # Add labels
            labels = VGroup()
            for label, pos in coords:
                if label == "A":
                    continue
                t = Text(label, font_size=24, color=WHITE)
                t.move_to(pos)
                labels.add(t)
            
            self.play(FadeIn(labels))
            
            # Caption
            caption = f"{shape_names[i]} Geometry"
            StepCaption(self, caption)
            
            self.wait(1.5)
            
            # Fade out for next shape
            self.play(FadeOut(bonds), FadeOut(atoms), FadeOut(labels), FadeOut(central_atom), FadeOut(title_text))
        
        StepCaption(self, "Shape determined by repulsion between electron domains")
        self.wait(2)


if __name__ == "__main__" and "--selftest" in sys.argv:
    # Test linear
    coords = get_vsepr_coords("linear")
    assert len(coords) == 3
    assert np.allclose(coords[0][1], [-2.0, 0, 0])
    assert np.allclose(coords[2][1], [2.0, 0, 0])
    
    # Test tetrahedral dot product
    coords = get_vsepr_coords("tetrahedral")
    # Get the 4 X positions
    x_positions = [c[1] for c in coords if c[0] == "X"]
    assert len(x_positions) == 4
    
    # Check angles between any two vectors from center (0,0,0)
    # cos(theta) = -1/3 for tetrahedron
    for i in range(len(x_positions)):
        for j in range(i + 1, len(x_positions)):
            v1 = x_positions[i]
            v2 = x_positions[j]
            dot = np.dot(v1, v2)
            norm1 = np.linalg.norm(v1)
            norm2 = np.linalg.norm(v2)
            cos_theta = dot / (norm1 * norm2)
            assert abs(cos_theta - (-1/3)) < 1e-6, f"Tetrahedral angle cos is {cos_theta}, expected -1/3"
    
    # Test octahedral
    coords = get_vsepr_coords("octahedral")
    x_positions = [c[1] for c in coords if c[0] == "X"]
    assert len(x_positions) == 6
    
    # Check that opposite vectors are 180 degrees (dot product -1)
    # Pairs: (0,3), (1,4), (2,5) roughly if ordered x,-x, y,-y, z,-z
    # Let's just check norm consistency
    for v in x_positions:
        assert abs(np.linalg.norm(v) - 2.0) < 1e-6
    
    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.