
Almost every gadget has a small screen, and someone had to draw it. In this lecture you'll design a screen for a 128x64 OLED display in your browser and run the generated Arduino code in a free simulator. No experience needed.
What you'll learn:
- What a microcontroller is and how a display is a grid of pixels
- Pixel coordinates: (0, 0) is the top-left corner
- What a graphics library does, and why coding screens by hand is slow
- Creating a U8g2 project in Lopaka, drawing shapes and text
- Copying the generated code and running it in Wokwi
A clock, the weather and a picture of the moon, all on a screen the size of a postage stamp. In this lecture we build a small morning dashboard on a 128x64 OLED and learn why text, fonts, icons and images all cost memory.
What you'll learn:
- Why a font is just a set of tiny pictures
- Flash vs RAM, and how much a font takes on an Arduino UNO
- Importing your own TrueType font
- Adding icons, and why a small icon takes just 32 bytes
- Inverted text and the XOR trick
- Uploading your own image and dithering it to black and white
- Multiple screens and PROGMEM
Same idea, now in full color: a living room dashboard on a color TFT display, built in a few minutes. In this lecture you'll learn how color screens work, what RGB565 means, and how to keep color graphics small.
What you'll learn:
- How every pixel is made of red, green and blue lights
- RGB565: 16-bit color, and why green gets the extra bit
- Why one full-screen picture is bigger than an Arduino UNO's whole flash
- Rounded cards, colored text, tinted icons and a small color picture in Lopaka
- How the same design becomes code for U8g2, Adafruit GFX or LVGL
- Running it on an ESP32 in Wokwi, and forking projects from the gallery
Two identical screens show the same sensor numbers, but one blinks every time a number changes. In this lecture you'll find out why color displays flicker and build a live room monitor that doesn't: temperature and humidity from a DHT22 sensor, updated twice a second on an ESP32 with a 320×240 TFT.
What you'll learn:
- What setup() and loop() do, and where live data belongs
- Frame buffer vs. drawing straight onto the display: why an OLED never blinks and a TFT does
- Three rules against flicker: no clearing in loop, a background behind every number, nothing under a live value
- Turning layers into variables in Lopaka: the layer name becomes the variable name
- Writing your own setup() and loop() around Lopaka's generated code
- Running it in Wokwi and moving the sensor's sliders
You uploaded the code, and the OLED stays black. It's almost never broken: it's one of five things. In this lecture we take a screen designed in the browser onto an Arduino Uno with a 128×64 SSD1306 OLED, step by step in the Arduino IDE, and then hunt down all five reasons a display stays dark.
What you'll learn:
- How the board talks to the screen: I2C, the clock and data wires, and the address 0x3C
- Installing U8g2 and picking your board in the Arduino IDE
- Building the sketch around Lopaka's drawing functions
- Reading the display constructor line: chip, size, buffer, wiring
- What the memory numbers after Verify mean on an Uno
- Five reasons a screen stays black: wires, address, chip, code, memory, and the fix for each
Two buttons, four screens, and a menu that feels like a real gadget. In this lecture we draw every screen of a small clock, weather and heart-rate gadget in Lopaka, add a menu with a moving cursor, and run it on an Arduino Uno with a 128×64 OLED in Wokwi.
What you'll learn:
- Why every menu is a map of states, and how two variables run it
- Several screens on one canvas: Duplicate, groups, renaming a screen into a draw function
- A menu cursor: a filled bar in XOR mode with a variable for its Y position
- Reading a button: catch the press, not the hold, and ignore the bounce
- The whole sketch: redraw only when something changed
A GIF from 1887, galloping on a tiny OLED. Make it full screen and a little smoother, and the sketch no longer fits. In this lecture we find out how animation works on a microcontroller, how much memory every frame really takes, and how to make a GIF, or even a video, fit. Then we run a galloping horse on an Arduino Uno and a whole month of moon phases on an ESP32 in Wokwi.
What you'll learn:
- Frames and frame rate: why ten pictures a second already look like motion
- How much memory an animation needs: width × height ÷ 8 bytes per frame
- Why an Arduino Uno fits only about 23 full-screen frames, and three ways to fit more
- Importing a GIF and a video into Lopaka, and editing frames in the frame editor
- The code: frames in flash with PROGMEM, one frame per loop
Sources: Horse: Eadweard Muybridge, Animal Locomotion (1887), public domain. Moon footage: NASA's Scientific Visualization Studio.
This looks like an app on a phone, but it's an ESP32 and a 2.8 inch touchscreen. In this lecture we build a phone-like touch interface with LVGL: a dial, a slider, a switch and two buttons. We lay it out in Lopaka, add a few lines of events, and touch it for real in the Wokwi simulator.
What you'll learn:
- A graphics library vs a UI framework: drawing a button vs creating one
- LVGL in three words: objects, styles and events
- Building an LVGL screen in Lopaka: arc, slider, switch, buttons, labels
- Connecting widgets to your code with lv_obj_add_event_cb
- When LVGL is worth it, and when a graphics library is enough
C++, YAML, Python and C: five different programs, and they all draw the same screen. In this lecture we design one small plant-monitor screen and take it to five platforms: Arduino (U8g2), ESPHome, MicroPython, CircuitPython and Flipper Zero. Four of them run in the Wokwi simulator; for the Flipper Zero we look at the C code that goes into a Flipper app.
What you'll learn:
- Compiled firmware vs an interpreter: how Arduino, ESPHome and Flipper apps differ from MicroPython and CircuitPython
- Picking a platform in Lopaka and drawing a screen from rectangles, circles, lines and text
- MicroPython: framebuf calls and a display driver on a Raspberry Pi Pico
- CircuitPython: displayio objects in a group, libraries from requirements.txt
- ESPHome: a display lambda inside YAML, fonts from Google Fonts, compiled to ESP32 firmware
- Flipper Zero: canvas calls and the four built-in fonts
- What stays the same between platforms and what changes
Sources: Flipper Zero and OLED module photos: Turbospok, Wikimedia Commons, CC BY-SA 4.0 (modified: background removed, perspective corrected, our screen inserted).
Pull the plug: a TFT goes dark instantly, an e-paper display keeps its picture with zero power. In this final lecture we design a meeting room sign for a 2.9" e-paper panel in Lopaka, run it on an ESP32 in the Wokwi simulator, publish it to the Lopaka gallery and go through a checklist before shipping.
What you'll learn:
- How electronic ink works: capsules with black and white particles that stay put without power
- Full refresh vs partial refresh, and why ghosting means a full refresh every few updates
- A GxEPD2 (e-paper) project in Lopaka: 296x128 canvas, the 9-colour palette, a duplicated screen
- The generated code, your own lines around it: displayWindow() for a partial refresh, hibernate() to sleep
- Three-colour panels: red in Lopaka becomes GxEPD_RED, and why a full refresh takes about 26 seconds
- Publishing to the gallery, sharing a public link, Fork
- Five common mistakes in embedded screens: a checklist before you ship
This course contains the use of artificial intelligence.
Almost every gadget has a small screen, and someone had to draw it. Lopaka Basics is a free, beginner-friendly course that shows you how to design graphical screens for microcontrollers in your browser and turn them into working code, without hand-coding every pixel.
You'll use Lopaka, a free online editor for embedded displays. Draw your screen with shapes, text, icons and images, and Lopaka writes the code for popular libraries such as U8g2, Adafruit GFX, TFT_eSPI and LVGL. Every result runs in the free Wokwi simulator, so you don't need any hardware to follow along. If you have an Arduino Uno or an ESP32, you can run the same code on a real board.
Each lecture is a short, focused project. Along the way you'll learn how small screens really work: a display as a grid of pixels, coordinates, fonts and baselines, Flash and RAM, RGB565 color, frame buffers and flicker, I2C wiring, animation frames and e-paper refresh.
What you'll build:
- Your first screen on a 128x64 OLED
- A morning dashboard with fonts, icons and your own picture
- A color living room dashboard on a TFT display
- A live sensor monitor that doesn't flicker
- A gadget menu with two buttons and four screens
- A GIF animation on a tiny OLED
- A phone-like touch interface with LVGL on an ESP32
- One screen design running on Arduino, ESPHome, MicroPython, CircuitPython and Flipper Zero
- A meeting room sign on a 2.9" e-paper display
No programming or electronics experience is needed. All you need is a computer with a web browser.