What Is a Cheap Yellow Display? A Hands-On Look at the ESP32 CYD

Since then, I’ve upgraded to a HaleHound CYD setup with a NerdMiner HAT, which adds a lot more functionality. I’ll be doing a separate video on that later. I also have a 3.5-inch HaleHound CYD, pre-built by Jesse Hale, that should be arriving today.

As I’ve gotten deeper into the CYD ecosystem, I’ve learned just how much you can do with these boards. Using the BMorcelli Launcher, you can run or install a variety of compatible community projects and firmware, including things like Bruce, Marauder, NerdMiner-related projects, and quite a few others.

I recently came across another project called Wireless Wizard that has apparently been around for a while, but I had never run into it before. From what I’ve seen so far, it looks pretty interesting, and I plan to spend some time checking it out.

One thing I’ve learned along the way is that I personally prefer the two-USB version of the CYD. I’ve found the separate USB connections more convenient when flashing and experimenting with different firmware, so that’s generally the version I look for when I have a choice.

In this Field Note, I’m going to go over the CYD hardware, specifications, firmware options, and some of the things I’ve learned from actually using these boards. I also plan to include a few labeled photos with arrows pointing out the different components so it’s easier to understand what everything is and where it’s located.

This Field Note is going to be a mix of my own hands-on experience and AI-assisted research and organization. I’ll be dictating the personal sections myself, like this introduction, while using AI to help organize technical sections such as specifications and feature breakdowns.

2. What Is the CYD? A Look at the Hardware

The Cheap Yellow Display, usually shortened to CYD, is a family of inexpensive ESP32-based development boards that combine a microcontroller, color touchscreen, and several useful hardware features into one compact package.

At the heart of the classic CYD is the ESP32, designed by Espressif Systems. Espressif develops the ESP32 family of system-on-chip devices, which combine processing power with built-in wireless capabilities such as Wi-Fi and Bluetooth. The complete CYD board itself is produced by third-party manufacturers, but the ESP32 is the core technology that makes the platform possible.

The board most people think of as the original CYD is the ESP32-2432S028R, a 2.8-inch model with a 320 × 240 color touchscreen.

The name “Cheap Yellow Display” was not an official manufacturer name. It came from the maker community. Brian Lough, through his witnessmenow GitHub project, proposed calling the ESP32-2432S028R the “Cheap Yellow Display,” or CYD, because the original model number was such a mouthful. His repository became one of the main community resources for documentation, examples, pin information, troubleshooting, hardware modifications, projects, and related CYD variants.

A typical classic 2.8-inch CYD includes:

• A 2.8-inch 320 × 240 color TFT display
• A resistive touchscreen
• An ESP32 microcontroller/module with Wi-Fi and Bluetooth
• A microSD/TF card slot
• USB connections for power, programming, and flashing
• Accessible GPIO and expansion connections
• Onboard components such as an RGB LED and light sensor on common versions

One thing I’ve learned from using these boards is that I personally prefer the two-USB version of the CYD. I find the separate USB connections more convenient when flashing and experimenting with different firmware, so that is generally the version I look for when I have a choice.

It is also important to understand that not every board sold as a CYD is exactly the same. Over time, the name has expanded beyond the original ESP32-2432S028R to include a growing family of similar ESP32 display boards. Different versions can use different screen sizes, touch controllers, USB layouts, display controllers, connectors, memory configurations, and even newer ESP32 chips.

That variation matters when flashing firmware. A firmware image made for one CYD revision may not necessarily work correctly on another, so identifying the exact board and hardware version is always a good first step.

The CYD family is still evolving. Newer boards based on chips such as the ESP32-C5 are beginning to appear, bringing newer wireless capabilities and updated hardware while keeping the same general touchscreen development-board concept alive.

In the accompanying image, I’ve labeled the major components and connectors on the classic two-USB CYD so you can see where the ESP32 module, microSD slot, USB connections, expansion ports, and other important hardware are located.

3. What Makes the CYD Interesting?

What makes the CYD interesting is that it manages to pack a surprising amount of capability into a small, inexpensive form factor.

