How Touchscreens Work

The touchscreen on a modern phone doesn’t know you touched it. It knows that a small amount of electrical charge disappeared from a specific point on a grid of wires embedded under the glass, and it infers, correctly almost every time, that a finger must have caused it. That inference is the entire trick behind projected-capacitive touch (often abbreviated PCAP), the technology that replaced resistive touchscreens industry-wide after the 2007 iPhone, and understanding it explains three things people run into constantly and rarely think about: why a bare finger works but a cotton glove doesn’t, why a wet screen produces phantom taps, and how a phone can track ten simultaneous fingers without any part of the screen physically moving.

The Grid Under the Glass

A projected-capacitive touch panel is built from a fine mesh of transparent conductive electrodes, almost always etched from indium tin oxide (ITO), sandwiched into layers arranged as rows running one direction and columns running perpendicular to them, separated by a thin insulating layer. “Projected” refers to the fact that the sensing electric field projects up through the cover glass rather than sitting directly on an exposed conductive surface, which is what lets manufacturers put a solid, undamageable sheet of glass — the same glass a Gorilla Glass-style cover uses — on top of the actual sensing layer with no loss of function.

The electrode pattern itself is rarely simple straight lines; most production panels etch the ITO into a repeating diamond lattice, because interlocking diamond shapes maximize the electrode surface area at each row-column crossing point, which is exactly where the measurement happens and where signal strength matters most.

        Column electrodes (etched ITO, under glass)
        ┆       ┆       ┆       ┆       ┆
   ┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄  ← row electrode
        ┆   ▲   ┆       ┆       ┆
   ┄┄┄┄◇┄┄┄┼┄◇┄┄┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄┄┄◇┄┄┄┄
        ┆   │   ┆       ┆       ┆
             touch here reduces the
             mutual capacitance formed
             at THIS row/column crossing

At every single crossing point, the row electrode and the column electrode form a tiny capacitor — two conductors separated by an insulator, which is the textbook definition of a capacitor, at a scale of femtofarads. When nothing is touching the screen, the controller chip already knows the baseline capacitance value at every one of these crossings, often numbering in the thousands on a phone-sized panel.

Mutual Capacitance: Why It Sees Position, Not Just Presence

There are two distinct ways a capacitive panel can be wired, and the difference between them explains almost everything about multi-touch capability.

Self-capacitance treats every row and every column as an independent sensor, each measured against system ground. The controller scans each electrode individually and looks for an increase in the current it draws, because a grounded human finger near an electrode adds capacitance to that electrode’s path to ground. This is simple and produces a strong, easy-to-detect signal, but it has a structural blind spot: if two fingers touch simultaneously at coordinates (X1, Y1) and (X2, Y2), the self-capacitance controller sees “column X1 and X2 activated” and “row Y1 and Y2 activated” as two separate, unlinked facts. It cannot tell whether the real touches are at (X1,Y1) and (X2,Y2), or at the swapped, equally consistent pair (X1,Y2) and (X2,Y1) — a well-known failure called ghost touching, and it’s the reason pure self-capacitance panels are typically limited to reliably resolving two touches at once, at best.

Mutual capacitance wires things differently: instead of measuring each electrode against ground, the controller drives a known voltage pulse onto one row electrode at a time and measures the resulting signal on every column electrode simultaneously. What’s actually being measured is the capacitive coupling between that specific row and each specific column — a genuinely local property of the row/column crossing, not a property of the row or column alone. A finger near a crossing point diverts part of the electric field between that row and that column to ground, which the controller reads as a measurable drop in mutual capacitance at that exact intersection, and only that intersection. Because every crossing is measured as its own independent value, the ambiguity that breaks self-capacitance simply doesn’t exist — touches at (X1,Y1) and (X2,Y2) show up as depressed capacitance values at exactly those two crossings and nowhere else, with no ghost pairing possible. This is the mechanism that makes ten-finger multi-touch a solved, unambiguous problem rather than a heuristic guess, and it’s why virtually every modern phone, tablet, and touch laptop uses mutual capacitance despite it being more circuit-complex than self-capacitance.

The Scan Loop

