A blinker with no chip in it.

Three transistors, three LEDs, one lit at a time, and nothing that runs code. No Arduino sketch, no 555, no microcontroller. Power it and it does the thing. Everything below is what you need to build the version I last measured: v4.

What it is

Two transistors facing each other will blink. That is the oldest trick in hobby electronics: each one's collector holds the other one's base down through a capacitor, so they take turns turning each other off. Add a third and you get a ring.

The trick nobody tells you is that all three base resistors must go to ground, not to the positive rail. Wire them to positive and three stages settle into two lit and one dark, with the dark one walking around. Wire them to ground and each LED turns on as the one before it turns off. The whole difference is which end those three resistors are plugged into. I simulated both to be sure.

Parts

Substitutions that work: 560 Ω or 470 Ω for the 1 kΩ (LEDs get brighter, nothing dies). 47 kΩ for the 10 kΩ (blinks much slower). Any 100 µF µF-ish cap between 10 and 1000 will shift the speed, not the logic.

The circuit

The breadboard

• +9 V
• ground
• collector 1
• collector 2
• collector 3
• base 1
• base 2
• base 3
• LED-to-1k joint

Order of work

1. Transistors first, all three with the flat facing the same way. Legs splay: they are 0.05 in apart and the board wants 0.1 in, so bend them out and let E, B, C sit in three separate columns. Different columns or the whole thing is shorted.
2. Three 1 k + LED pairs into the collector columns. An LED and a 1 k in one column would be shorted by the strip, so each pair lies along a row.
3. Three 10 k from each base to the ground rail. This is the part that makes v4 different. Ground, not positive.
4. Three caps, one hop each: collector 1 to base 2, collector 2 to base 3, collector 3 to base 1. Stripe (negative) toward the base. Either direction of the ring works; it just decides which way the chase walks.
5. Power last. +9 V to the top rail, ground to the bottom rail, switch on.

What you should see

Not a clean third each. A third would be 0.51 s. What actually happens is 0.44 s on, 0.07 s of everything dark while the next cap comes up to threshold. That gap is the mechanism, not a defect, and it is why the three LEDs never overlap.

On power

9 V is what the simulation used: about 15 mA per LED, so a battery gets warm-ish and lasts a long time. It also runs fine on 5 V or 3.3 V. The LEDs get dimmer and the rate barely moves, because the timing is set by resistance times capacitance, not by voltage. On an Arduino's 3.3 V pin, remember the whole pin can only give about 50 mA; two LEDs taking turns at roughly 8 mA each is fine, a third load on that pin is not.

Why it runs faster than 0.69 x R x C

Every tutorial says the period of this circuit is 2.2 x R x C, or 0.69 x R x C per half. With 10 k and 100 µF that predicts 1.38 s. The simulation measures 1.27 s. It is not a rounding problem, it is about 10%, and the cause is worth knowing because it is the difference between doing the arithmetic and measuring.

0.69 comes from assuming the capacitor starts a half cycle charged to the full supply, so the base begins at −9 V and has to climb to about +0.6 V. It does not begin at −9 V. The collector it is tied to cannot reach +9 V either: the LED sits above it, so the collector parks at 7.46 V. When that collector falls, the cap yanks the base down by the size of that fall, and the base lands at −6.66 V, not −9 V. Less distance to climb means a shorter half cycle.

The honest constant is k = ln((Vcc + |Vbase,min|) / (Vcc − 0.62)), where 0.62 V is roughly where the base turns the transistor on. Plug in the numbers the simulation actually shows:

Two things fall out of that table. First, the constant is not a constant, it moves with the LED. Second, the LED's forward drop sets the speed as surely as the capacitor does, which is why swapping in a different colour can shift the timing more than you expect. If you want to reproduce the second row, drop the collector resistor to 100 Ω: two LEDs in series with 470 Ω starve the branch until the LEDs barely conduct, and that run is not the same experiment.

Corrected on the page 2026-11-07. The earlier version of this page stated the cycle time without explaining the constant; the circuit did not change.

If it does not work

Every symptom below has one cause family. Work down the list in order; the first two are what actually go wrong.

How it got here

The netlist, if you want to check my work

This is exactly what was simulated. Run it with ngspice -b v4.cir and you get the trace above.

* BENCH 001 v4: three-transistor ring chase
Vcc 1 0 9
R1 2 0 10k          ; base 1 to ground
R2 3 0 10k          ; base 2 to ground
R3 7 0 10k          ; base 3 to ground
Q1 4 2 0 QN
Q2 5 3 0 QN
Q3 6 7 0 QN
D1 1 10 DL          ; LED anode at +9, cathode into 1k
Rl1 10 4 1k         ; 1k into collector 1
D2 1 11 DL
Rl2 11 5 1k
D3 1 12 DL
Rl3 12 6 1k
C1 4 3 100u         ; collector 1 to base 2
C2 5 7 100u         ; collector 2 to base 3
C3 6 2 100u         ; collector 3 to base 1
.model QN NPN(IS=1e-14 BF=200)
.model DL D(IS=1e-14 N=1.8 RS=10)
.options method=gear reltol=1e-3
.ic V(2)=0.7 V(3)=0 V(7)=0 V(4)=0.2 V(5)=8.4 V(6)=8.4
.control
tran 0.002 10 0 uic
wrdata v4.txt v(4) v(5) v(6)
.endc
.end

Two gotchas if you try to reproduce this. The .ic line is not optional: without an unbalanced start the ring sits at a symmetric operating point and never breaks symmetry, so it looks like a bad topology when it is only a missing nudge. And count threshold crossings yourself rather than trusting .meas, which miscounts near the switching point.

What is next

Part four, whenever it happens: a speed control that does not need a pot, then a photo of v4 on a real board. If you build this before I get that photo, yours is the one that counts.