At its core, it is still an ESP32 development board with a touchscreen, storage support, USB connectivity, and expansion options. But because everything is combined into one compact device, it is easy to carry, easy to experiment with, and easy to turn into something more specialized.

The small form factor is a big part of the appeal. You can have a touchscreen-equipped ESP32 platform that fits in your hand, runs from USB power, and can be built into a case or portable project without needing a large collection of separate components.

What really sets the CYD apart, though, is the community ecosystem that has grown around it.

There are now many different firmware projects and tools that support CYD-style hardware, along with launchers that make it easier to move between compatible firmware. That means the same basic board can be used for wireless-analysis projects, utilities, development experiments, dashboards, sensors, and other hands-on electronics projects depending on the firmware and accessories you choose.

Another thing I find interesting is that the CYD ecosystem keeps evolving. It is no longer just one 2.8-inch ESP32 board. New screen sizes, different hardware revisions, updated processors, and new expansion options continue to appear.

A good example is the newer ESP32-C5-based CYD hardware, including boards designed to work with newer accessories and HATs. These newer variants bring updated wireless capabilities and show that the CYD idea is continuing to grow rather than staying tied to one original board design.

That evolution also means the community keeps finding new uses for the platform. New firmware appears, older projects add support for newer boards, and people continue creating custom cases, HATs, antenna setups, battery options, and other add-ons.

The CYD is also inexpensive enough that experimenting with it does not feel like risking an expensive piece of specialized hardware. You can flash different firmware, test new configurations, modify cases, add hardware, and learn by trial and error.

For me, that is probably the biggest appeal: the CYD is small, affordable, flexible, and constantly evolving.

It starts as a simple touchscreen ESP32 board, but because of the hardware, firmware community, and growing number of variants, it can become a lot of different things depending on what you want to build.

4. Flashing Firmware and Finding New Projects

One of the things that makes the CYD so approachable is how easy it can be to flash new firmware onto it. In many cases, you do not need a complicated development environment or a bunch of programming experience. A USB cable, the correct firmware, and a browser-based flashing tool may be all you need.

The part that seems to trip people up most often is getting the ESP32 into download or flashing mode.

On the CYD boards I use, the basic process is to connect the board, hold down the BOOT button, and start the erase or flashing process. The important part is not letting go of BOOT too early.

I normally keep holding it until the flashing tool clearly shows that it has connected and has started either erasing or writing the firmware. Once that process has actually started, I release the button and let it finish.

That one little detail can make the difference between thinking something is wrong with your board and having it flash correctly on the first try.

ESP Terminator

ESP Terminator is one of the browser-based tools you may run across when flashing ESP32 firmware.

One of the things I like about ESP Terminator is that it is useful for more than just flashing one firmware image. It can also be a good place to discover other ESP32 projects.

Once you connect a supported board, you can browse a large selection of firmware and projects for compatible hardware. That makes it useful when you are not sure what you want to try next.

Instead of already knowing the exact GitHub repository or firmware file you need, you can plug in your board, look through the available projects, and get an idea of what else exists in the ESP32 ecosystem.

That is one of the ways I have found new projects myself. You may start out looking for one specific firmware and end up finding several other tools or experiments you had never heard of before.

ESP Terminator:
https://espterminator.com/

The site currently includes projects such as Bruce, Marauder-related firmware, and numerous other ESP32 and hardware projects that can be flashed directly through the browser.

As always, compatibility still matters. Just because a project appears in an ESP32-related flasher does not mean it will work on every CYD revision, so check the supported-board information before flashing.

Spacehuhn ESP Web Tool

Another useful option is the Spacehuhn ESP Web Tool.

This is a browser-based utility that lets you connect to supported ESP32 hardware and manually flash firmware files.

It becomes especially useful when a project gives you several separate .bin files rather than one complete firmware image.

Spacehuhn ESP Web Tool:
https://esptool.spacehuhn.com/

The tool lets you connect the ESP device, add individual .bin files, assign the correct flash address to each one, and program the device directly from the browser.

Understanding .bin Files and Flash Addresses

