OLED logo splash screen on Arduino

By Ashish · Sep 29, 2026 · ~25 min · Import, SSD1306

Static logos are easy. Drop a PNG into image2cpp, paste the array, call drawBitmap once. A splash that builds the logo is different. You need every lit pixel to travel somehow, then hold the final image long enough that people can read it.

I used to spit GIFs into frames by hand. Now I import once and let an assemble style do the motion. This guide covers artwork prep, the import workflow, flash budget, and where the splash sits in a real sketch.

Still image vs splash animation

If you only need a still image, the image to byte array guide is enough. Keep reading when you want motion into that logo.

Prepare the logo

• Work at 128×64 or smaller. Upscaling mush looks worse than a clean small mark.
• High contrast. Gray soft logos die on 1-bit OLEDs.
• Prefer PNG with a transparent or flat background.
• Skip tiny serifs. They vanish after thresholding.
• Filled shapes assemble better than hollow outlines.

I often redraw a brand mark as a 1-bit silhouette in a pixel editor before import. Ten minutes of cleanup saves twenty minutes of threshold fighting.

Artwork checklist before you open the importer

1. Export or redraw at 128×64 (or centered on a 128×64 canvas)
2. Convert soft grays to pure black/white in any editor
3. Remove backgrounds that leave speckles
4. Save PNG
5. Only then import into Name Assemble

If you import a busy photo logo “as is,” threshold becomes a lottery. Silhouette first. Fancy later.

Still image path vs splash path (do not mix them up)

How I test a splash before soldering a product

1. Import + style on desktop mockup
2. WebSerial preview on a spare SSD1306 if available
3. Export and check IDE memory bar on the target board
4. Flash, time the intro with a phone stopwatch — aim 1.5–3 seconds for gadgets
5. Confirm UI after splash still fits in remaining flash

Intros longer than ~4 seconds feel slow on a thermometer. Desk ornaments can run longer. Know which product you are building.

Minimal sketch skeleton after you paste export arrays

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

Adafruit_SSD1306 display(128, 64, &Wire, -1);

// --- paste Name Assemble frames + playSplash() here ---

void drawMainUI() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.print(F("Ready"));
  display.display();
}

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  playSplash();
  drawMainUI();
}

void loop() {
  // product code
}

Legal / brand note (worth saying out loud)

Only animate logos you own or have permission to use. Workshop demos with student initials are safe. Shipping a commercial gadget with someone else’s trademark splash is not a code problem — it is a legal one.

Import → assemble → export

In Name Assemble (same editor DNA as the main maker):

1. Open the Import tab and drop the PNG / JPG / GIF
2. Move the threshold until the preview shows a clean silhouette
3. Toggle invert if your logo is black-on-white and the OLED looks wrong
4. Pick an assemble style in the popup (Outside Random, Spiral, Rain…)
5. Watch the mockup. Every lit pixel should settle into the full logo
6. Get the Code for Adafruit SSD1306, SH110X, U8g2, or MicroPython

Tip: after import, leave a short hold at the end so the finished logo stays readable. The export already plays frames in order; adjust FPS if it feels frantic.

Where this fits in a real sketch

void setup() {
  // init display...
  playSplash();   // exported frame loop, once
  drawMainUI();   // menus, sensors, whatever
}

void loop() {
  // normal product code
}

Do not loop the splash forever unless that is the product (desk ornament). For gadgets, play once at boot, then move on. Name badges follow the same pattern with text instead of a logo — name badge build.

Flash budget reality check

Dense logos light more pixels, so assemble styles may generate more intermediate frames than a thin name. On Arduino Uno, trim the style or crop the logo. ESP32 / ESP8266 handle longer intros without drama. Details: Uno PROGMEM limits.

Rough math: each full 128×64 frame ≈ 1024 bytes. Twenty frames ≈ 20 KB before libraries. That is why I crop logos and avoid “full particle chaos” styles on Uno.

Common import fails (and fixes)

• Logo looks like confetti: threshold too aggressive. Ease it back.
• Only outlines assemble: source was a hollow stroke. Fill the shape first.
• Inverted result: use the invert toggle after threshold, then re-run the style.
• Muddy photo logo: dithering helps photos; solid logos usually look better without it.
• GIF with many frames: for full GIF playback use the main animation maker import path (GIF to OLED guide). Name Assemble shines when you want one silhouette assembling.

SH1106 note