A touch controller isn’t watching the grid continuously in an analog sense — it’s running a fast digital scan loop, driving one row electrode with a known excitation signal, reading the induced signal on every column electrode in parallel through an analog-to-digital converter, then moving to the next row and repeating, cycling through the entire row set many times per second (commercial controllers commonly scan the full grid at rates well into the hundreds of hertz to keep touch-to-response latency low enough that dragging a finger feels physically continuous rather than laggy).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Simplified mutual-capacitance scan loop (illustrative, not production code)
def scan_frame(rows, cols, baseline):
    frame = {}
    for row in rows:
        drive_pulse(row)                      # excite one row electrode
        readings = read_all_columns(cols)      # ADC sample every column at once
        for col, raw_value in zip(cols, readings):
            delta = baseline[(row, col)] - raw_value
            frame[(row, col)] = delta          # positive delta = capacitance dropped
    return frame

def find_touches(frame, threshold):
    candidates = [(r, c) for (r, c), d in frame.items() if d > threshold]
    return cluster_adjacent_points(candidates)  # merge neighboring hits into one touch

Two things happen after the raw scan: first, adjacent crossing points that all show a depressed capacitance get clustered into a single touch event, because a fingertip is wider than the electrode pitch and always perturbs several neighboring crossings at once — the controller then interpolates a sub-pixel centroid from the weighted signal strengths across that cluster, which is how a touchscreen with, say, a 4mm electrode pitch can still report touch position accurate to well under a millimeter. Second, the controller runs the result through noise and interference filtering, because switching-mode power supplies, nearby USB charging, and even the display’s own refresh circuitry inject electrical noise directly into the same electrode grid being used for sensing.

Why a Bare Finger Works and a Glove Doesn’t

The entire sensing mechanism depends on one physical fact: a capacitor’s value depends on the dielectric and conductive properties of what’s near its field, and a human body is a large, grounded, electrically conductive mass, mostly by virtue of being full of ionic fluid. When a bare finger approaches the grid, it doesn’t need to touch the ITO layer directly (it’s under a layer of glass anyway) — it just needs to be close enough for its conductive mass to divert part of the electric field between a row and column, and it does that because skin is a reasonably good conductor at the frequencies involved.

An ordinary glove — cotton, leather, wool, standard synthetic fabric — is an electrical insulator. It sits between the finger and the glass and simply blocks the coupling; the finger is still there, still conductive, but it’s now too far from the field and separated by non-conductive material, so no meaningful capacitance change reaches the electrode grid. This is a direct, unavoidable consequence of the sensing principle, not a software limitation — which is also why the fix, when there is one, is a hardware fix: touchscreen-compatible gloves work by weaving a conductive thread (commonly a silver- or copper-coated fiber) into the fingertip fabric, giving the glove itself enough conductivity to carry the coupling through to the finger underneath.

Some manufacturers add a software-side accommodation — a “glove mode” that raises the controller’s sensitivity threshold so it registers the smaller capacitance change a gloved touch still produces — but this trades a real cost for the convenience: turning up sensitivity to catch weak, glove-attenuated signals also makes the panel more prone to false triggers from other small capacitance disturbances, which is exactly the same trade-off at the root of the water problem below.

Why Water Causes Ghost Touches

Water is also an electrical conductor, thanks to dissolved minerals and ions, and a wet screen — or a wet finger — presents the same basic electrical signature to the sensing grid that an actual touch does: a conductive mass near the field, diverting capacitance. A single stationary droplet sitting on the glass can register as a persistent phantom touch; a thin film of water spreading across the surface during rain, or a screen protector with trapped moisture underneath, can produce a moving smear of false touch points that the controller has no principled way to distinguish from a real finger drag, because at the level of raw capacitance data, they look the same.

The industry’s fix isn’t better hardware — it’s algorithmic. Modern touch controllers run water-rejection heuristics that use shape, size, and behavioral signatures to discriminate a finger from water: a real fingertip produces a touch signature of fairly consistent size and a compact, roughly circular cluster shape, while water droplets tend to produce irregular, often elongated or multiply-connected blob shapes that spread and merge unpredictably across neighboring crossings as the liquid moves. Some controllers also cross-reference signal shape against known conductivity and edge-sharpness profiles, and increasingly rely on grip and palm-rejection logic borrowed from the same signal-processing pipeline, to decide which candidate clusters get reported to the OS as touches and which get suppressed as probable water. This is genuinely imperfect — it’s the reason “swipe screen dry before using it in the rain” remains standard advice even on flagship phones marketed as having dedicated wet-finger tracking modes, because the underlying physics gives water and finger the same fundamental fingerprint, and every rejection algorithm is a statistical judgment call, not a hard physical distinction.