When you download firmware manually from GitHub, you may not always get one simple file to flash.

Some projects provide several .bin files that each belong in a different location in the ESP32’s flash memory.

A typical project might include:

• bootloader.bin
• partition-table.bin
• the main application or firmware .bin
• sometimes filesystem or additional data images

These files cannot simply be loaded anywhere.

Each one has a specific flash address, sometimes called an offset, that tells the flashing program where that part of the firmware belongs.

For some classic ESP32 projects, you may commonly see addresses such as:

• Bootloader: 0x1000
• Partition table: 0x8000
• Main application: often 0x10000

Those are common examples, but they are not universal.

Different ESP32 families, firmware projects, partition layouts, and build configurations can use different addresses. The safest approach is always to follow the addresses given in the firmware project’s own instructions.

When downloading firmware from GitHub, look for things like:

• installation or flashing instructions
• release notes
• README or Wiki pages
• flash_args or similar build information
• an example esptool command listing the filename and address pairs

Merged .bin Files

Some projects make flashing much easier by providing a merged binary.

A merged .bin combines the bootloader, partition table, application, and sometimes other required pieces into one complete firmware image.

When a firmware file has been properly created and documented as a merged or full-flash image, it is normally flashed beginning at:

0x0

That is different from taking an ordinary application .bin and putting it at 0x0.

The important distinction is:

Several separate .bin files: find and use the correct flash address for each file.

One confirmed merged/full-flash .bin: normally flash it beginning at 0x0, unless the project specifically tells you otherwise.

Do not assume that every single .bin file you download is a merged image.

Espressif Flash Download Tool

For more manual firmware flashing, another useful option is the Espressif Flash Download Tool.

This is a Windows utility from Espressif Systems for flashing firmware directly to ESP32-family devices.

It is especially useful when a project provides several separate .bin files that each need to be written to a specific address in flash memory.

The tool lets you select firmware files, enter their flash addresses, choose the correct COM port and baud rate, erase the existing flash when needed, and then write the firmware to the board.

The version I have used is Flash Download Tool 3.9.7, although Espressif has released newer versions.

Official Espressif tools:
https://www.espressif.com/en/support/download/other-tools

BMorcelli Launcher

One of the most useful pieces of software in the CYD ecosystem is BMorcelli Launcher.

Launcher changes the way you use the CYD because instead of treating the board as something that has to be erased and reflashed from a computer every time you want to try different firmware, it gives you a much more convenient way to manage compatible firmware.

You can keep firmware available on storage and switch between compatible projects as needed.

For me, this is one of the biggest things that makes the CYD so useful.

Once Launcher is installed, it becomes much easier to experiment with different compatible firmware without starting completely from scratch every time.

It also ties into the wider community ecosystem. You may discover a new firmware project, download the correct compatible build, and add it to your Launcher setup rather than dedicating an entire board to one piece of firmware.

As always, different CYD revisions, screen controllers, memory layouts, and ESP32 variants may require different builds.

BMorcelli Launcher:
https://github.com/bmorcelli/Launcher

Launcher Web Flasher:
https://bmorcelli.github.io/Launcher/

HaleHound

HaleHound is another major project in the CYD ecosystem and one of the projects that originally got me interested in these boards.

Official HaleHound firmware can be flashed directly through its browser-based web flasher. The site lets you select your supported board and flash the official HaleHound firmware without having to manually manage the firmware files yourself.

HaleHound:
https://halehound.com/

HaleHound Web Flasher:
https://flash.halehound.com/

HaleHound also continues to release firmware updates for supported CYD hardware.

GitHub: Where the Rabbit Hole Really Starts

Once you get comfortable flashing the CYD, GitHub becomes one of the best places to discover what else the hardware can do.

A lot of ESP32 and CYD firmware is developed openly there.

GitHub is usually where you can find:

• current releases
• supported-board lists
• installation instructions
• source code
• bug reports
• hardware discussions
• experimental builds
• forks and new projects

That is also where the CYD starts becoming more than a device you bought for one specific firmware.

