Arduino OLED name animation on SSD1306

By Ashish · Sep 29, 2026 · ~28 min · SSD1306, Name, Arduino

First time I tried to put my name on a 0.96" OLED, I used display.println("ASHISH"). It worked. It also looked like a calculator. Fine for debugging. Boring for a gift, a desk toy, or a project boot screen.

What people usually want is motion: letters that rain in, spiral together, or build from the sides. That means frames. Lots of tiny bitmaps playing one after another. This guide is the path I use now — from wiring checks to flash budget, then a free export so you are not typing hex at midnight.

What you will build

• A working I²C SSD1306 (or SH1106) wired to Arduino or ESP
• A name that appears as a multi-frame assemble animation
• A sketch that stores frames in PROGMEM and plays them with drawBitmap
• A sense of how many frames fit on Uno vs ESP32

Parts list

• Arduino Uno / Nano, or ESP32 / ESP8266 if you want more flash for longer animations
• SSD1306 128×64 I²C OLED (most cheap 0.96" boards)
• Four wires: GND, VCC, SDA, SCL
• Adafruit GFX + Adafruit SSD1306 libraries, or U8g2 if that is already your stack

If the screen stays black, run an I²C scanner before you blame the animation code. Address is usually 0x3C. Some boards sit on 0x3D. Full wiring walkthrough: Arduino OLED 128×64 I2C example. Blank screen checklist: SSD1306 blank screen fix.

Static text vs name animation

Static text is one call in setup(). Animation is a list of frames in flash, then a loop that clears, draws the next bitmap, and waits a few milliseconds.

On a 128×64 mono OLED, one full frame is 1024 bytes. Store it with PROGMEM so you do not eat RAM. Uno has 32 KB flash total. After libraries and your sketch, you might fit roughly 20–30 frames if you keep things tight. ESP32 laughs at that limit.

// Idea only — real arrays are much longer
const unsigned char frame0[] PROGMEM = { /* 1024 bytes */ };
const unsigned char frame1[] PROGMEM = { /* 1024 bytes */ };

void playOnce() {
  display.clearDisplay();
  display.drawBitmap(0, 0, frame0, 128, 64, SSD1306_WHITE);
  display.display();
  delay(40);
  display.clearDisplay();
  display.drawBitmap(0, 0, frame1, 128, 64, SSD1306_WHITE);
  display.display();
  delay(40);
}

Writing those hex arrays by hand for a name is a bad afternoon. I did it once for a four-letter word and swore I would never do it again.

Why println is not enough for a “name intro”

setTextSize and print are great for sensor values. They draw font glyphs from the library. They do not give you particle rain, spiral join, or a logo that fills in. Those effects need the final shape as pixels, then intermediate frames that move those pixels into place.

Hardware scroll (startscrollleft) only slides whatever is already on the glass. Useful for tickers. Not the same as a designed intro. I wrote a separate comparison here: scrolling text vs name animation.

Faster way: type the name, export frames

I built OLED Name Assemble for this job. You type a name (multiline works), pick a style like Outside Random or Wave Ride, watch the 128×64 mockup, then hit Get the Code.

1. Open Name Assemble in the browser
2. Type the name (keep it short on Uno)
3. Click a style — preview updates on the board mockup
4. Tweak speed / font size if the letters look cramped
5. Get the Code → Adafruit SSD1306, SH110X, U8g2, or MicroPython
6. Select your board and I²C address in the header, then upload

The export already includes PROGMEM frames and a playback loop. You still match library and address so the sketch fits your hardware.

Install the libraries (Arduino IDE)

1. Open Library Manager
2. Install Adafruit GFX Library
3. Install Adafruit SSD1306 (it will pull Wire dependencies)
4. If you use SH1106 modules that need Adafruit SH110X, install that too and pick SH110X in export

On Arduino IDE 2.x this is Tools → Manage Libraries. On older IDE 1.x it is Sketch → Include Library → Manage Libraries. Restart the IDE if examples do not show up immediately.

Step 0 — prove the OLED works with a static name

Before any animation, flash this. If “ASHISH” does not appear, fix wiring / address first. Do not debug frames on a dead bus.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    for (;;); // hang if OLED not found
  }
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(2);
  display.setCursor(16, 24);
  display.print(F("ASHISH"));
  display.display();
}

void loop() {}

Change the string, address, and cursor until it looks centered. That baseline confidence matters. Only then move to multi-frame playback.

What a frame loop looks like after export

Name Assemble exports something in this shape (arrays shortened here on purpose):

const unsigned char frame_0[] PROGMEM = {
  0x00, 0x00, /* ... 1024 bytes total for 128x64 ... */
};
const unsigned char frame_1[] PROGMEM = {
  0x00, 0x00, /* ... */
};

const unsigned char* const frames[] PROGMEM = {
  frame_0, frame_1 /*, ... */
};
const uint16_t FRAME_COUNT = 2;
const uint16_t FRAME_DELAY_MS = 40;

void playNameIntro() {
  for (uint16_t i = 0; i < FRAME_COUNT; i++) {
    display.clearDisplay();
    display.drawBitmap(0, 0, (const unsigned char*)pgm_read_ptr(&frames[i]), 128, 64, SSD1306_WHITE);
    display.display();
    delay(FRAME_DELAY_MS);
  }
}