Resistive: The Technology It Replaced

Capacitive sensing wasn’t the first touchscreen technology to reach mass production, and understanding why it displaced the older approach clarifies what capacitive sensing actually buys you. Resistive touchscreens, commercialized starting in the 1970s largely through Dr. Sam Hurst’s work at Elographics (including the first ITO-based transparent touch panel in 1974), use two flexible conductive layers held apart by a thin air gap or spacer dots. Pressing anywhere on the surface physically bends the top layer down until it contacts the bottom layer, and the device measures the voltage divider that forms at the contact point to compute an X-Y coordinate.

Resistive dominated mobile devices through the mid-2000s specifically because it tolerated a stylus or a gloved finger, which mattered on early PDAs and industrial handhelds. The 2007 iPhone’s use of projected-capacitive sensing was the inflection point for consumer devices: it traded stylus/glove compatibility for multi-touch gestures (pinch-to-zoom being the signature demonstration), a brighter and clearer display stack, and a sealed glass surface with no moving parts to wear out — and the smartphone industry followed almost entirely in that direction within a few years, leaving resistive touch mostly to industrial, medical, and glove-mandatory environments where capacitive’s limitations are actual dealbreakers rather than inconveniences.

Honest Trade-offs

• Conductive-object dependency is fundamental, not fixable in software. No firmware update makes a capacitive panel sense a non-conductive stylus or a thick insulating glove; any accessory that claims to work either embeds a conductive tip/fiber or it’s exploiting the sensitivity threshold in a way that degrades accuracy elsewhere.
• Water rejection is a statistical trade-off, not a solved problem. Raising sensitivity to catch light, fast touches during rain necessarily raises the false-positive rate for stray droplets; every vendor’s “swim mode” or “wet mode” is tuning a knob between missed real touches and phantom water touches, not eliminating the ambiguity.
• Electrode pitch sets a real resolution floor. Sub-pixel touch accuracy comes from interpolating across a cluster of activated crossings, which works well for a fingertip (wide, soft contact) but is part of why capacitive touch was never well-suited to fine stylus work without dedicated active-stylus hardware that communicates directly with the controller rather than relying on passive capacitive coupling.
• Noise immunity costs power and complexity. Scanning the full grid hundreds of times per second while filtering out switching-power-supply and display-refresh interference requires continuously active analog front-end circuitry, which is a nontrivial and largely invisible contributor to a touch device’s idle power draw.

Verdict

Projected-capacitive touch doesn’t measure touch at all in any direct sense — it measures a change in an electric field between a grid of etched electrodes, and treats a localized drop in that field as evidence that something conductive, almost always a finger, is nearby. Mutual capacitance sensing turned that trick into an unambiguous, per-intersection measurement, which is the specific innovation that made real multi-touch gestures possible and is why the technology displaced resistive touch across the entire consumer electronics industry after 2007. Every well-known quirk of the technology — gloves failing, water producing ghost touches, the reason capacitive styluses need a conductive tip — falls directly out of that one design decision: the sensor is watching for conductivity, not pressure, and it has no way to know the difference between a finger and anything else that happens to look electrically similar.

Sources

• Densitron — Projected Capacitive Touch Sensor
• iQS Directory — Types, Principles and Advantages of Capacitive Touch Screens
• Nelson Miller Group — Comparing the 2 Types of Projected Capacitance Touchscreen Technology
• Hindawi — Concurrent Driving Method with Fast Scan Rate for Large Mutual Capacitance Touch Screens
• PMC — Mutual Capacitive Sensing Touch Screen Controller for Ultrathin Display with Extended Signal Passband
• Nelson Miller — Why Can’t I Wear Gloves With My Touchscreen?
• Fieldscale — Why Don’t Touch Screens Work With Gloves On?
• Orient Display — A Brief History of Capacitive Touchscreen Technology
• AllPCB — How the Touchscreen Was Invented