The Cheap Yellow Display (officially the ESP32-2432S028R) is a small dev board that pairs an ESP32 with a 2.8 inch 320x240 resistive touchscreen, an SD card slot, an RGB LED, and a light-dependent resistor, all for under ten dollars. It took off in 2024, and by 2026 it has become the default hobbyist target for anyone who wants a real touchscreen widget on a desk, a wall, or the front of a 3D printer. The hardware is only half the story. The other half is the desktop toolchain we use to design UIs, write firmware, and push builds to the board. Below are the seven tools we reach for most often when we work on a CYD project, from a first blinking pixel to a polished smart-home dashboard.
What to look for in a CYD tool
The CYD is quirky. It uses an ILI9341 display driver over SPI and an XPT2046 resistive touch controller on a separate SPI bus, and the pin assignments are not the ones most ESP32 tutorials assume. That means a good tool for CYD work has a few specific traits.
- First-class LVGL support, since almost every serious CYD project uses LVGL for the graphics layer.
- Ready-to-use driver templates or examples for the ILI9341 and XPT2046, so we do not have to guess pin numbers.
- Wi-Fi OTA support, because taking the board out of an enclosure to flash it gets old fast.
- A clean way to keep fonts, images, and other assets on the SD card instead of flash.
- A big community of published CYD examples we can borrow from, since the board’s pinout varies slightly between clones.
Everything below scores well on at least three of those five.
Quick comparison
| Tool | Best for | Platforms | Free or paid | Standout feature |
|---|---|---|---|---|
| LVGL | The graphics layer itself | Windows, macOS, Linux | Free, MIT | Runs the same C code on the CYD and on a desktop simulator |
| SquareLine Studio | Designing UIs visually | Windows, macOS, Linux | Free personal tier, paid Pro | Exports clean LVGL C project code |
| PlatformIO | Managing builds and libraries | Windows, macOS, Linux | Free core, paid Home features | One platformio.ini handles boards, deps, and OTA |
| Arduino IDE 2 | A first CYD project | Windows, macOS, Linux | Free | Board Manager finds the ESP32 core in two clicks |
| ESP-IDF | Deep firmware and low-level work | Windows, macOS, Linux | Free | Full access to Espressif drivers and RTOS features |
| MicroPython | Rapid prototyping in Python | Windows, macOS, Linux | Free | Live REPL over USB, no compile step |
| ESPHome | Home Assistant dashboards | Windows, macOS, Linux | Free | YAML config compiles to firmware, no C required |
The tools
1. LVGL – Best for the graphics layer
LVGL (Light and Versatile Graphics Library) is the reason the CYD is fun to work with. It gives us buttons, sliders, charts, keyboards, and animations that look modern on a 320x240 screen, and it runs on almost any microcontroller with a framebuffer. Version 9 tightened the memory footprint and simplified the display and input driver APIs, which matters on the ESP32’s tight RAM budget.
The killer feature for beginners is the desktop simulator: the same C code that drives the CYD can run inside an SDL window on our laptop, so we can iterate on layout and interaction without touching the board. When we do flash, LVGL slots cleanly into PlatformIO, Arduino, and ESP-IDF projects with the same lv_conf.h file.
Anything more polished than a two-button demo on the CYD is almost certainly LVGL under the hood.
2. SquareLine Studio – Best for designing UIs visually
Writing LVGL widgets by hand is fine for a screen or two. Past that, we want a canvas. SquareLine Studio is a drag-and-drop UI editor built specifically for LVGL: we lay out screens, wire event handlers, pick fonts, drop in images, and then hit export to get a full LVGL C project ready to drop into PlatformIO or Arduino.
The free personal tier is generous enough for hobby CYD builds, and there is a CYD template floating around the community that seeds the correct 320x240 resolution and the ILI9341 driver settings. The Pro tier unlocks unlimited screens, custom widgets, and the ability to keep assets on the SD card, which is worth it if we start selling projects.
The workflow that clicks for us: sketch the UI in SquareLine, export, then hand-edit the generated ui_events.c to wire in the Wi-Fi, sensor, or MQTT logic.
Download: Site
3. PlatformIO – Best for managing builds and libraries
Once a project has more than one file, PlatformIO earns its keep. It runs as an extension inside VS Code (and a few other editors), and it replaces the ad-hoc build steps that plague hobbyist ESP32 work with a single platformio.ini that declares the board, the framework, the libraries, and the upload method.
For CYD work, the pattern is: pick board = esp32dev, add LVGL and the TFT_eSPI or LovyanGFX display library as lib_deps, and drop the correct User_Setup.h into include/ so the pins match the CYD’s wiring. From there, a single click builds, uploads, and opens the serial monitor. OTA over Wi-Fi is a one-line change to upload_protocol, which is a big quality-of-life win for boards mounted behind a bezel.
Library versions get pinned in the config file, so a project that built last year still builds this year. That is not something we can say about every ESP32 tutorial.
4. Arduino IDE 2 – Best for a first CYD project
Arduino IDE 2 (the current stable release, not the old Java 1.x) is where most people start with the CYD, and there is no shame in staying. It handles the ESP32 board package through the Board Manager, ships a fast Monaco-based editor with autocomplete, and has serial monitor and plotter built in.
The example browser is the best-in-class discovery tool for a beginner: install the TFT_eSPI, XPT2046_Touchscreen, and LVGL libraries and dozens of runnable sketches appear in the File menu. Most CYD tutorials on YouTube and GitHub are written against Arduino, so following along is friction-free.
We reach for it when we want a single-file sketch to prove something works on the hardware, then port to PlatformIO once the project grows.
Download: Site
5. ESP-IDF – Best for deep firmware work
Once we outgrow the Arduino abstraction, Espressif’s own SDK is waiting. ESP-IDF gives us FreeRTOS tasks, the full component system, deep power management, dual-core control, and access to every peripheral the ESP32 exposes. It is what shipping products use.
The tradeoff is verbosity. A blinking LED is more code than in Arduino, and the CYD’s display driver is not built in, so we either bring in LVGL’s esp_lcd port or wire up TFT_eSPI as a component. The payoff is that once the plumbing is in place, we can do things Arduino cannot, like double-buffered display refresh with DMA and PSRAM-backed framebuffers.
We use it when the CYD project involves anything network-heavy (BLE + Wi-Fi coexistence, mesh, TLS), or when we care about power draw on battery.
6. MicroPython – Best for Python prototypes
MicroPython puts a Python 3 interpreter on the ESP32 with a REPL over USB, and it changes how we prototype. Type a line, see the pixel change on the CYD. No compile, no flash cycle, no wait.
The graphics story is a bit more fragmented than with LVGL C, but LVGL itself ships MicroPython bindings, and lv_micropython builds tailored for the CYD are floating around the community. For simpler dashboards, st7789py and xpt2046 drivers are enough to draw text, sprites, and touch regions in a few dozen lines.
We use it for teaching, for one-off toys, and for the kind of internal tools where we want to be able to SSH in over WebREPL and change behavior without a rebuild.
Download: Site
7. ESPHome – Best for smart-home dashboards
If the CYD is going on a wall next to a Home Assistant install, ESPHome is the shortest path to a working dashboard. Instead of writing firmware, we write a YAML file that declares the display, the touchscreen, the switches, the sensors, and the UI pages. ESPHome compiles it into a firmware binary and flashes it, then wires the whole thing back into Home Assistant automatically.
The CYD has first-party support in the ESPHome docs, including the correct SPI bus assignments, backlight PWM, and touchscreen calibration hints. Community configs cover thermostats, media controllers, and multi-room lighting panels, and any of them can be forked and edited in the ESPHome dashboard through a browser.
For anyone who wants a working smart-home touchscreen this weekend rather than a firmware learning project, this is the answer.
How to pick the right one
The right tool depends on where the CYD is going and how deep we want to go. Someone who just picked up the board and wants to see something happen on the screen tonight should install Arduino IDE 2, add the ESP32 core, and load a TFT_eSPI example. It is the shortest distance to a working pixel.
For a project with a real UI (menus, screens, animations, a keyboard), the answer is LVGL for the rendering, SquareLine Studio for the layout, and PlatformIO for the build. That trio is what most polished CYD projects on GitHub use, and it is the combination we recommend to anyone serious about the board.
Firmware developers with an eye on shipping a product should skip Arduino and go straight to ESP-IDF, then bring in LVGL as a component. It is more setup, but it removes the ceiling.
Python-first hobbyists and educators get more done in MicroPython, especially for kids’ workshops or in-house tools.
And if the CYD is destined to live on a wall with Home Assistant behind it, ESPHome bypasses all of the above and lets us describe the dashboard in YAML in an afternoon.
FAQ
What is the Cheap Yellow Display exactly? It is the ESP32-2432S028R, an ESP32-WROOM-32 module soldered to a board with a 2.8 inch 320x240 touchscreen (ILI9341 driver, XPT2046 resistive touch), an SD card slot, an RGB LED, a light sensor, and a USB port. It sells for around eight to twelve dollars on most marketplaces and picked up the “Cheap Yellow Display” nickname because early runs shipped on yellow PCBs.
Do I have to use LVGL, or are there alternatives? LVGL is the most popular choice, but not the only one. TFT_eSPI and LovyanGFX both give us fast primitives (lines, shapes, sprites, text) if we want to draw the UI ourselves. For simple gauges and dashboards that is plenty. LVGL wins as soon as we want widgets, animation, or a keyboard.
Can I develop for the CYD on macOS or Linux?
Yes. Every tool in this article runs natively on Windows, macOS, and Linux. On Linux we may need a udev rule so our user account can talk to the CH340 or CP2102 USB-to-serial chip on the board, but the setup is a one-time step.
How do I flash the CYD over Wi-Fi instead of USB? PlatformIO, Arduino IDE 2, ESP-IDF, and ESPHome all support OTA updates. The common pattern is to include an OTA library or component in the firmware, connect the board to Wi-Fi, and then set the upload method in the tool to point at the board’s IP address. First upload is over USB, everything after can be wireless.
Is SquareLine Studio free for hobby use? The personal tier is free and covers most hobby CYD projects. It caps things like the number of screens and asset resolution, but the exported LVGL code has no runtime restrictions. The Pro subscription unlocks unlimited screens, higher-resolution assets, and commercial use.
