Infinite Pi Clock: a Desk Gadget That Blends Time With Endless Math

Ever notice how a regular clock just keeps looping through the same hours, minutes, and seconds? It’s predictable. Comforting, even. But π (pi) is the complete opposite — an infinite, non-repeating decimal that goes on forever without any pattern.

This project merges those two concepts into one clean, minimalist device: a clock that shows accurate real-world time while slowly scrolling through the never-ending digits of π.

The result is a small, always-running desktop piece that’s part timekeeper, part mathematical art. It’s simple enough for beginners, looks surprisingly polished, and quietly reminds you that while time cycles, mathematics never stops.

Why Build This?

1. Super straightforward to assemble
2. Clean, uncluttered display
3. Educational and mesmerizing to watch
4. Runs 24/7 with no interaction needed

How It Works

The Infinite Pi Clock has three main components working together:

1. Accurate Timekeeping — A DS3231 Real-Time Clock (RTC) module tracks time precisely, even when the power is off.
2. Pi Digit Stream — A pre-stored sequence of π digits acts as an endless data feed that the display advances through over time.
3. Visual Output — A compact 128×64 OLED screen displays the current time (in 24-hour format), the familiar start of π (3.14159…), the advancing digits, and a counter showing how deep into the sequence you’ve gone.

The whole thing runs continuously, giving you a living visualization of infinity in motion.

Parts List

1. Arduino UNO or Nano
2. ELEGOO 0.96" OLED Display (SSD1306, I2C, 128×64)
3. DS3231 RTC module
4. Jumper wires
5. Breadboard (optional but recommended for prototyping)
6. USB cable for uploading code

Both the OLED and RTC communicate over I2C, so they happily share the same two pins.

Here’s the connection table:

ComponentPinArduino Pin

OLED VCC - 5V

OLED GND - GND

OLED SDA - A4

OLED SCL - A5

RTC VCC - 5V

RTC GND -GND

RTC SDA - A4

RTC SCL - A5

Pro tip: Keep your wiring tidy. It makes troubleshooting easier and the final build look much nicer.

Open the Arduino IDE and install these three libraries via the Library Manager:

1. Adafruit SSD1306
2. Adafruit GFX
3. RTClib

Before the first run, you need to tell the RTC what time it is.

In the code, temporarily uncomment this line:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

Upload the final code to your Arduino. Once powered on, the display should show:

1. Current time in 24-hour format (with a blinking colon)
2. “PI” label at the top
3. The starting digits: 3.14159…
4. Continuously advancing π digits
5. A live counter showing your progress through the sequence

The layout is intentionally clean and balanced:

1. Yellow top band: “PI” label
2. Center area: Large, easy-to-read current time
3. Bottom section: Scrolling π digits + progress counter

Everything is positioned to avoid visual clutter while staying highly readable.

Instead of calculating π on the fly (which would be slow and heavy), the project uses a stored array of digits and simply walks through them step by step.

This method keeps everything smooth, responsive, and capable of running forever without bogging down the Arduino. The counter tracks how many digits deep you are.

How Long Until It Loops?

The counter uses an unsigned long, so it can count up to 4,294,967,295 steps before rolling over.

With the display advancing roughly every 0.4 seconds:

1. ~2.5 updates per second
2. ~9,000 updates per hour
3. ~216,000 updates per day

That means it takes about 20 days of continuous running to hit the maximum and reset. When it does reset, the clock just keeps going — a nice little nod to the infinite nature of π.

This basic version is deliberately minimal, but the concept scales beautifully.

Bigger Displays Swap the small OLED for:

1. A larger OLED or LCD
2. A color TFT screen
3. Or even connect it to a Raspberry Pi and use a full monitor

With more screen real estate, you could show hundreds of digits at once, add smooth scrolling, or create animated π visualizations.

Better Enclosures Move beyond the breadboard with:

1. A 3D-printed case
2. Laser-cut acrylic box
3. Round “clock face” housing
4. Wall-mountable design

A proper enclosure instantly makes the project feel like a finished product instead of a prototype.

When everything is working, you should see:

1. Time updating every minute
2. Smoothly advancing π digits
3. Steady counter increase
4. No freezing or glitches

Common Issues & Fixes:

1. Split-color display problems (yellow/blue OLED): Keep large text entirely within one color region.
2. Nothing showing on OLED: Double-check the I2C address (usually 0x3C), wiring, and that the libraries are installed.
3. Glitchy behavior or crashes: Avoid heavy use of String objects on the Arduino — stick with character arrays.
4. Wrong time: Make sure you set the RTC properly and that the backup battery is in place.

Future Upgrade Ideas

1. Add a 3D-printed or laser-cut enclosure
2. Use a larger screen for more π digits
3. Add ambient light-based brightness control
4. Implement multiple display modes
5. Upgrade to an ESP32 for automatic WiFi time synchronization
6. Store even more π digits

Final Thoughts

The Infinite Pi Clock is a fun contrast between the predictable cycle of time and the endless, pattern-free world of π. It’s a small, easy build that creates something surprisingly thoughtful — a desktop reminder that while days repeat, mathematics stretches on forever.

Build it, let it run, and enjoy watching infinity unfold in real time.

Safety Notes

1. Only use low-voltage USB power (5V)
2. Double-check all connections before powering on
3. Be careful not to create shorts on the breadboard

If you make one, I’d love to hear how it turns out — and whether you end up scaling it up into something even bigger!