How a late-night Instagram post turned into an ongoing experiment in embedded systems, wearable technology, and a lot of trial and error.

The Inspiration

This project began when I came across a post from Instagram creator @danielidle showcasing a Digital Rain Ring inspired by The Matrix. The ring featured a tiny display embedded inside what appeared to be a signet ring, continuously playing the iconic Matrix code rain effect.

What immediately caught my attention wasn't just the animation—it was how seamlessly the technology disappeared into the design. When the display was off, it looked like a piece of jewelry. When it turned on, it felt like a prop straight out of a science fiction film.

What fascinated me most was that the ring wasn't trying to be a smartwatch, fitness tracker, or productivity device. It existed purely because it was cool.

I couldn't stop thinking about how it worked.

As someone who enjoys electronics, programming, photography, and making things, I found myself wondering:

Could I build something similar myself?

Not necessarily a replica, but a Matrix-inspired wearable that I could understand, customize, and use as a learning experience.

A few days later, I was ordering parts.

Choosing the Hardware

After exploring several options, I settled on an inexpensive development board:

AITRIP ESP32-C3 Development Board

ESP32-C3 microcontroller
Wi-Fi
Bluetooth 5.0
USB-C
0.42" OLED display

The board seemed almost too good to be true. It included a display and a powerful microcontroller in a package small enough that I could at least begin experimenting with wearable designs.

Of course, before creating anything interesting, I first had to figure out exactly what I had purchased.

First Contact

The first challenge was getting the display to respond.

After working through libraries, examples, and display drivers, I finally got a single word to appear:

Alive

That was it.

One word.

But after hours of troubleshooting, it felt like a major victory.

The display worked.

The board worked.

Now I could start building.

Discovering the Display

One of the first surprises came when I realized the display wasn't actually using the full screen area I expected.

Like many small OLEDs, only part of the display was truly visible through the front window.

This meant a lot of my early graphics looked misaligned or partially cut off.

Simple messages like:

Wake up,

Neo...

needed careful positioning to avoid disappearing off the edge of the screen.

What seemed like a simple display problem quickly turned into an exercise in pixel-level layout design.

Enter the Matrix

My first attempt at a Matrix effect was exactly what most people imagine:

1010101010

0101010101

1010101010

Technically it worked.

Visually it wasn't quite right.

After researching how the original effect was created for the films, I learned that the Matrix code wasn't just binary. It incorporated:

Japanese katakana characters
Numbers
Symbols
Letters

That discovery changed the direction of the project.

Instead of a binary display, I began creating custom glyphs inspired by the movie's digital rain.

Suddenly the animation started feeling much more authentic.

Building the Startup Sequence

Once the display could show characters reliably, I wanted the device to feel alive.

Instead of immediately jumping into the rain effect, I created a startup sequence inspired by the opening scene of The Matrix.

The display would slowly type:

Wake up,

Neo...

followed by:

The Matrix

has you...

then:

Follow the

white rabbit.

I added:

Variable typing speeds
Delays between characters
Screen transitions
A blinking cursor

The goal wasn't to display text.

The goal was to create anticipation.

The Rabbit Problem

I probably spent more time on the rabbit than I would like to admit.

After displaying:

Follow the white rabbit.

I wanted an actual rabbit to appear on the screen.

On paper this sounded simple.

In reality, a rabbit rendered on a 0.42-inch OLED can easily end up looking like a potato with ears.

Several designs were tested.

Some looked like mice.

Some looked like blobs.

Some looked like absolutely nothing recognizable.

Eventually I settled on a simplified rabbit silhouette that could be animated and understood at a glance.

That taught me an important lesson:

On tiny displays, readability matters more than detail.

Building a Portal

Once the rabbit existed, it needed somewhere to go.

I began experimenting with expanding circles and spiral animations.

The sequence evolved into:

Follow the white rabbit.

↓

Rabbit appears

↓

Rabbit hops across the screen

↓

Portal forms