You may start with one project, discover another repository that supports the same board, find a Launcher-compatible build, discover a new HAT, or find an entirely different use for the hardware.

The main thing to remember is that “ESP32 compatible” does not automatically mean “compatible with every CYD.”

Always check the supported hardware before flashing.

Wireless Wizard

One lesser-known CYD firmware project I recently came across is Wireless Wizard.

It is another example of how the CYD ecosystem keeps expanding beyond the better-known projects.

Wireless Wizard is aimed at wireless experimentation and analysis, and I had not heard of it until recently even though the project has apparently been around for a while.

That is a good example of how easy it is to keep discovering new firmware and new uses for the CYD.

Wireless Wizard:
https://wirelesswizard.net

For me, learning how easy these boards are to flash was really the point where the CYD opened up.

Once you know how to put it into flashing mode, where to find firmware, and how to recover it when something does not work, you stop thinking of it as a device with one purpose and start thinking of it as a platform you can keep changing.

5. What You Can Build and Learn With a CYD

One of the best things about the CYD is that it is not tied to one single purpose.

At the simplest level, it is a compact ESP32 development platform with a touchscreen, storage, wireless connectivity, and expansion options.

That combination makes it useful for learning, experimenting, and building a wide range of projects without needing a large collection of separate hardware.

For someone just getting started, the CYD can be a good way to learn the basics of working with ESP32 hardware.

You can learn how to:

• Flash and erase firmware
• Recover a board that will not boot
• Work with boot and download modes
• Use microSD storage
• Understand firmware partitions and flash addresses
• Connect GPIO devices and expansion hardware
• Work with Wi-Fi and Bluetooth
• Compare different board revisions and hardware layouts

It is also a good platform for experimenting with community firmware.

Instead of buying a completely separate device every time you want to try something new, you can use the same CYD hardware with different compatible firmware.

That can include wireless-analysis tools, utilities, dashboards, sensors, touchscreen interfaces, and other ESP32 projects.

You can also build outward from the basic board.

The CYD can be used with custom cases, external antennas, batteries, GPS hardware, sensors, and different expansion boards or HATs.

That makes it possible to start with a simple handheld touchscreen device and gradually turn it into something much more specialized.

That modularity is part of what makes the platform useful for learning.

You are not just using finished software. You are learning how the hardware, firmware, storage, displays, wireless radios, and add-on boards all work together.

Another useful lesson is simply learning that compatibility matters.

Not every firmware works on every CYD.

Screen controllers can differ. Touch hardware can differ. Memory layouts can differ. Newer ESP32 chips may require different builds entirely.

Learning how to identify your exact hardware, read GitHub documentation, choose the right firmware image, and recover from a bad flash is part of the experience.

Firmware You Can Explore on the CYD

One of the biggest advantages of the CYD is the amount of firmware that has been developed, adapted, or ported for CYD-style hardware.

Some of the projects we have found include:

• BMorcelli Launcher – firmware management and launching for supported ESP32 devices.
• Bruce – a multi-purpose ESP32 firmware supporting several CYD-style platforms.
• ESP32 Marauder / CYD builds – wireless testing and experimentation firmware with builds available for compatible CYD hardware.
• HaleHound – a CYD-centered multi-protocol hardware and firmware ecosystem.
• GhostESP – another community ESP32 wireless platform with support for compatible CYD hardware.
• Wireless Wizard – a lesser-known third-party firmware project centered around wireless experimentation and analysis.
• NerdMiner / NMMiner-related projects – mining-oriented firmware and hardware projects, including newer CYD-style hardware.
• Other community projects – dashboards, utilities, sensor interfaces, experimental firmware, games, displays, and other ESP32 projects continue to appear.

This list keeps growing, and not every project supports every CYD.

Before flashing anything, always check the project’s supported-board list and make sure you are using the build made for your exact display, USB layout, ESP32 variant, and hardware revision.

The C5 Opens Another Door

The newer ESP32-C5 generation is a good example of where the CYD ecosystem is heading.

The ESP32-C5 adds dual-band 2.4 GHz and 5 GHz Wi-Fi, along with newer wireless capabilities.