Exact pointer macros can differ slightly by export target. Trust the full sketch from Get the Code — the idea is always: store frames in flash, draw one, wait, next frame.

Workshop notes from teaching this

In WitBlox-style sessions I learned students fail in the same three places:

1. They skip Hello World and jump straight to a 40-frame export on Uno → upload fails or board resets
2. They leave the name at huge font size so letters clip, then blame the style
3. They wire SDA/SCL swapped and spend an hour “fixing” the animation

Rule I enforce now: static name on screen → then Name Assemble → then upload. Takes longer on paper. Saves the whole lab period in practice.

Troubleshooting lab

Checklist before you call it done

• Static name sketch works on this exact board + OLED
• Name Assemble preview matches what you want
• Export library matches installed libraries
• Sketch size fits with margin (watch IDE memory bar)
• Intro plays once in setup(), then your real UI runs

Font and size tips that save re-uploads

• Long names look better at smaller font size, or split across two lines.
• Impact and Comic Sans fill the screen fast. IBM Plex Mono stays readable on 128×64.
• If letters clip the edges, drop size before you change style.
• SH1106 panels need a 2-pixel column offset. Pick SH1106 in the tool so export handles it.

Uno flash budget (so your sketch actually uploads)

Rough math I use when someone asks “will this fit?”:

• 1 full 128×64 frame ≈ 1024 bytes PROGMEM
• Adafruit SSD1306 + GFX already take a chunk of flash
• Leave headroom for WiFi stacks on ESP — they are heavy too, but RAM/flash is larger

If the IDE says the sketch is too big, shorten the name, pick a simpler style, or move to ESP32. Deeper dive: Uno OLED memory limits.

Where to put the animation in your project

void setup() {
  // Wire + display.begin(...)
  playNameIntro();   // exported loop, once
  drawHomeScreen();  // your normal UI
}

void loop() {
  // sensors, menus, etc.
}

Play the intro once at boot. Looping forever looks cool for a desk ornament and annoying for a tool. For a dedicated name badge build, see DIY OLED name badge.

Live preview while you tweak (optional)

If you are on Chrome/Edge, the maker can stream frames over USB WebSerial or WiFi to ESP boards. That saves the upload-wait-upload cycle while you hunt for a font size that fits. Guides: WebSerial live connect, WiFi wireless preview.

Related searches: arduino oled name animation · ssd1306 name animation · oled text animation arduino · display name on oled · adafruit ssd1306 text animation

Frequently asked questions

Worked example: center a four-letter name, then spend the frames

Prove the glass with a static string before any assemble export. On a 128×64 SSD1306, size-2 glyphs are 12 by 16 pixels. Four letters such as MIRA are 48 pixels wide and 16 tall. Center them with integer math: x = (128 − 48) / 2 = 40, y = (64 − 16) / 2 = 24. Address stays 0x3C unless a scanner says 0x3D.

display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.setCursor(40, 24);
display.print(F("MIRA"));
display.display();

Uno wiring is SDA on A4 and SCL on A5. ESP32 is GPIO 21 and GPIO 22. ESP8266 NodeMCU is D2 and D1. If this one word is clipped, rotated, or missing, stop. An animation export will fail the same way.

When the static name is centered, open Name Assemble, type the same four letters, and pick a short style. Count frames before you upload. Each 128×64 frame is 1024 bytes in PROGMEM. Twelve frames are about 12 KB of pictures. That plus Adafruit GFX and SSD1306 still fits a typical Uno if you are not also storing a second animation. Forty frames are about 40 KB and will not fit a Uno no matter how the letters look in the browser. ESP32 is the board for the long particle styles.

Play the exported loop once from setup(), then leave the last frame up, or clear and print the centered static name as the resting screen. A desk badge can loop. A sensor box should not replay the intro every time loop() runs. On SH1106 modules, export with that controller so the assembler output starts at column 2 of the 132-wide buffer. Adding 2 yourself on top of an SH1106 export shifts the name twice.

If the letters look cramped in the mockup, drop font size before you change style. Size 2 is the largest that still leaves a margin for a four-letter word. A longer name belongs on two lines or at size 1, or the assemble animation will spend frames sliding clipped pixels that were never going to fit.

Troubleshooting a name that uploads but looks wrong

• Upload says the sketch is too large. Frame count times 1024, plus libraries, exceeds flash. Shorter style, shorter name, or ESP32.
• Name sits in the corner in the animation but was centered in the static test. The export uses its own layout. Raise size or alignment in Name Assemble and export again. Do not expect setCursor(40, 24) to move bitmap frames.
• Snow, then a reset. A frame pointer was copied into RAM or PROGMEM was stripped while cleaning the sketch. Use the export’s playback loop unchanged.
• Two-pixel gap on the left of every frame. SH1106 panel, SSD1306 export. Switch the controller and export again. Wiring and 0x3C are already fine if you can see the shift.
• Intro plays, then the screen goes black. loop() calls clearDisplay without drawing the resting name. After playNameIntro(), draw the static string or the last frame and call display() once.
• Browser preview is smooth, hardware is half speed. I²C has to move 1024 bytes per frame. Increase the frame delay in the exported constant if the name stutters. The pixels are already correct.

Related

• SSD1306 scrolling text vs name animation
• DIY OLED name badge with Arduino
• How to create SSD1306 OLED animations
• Name Assemble tool
• About this project · Contact