SH1106 modules often need a 2-pixel column offset. If your logo sits two pixels off-center, you probably picked SSD1306 in software while the panel is SH1106. Comparison: SH1106 vs SSD1306.

Optional live preview

WebSerial or WiFi preview lets you tune threshold and style without uploading every try. WebSerial · WiFi preview.

Related searches: oled logo animation arduino · ssd1306 splash screen · image to oled animation · png to ssd1306 · oled startup animation

Frequently asked questions

A 12-frame boot mark, timed on the bench

The splash I actually ship on small gadgets is a filled mark about 48×48, centered on the 128×64 canvas (origin near x=40, y=8), not a full-bleed photograph. Twelve assemble frames plus a hold is enough for “the logo built itself” without spending the whole flash budget. At 1024 bytes each, twelve frames are about 12 KB before the Adafruit core. On an Uno (32 KB flash) that leaves room for begin, a short menu, and not much else. The same twelve frames are noise on an ESP32.

Playback I want: about 80–100 ms per frame (roughly a second of motion), then a hard hold so a person can read the mark. I use millis() for the hold so a later button library is not stuck behind delay(). Reset on a 4-pin I2C module stays -1.

const uint8_t FRAME_COUNT = 12;
const uint16_t FRAME_MS = 90;
const uint16_t HOLD_MS = 1500;

void playSplash() {
  for (uint8_t i = 0; i < FRAME_COUNT; i++) {
    display.clearDisplay();
    display.drawBitmap(0, 0, frames[i], 128, 64, SSD1306_WHITE);
    display.display();
    delay(FRAME_MS);
  }
  uint32_t t0 = millis();
  while (millis() - t0 < HOLD_MS) {
    // last frame is already on glass; do not clear here
  }
}

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // 0x3D if the scanner says so
  playSplash();   // once
  drawMainUI();
}

frames[] is the Name Assemble export, stored in PROGMEM the way that export already does it. Do not also keep a second RAM copy “to make it faster.” On Uno that second copy is 12 KB you do not have. After the hold, drawMainUI() must clearDisplay() or the logo and the menu share the glass. If the IDE flash bar goes red, drop to eight frames or a thinner style before you start deleting the UI.

I time the intro with a phone stopwatch from power-on, not from the first pixel. USB enumeration on a Nano adds a delay the animation code cannot see. If the whole boot feels longer than three seconds, shorten FRAME_COUNT or HOLD_MS, not the contrast.

Splash-specific failures

• Upload fails with “text section exceeds available space.” The style generated too many full frames for an Uno or Nano. A 128×64 frame is 1024 bytes. Cut frames, crop the artwork, or compile the same export for ESP32. This is flash, not a bad USB cable.
• Logo looks like scattered dots, then never becomes the mark. Threshold was too high, or the PNG was a soft gray wordmark. Redraw a solid silhouette and re-import. Hollow outlines assemble as crumbs; fill them first.
• Animation is perfect in the browser and shifted on the module. SH1106 column offset. The art is not off-center. Change the driver. SSD1306 code on an SH1106 is the usual “two pixels left” photo students send.
• First frame is black for a second, then the splash runs. begin() succeeded but contrast was left at 0 by an older experiment, or display() was missing on frame 0. Set contrast (SSD1306_SETCONTRAST, then 0x8F or 0xCF) once after begin. A splash that starts at contrast 0 looks like a dead OLED that “wakes up.”
• Splash runs, then the board resets halfway. A marginal USB cable plus a 5 V module inrush. Try another cable before you rewrite the player. On ESP32, power the OLED from 3.3V; a 5 V rail into GPIO pull-ups is a separate way to get brownouts and dark screens.
• Works on Uno, black on Mega. SDA and SCL moved. Mega is pins 20 and 21, not A4 and A5. ESP32 is GPIO21 and GPIO22. NodeMCU is D2 and D1. The frame arrays do not care; the wires do.

Which board should store this intro

I2C is the right default for a splash you show once. SPI’s extra wires (DC, CS, RST, plus MOSI and SCK) matter when the product keeps streaming full frames. Address 0x3C versus 0x3D is independent of how pretty the logo is — if Hello World is black, fix that before you judge the assemble style. A breadboard that loses contact on SDA will freeze mid-splash and look like a corrupt bitmap.

Related

• Arduino OLED name animation
• DIY OLED name badge
• Scrolling text vs name animation
• GIF to OLED converter
• About · Contact · Privacy