That is a significant change from the classic CYD generation, which has generally been centered around 2.4 GHz Wi-Fi.

For wireless experimentation, adding 5 GHz Wi-Fi support opens up a whole new range of possibilities as firmware developers begin taking advantage of the newer hardware.

That does not mean every existing CYD project will automatically work on the C5.

New chips usually mean new firmware builds, new compatibility work, and sometimes new hardware layouts.

But that is also what makes the platform interesting.

The CYD started as a cheap little ESP32 touchscreen board, and now we are already seeing newer processors, new screen sizes, different expansion hardware, and new firmware support being added around it.

Where it goes next is still being figured out.

And honestly, that may be one of the most interesting parts.

The hardware keeps changing.

The community keeps building.

New firmware keeps showing up.

The future of the CYD ecosystem is still wide open.

6. Things Beginners Should Know

The CYD is a pretty forgiving platform to learn on, but there are a handful of mistakes that cause most of the frustration.

The good news is that once you understand a few basics, most problems are easy to avoid.

Know Exactly Which CYD You Have

The first thing to figure out is the exact board and revision you are using.

“CYD” has become a broad community name for a family of similar ESP32 touchscreen boards.

They can differ in:

• screen size
• touch controller
• display controller
• USB layout
• memory
• processor
• GPIO layout
• antenna configuration

That matters because firmware written for one CYD may not work correctly on another.

Before flashing anything, check the board model printed on the PCB and compare it with the supported-hardware list for the firmware you want to use.

Use the Correct Firmware Build

One of the easiest mistakes to make is downloading the wrong build.

A firmware project may offer separate files for:

• one-USB and two-USB CYDs
• different screen sizes
• different ESP32 chips
• different display controllers
• newer boards such as the ESP32-C5

Do not assume the file with “CYD” in the name will work on every CYD.

If the project provides a build specifically for your board, use that one.

Hold the BOOT Button Long Enough

This is probably one of the most common flashing mistakes.

When putting the board into flashing mode, I normally hold the BOOT button while starting the erase or flash process and keep holding it until the flashing program clearly shows that it has connected and has started erasing or writing.

Letting go too early can cause the flasher to fail to connect.

Once the process has actually started, I release the button and let the flash finish.

That simple timing issue can make a board look broken when it is really just not entering download mode correctly.

Understand .bin Files and Flash Addresses

If you are manually flashing firmware, pay attention to whether the project gives you one file or several.

Some firmware packages include separate files such as:

• bootloader
• partition table
• main firmware
• filesystem or data image

Each file may need to be written to a specific flash address.

Common examples on some classic ESP32 projects include addresses such as:

• 0x1000
• 0x8000
• 0x10000

But these are only examples.

Always use the addresses provided by the firmware project.

If a project provides a properly merged or full-flash .bin, that file is commonly written starting at:

0x0

Do not assume that every single .bin file belongs at 0x0.

It should specifically be identified as a merged or full image.

Use a Good USB Cable

A surprising number of flashing problems come down to the USB cable.

Some cables are power-only and do not carry data.

Others are simply unreliable.

If the board powers on but your computer cannot detect it, or flashing repeatedly fails, try a known-good data cable before assuming the board is bad.

Pay Attention to Power

ESP32 boards can behave strangely when power is unstable.

Symptoms can include:

• random resets
• failed boots
• SD card problems
• flashing failures
• freezing or crashing

Use a reliable USB port or power source and avoid very poor-quality cables.

If you add accessories, HATs, external radios, GPS, or other hardware, remember that those devices may increase the power requirements.

microSD Cards Can Matter

Many CYD projects use microSD storage for firmware files, logs, configuration, or additional data.

Card size, formatting, and card quality can affect reliability.

I personally tend to prefer smaller cards such as 8 GB or 16 GB for ESP32 projects rather than using very large cards unless the firmware specifically needs them.

The key thing is to check the firmware documentation for:

• supported card size
• required filesystem
• folder structure
• required filenames

If a project depends on the SD card and something is not working, the card is one of the first things worth checking.