↓

Rabbit enters portal

↓

Portal expands

↓

Reality changes

This became one of my favorite moments in the entire project because it transformed a simple display animation into a tiny story.

The Spiral Tunnel

To transition into the Matrix, I built a spiral tunnel effect using trigonometry.

Using functions such as:

sin()

cos()

I created particles that orbit and slowly collapse inward.

As they approach the center, they transform from simple pixels into Matrix-inspired symbols.

Watching the effect run for the first time felt surprisingly satisfying.

It was also one of the first times I felt like I was creating something unique rather than simply following tutorials.

Digital Rain

Eventually all roads lead back to the rain.

The current version uses:

Multiple independent columns
Random speeds
Custom glyphs
Numbers
Symbols

The result isn't a perfect recreation of the film, but it captures the feeling remarkably well considering the hardware limitations.

Every so often, the rain is interrupted by a message:

WAKE UP

before returning to its endless cascade of symbols.

Those interruptions make the device feel less like a screen saver and more like an object trying to communicate.

Unexpected Discoveries

One of the more surprising discoveries came while experimenting with color.

The OLED itself is monochrome, but I tested various lighting gels to see how they changed the appearance of the display.

A piece of Rosco #010 Yellow gel unexpectedly produced a green tint that looked remarkably close to the iconic Matrix aesthetic.

Sometimes the best effects come from accidental experiments.

Debugging Adventures

Not every part of the project went smoothly.

At one point I accidentally purchased filament refills instead of actual filament for my 3D printer.

Another time I spent hours troubleshooting upload failures only to discover the issue was related to communication speed during flashing.

More recently, I have been experimenting with the ESP32-C3's Wi-Fi capabilities.

The plan seemed simple:

Create a Wi-Fi network.

Connect a phone.

Control the ring remotely.

Reality had other plans.

The network appeared.

Then disappeared.

Then reappeared.

Then devices could connect but not reach the web interface.

Then the network vanished again.

Embedded development has a way of reminding you that the hardest problems are often the ones you least expect.

Where the Project Stands Today

At this point, the software is further along than the hardware.

I have:

Matrix-inspired startup sequences
Animated digital rain
Custom glyphs
Rabbit animations
Portal effects
Spiral tunnels
Early Wi-Fi experiments

What I do not yet have is a finished wearable ring.

The biggest challenge now is power.

The Next Challenge: Power

My next step is building a proper power system around the ESP32-C3.

I have been exploring options including:

Rechargeable coin cells
Small LiPo batteries
USB-C charging
Compact charging circuits

The challenge is finding a solution that is:

Safe
Rechargeable
Compact
Comfortable to wear
Capable of supplying enough current for the ESP32

Power isn't just an electrical problem.

It directly affects the enclosure design, heat management, weight, comfort, and overall appearance of the ring.

Designing the Enclosure

Eventually I want to move beyond a development board sitting on my desk.

The goal is to create an enclosure that:

Looks intentional
Protects the electronics
Manages heat
Supports charging
Feels like a wearable object

I don't want it to look like a development board strapped to my finger.

I want it to feel like a mysterious artifact pulled from a cyberpunk universe.

Why I'm Documenting This

One of the reasons I wanted to write about this project is that I am still figuring it out.

This isn't a tutorial written after everything worked.

This is a record of the process.

The successes.

The mistakes.

The experiments that failed.

The rabbit sprites that looked terrible.

The Wi-Fi networks that disappeared.

The accidental discoveries that ended up becoming some of my favorite features.

I have no idea exactly what the final version of this ring will look like.

But that's part of what makes the project exciting.

What's Next?

The immediate goals are:

Build a reliable power system
Design a wearable enclosure
Improve Wi-Fi functionality
Refine the rabbit animation
Add more hidden Matrix-inspired interactions
Transition from prototype to wearable device

For now, the project remains a work in progress.

The digital rain continues to fall.

Wake up, Neo...

The Matrix has you.