A Bad Flash Usually Does Not Mean a Dead Board

One of the most useful things to learn early is that flashing the wrong firmware usually does not permanently kill the CYD.

If the board boots to a blank screen, crashes, loops, or shows garbage after a flash, you can often recover it by:

1. putting it back into download mode;
2. erasing the flash;
3. reflashing known-good firmware for the correct board.

That is one reason the CYD is such a good learning platform.

You can make mistakes and recover from most of them.

Save or Identify the Original Firmware

Before experimenting, it is a good idea to know what firmware originally came on the board.

You may not always need to back it up, especially if the stock firmware is publicly available, but it is useful to at least identify:

• the board model
• original firmware
• display type
• touch controller
• USB configuration

That gives you a known starting point if you need to restore the board later.

Be Careful With GPIO and Add-On Hardware

The CYD has expansion connectors and GPIO pins, which makes it easy to add hardware.

But GPIO pins are not unlimited.

Some may already be used by:

• the display
• touchscreen
• SD card
• LEDs
• other onboard hardware

Before connecting a HAT, sensor, GPS, radio, or other expansion board, check the pinout for your exact CYD revision.

Also make sure the voltage levels and power requirements are correct before connecting anything.

Check Compatibility Before You Assume Something Is Broken

A lot of CYD troubleshooting comes down to compatibility.

Before spending hours debugging, check:

• Is this firmware made for my exact board?
• Is the screen controller supported?
• Is the touch controller supported?
• Am I using the correct build?
• Is my USB cable a data cable?
• Did I hold BOOT long enough?
• Is the SD card formatted correctly?
• Am I using the correct flash addresses?

Most CYD problems are not mysterious once you work through those basics.

The CYD is easy to experiment with, but learning these few habits early will save you a lot of time and make flashing, testing, and trying new projects much less frustrating.

7. My Hands-On Experience and Final Thoughts

The CYD is really the project that got me back into wireless penetration testing and cyber gadgets.

Since that first board, I’ve ended up with a bunch of CYDs. I even sell them on my site now.

I started with the basic CYD, then moved into adding a NerdMiner HAT that was compatible with both Bruce and HaleHound.

That was one of the points where I really started to see how much these boards could grow beyond the basic setup.

The HAT added more hardware and capabilities, including antennas, GPS, and additional RF/IR functionality, and it made the whole platform feel much more like a complete handheld cyber tool rather than just a touchscreen development board.

I normally like to build my own equipment, but this time I decided to do something a little different.

I bought a HaleHound 3.5-inch prebuilt, and it is actually supposed to arrive today.

Part of the reason I bought the prebuilt version was because I wanted one put together by the person behind the project instead of building every part of it myself.

I’m looking forward to comparing it with the CYD builds I already have.

I’ve also been really impressed with BMorcelli Launcher.

One of the things I like most about Launcher is that you can keep different firmware available and change what you are running as you need it.

Instead of treating the CYD like a device that only runs one thing, Launcher makes it much easier to switch between compatible firmware and experiment with new projects.

That has been surprisingly useful.

On the CYDs I sell through my website, I use BMorcelli Launcher as part of the setup.

For the lower-cost CYDs I sell through eBay, I leave the manufacturer’s stock or demo firmware on the board and provide information so the buyer can install Launcher or other compatible firmware themselves.

I’m also getting some newer CYD C5 boards made by NerdMiner.

These bring 5 GHz Wi-Fi support to the CYD-style platform, and I’m really interested to see what developers do with that extra capability.

Since getting back into this through the CYD, I’ve also moved into a lot of other hardware and projects.

I’ve been experimenting with boards such as the LilyGO ESP32-C5, and I’ve also gotten into Raspberry Pi Zero 2-based projects like Bjorn, Pi Squirrel, Pwnagotchi, and RaspyJack.

So, in a lot of ways, the CYD was the starting point that pulled me back into all of this.

I’ve moved on to experimenting with a lot of other hardware since then, but I still really like the CYD because of how much you can do with such a small and inexpensive platform.

There will definitely be future videos and Field Notes covering these other projects as well.