A couple months ago, the screen of my old ereader cracked, which lead me to search for open source ereader projects. None of the projects contained all the features I wanted, so I decided to make one myself. It's main features are:

• esp32s3 based, allowing for deep sleep mode

• Dual-screen foldable design, allowing it to be carried without a protective case

• usb-c for charging and programming

• Buttons for menu navigation and turning pages

• Internal SD-card for book storage

• Two 1300 mAh batteries

• Only 16mm thick when closed (each half is 8mm thick)

The software is still very much work-in-progress. The code for unzipping and loading epub files is based on a very nice project by atomic14: https://github.com/atomic14/diy-esp32-epub-reader

The UI, epub parsing and text rendering is handled by custom code, and supports basic html and css stylesheets. Text is displayed in Unifont and supports the first 65,536 unicode characters, and can be bold, italic and large.

When reading, the esp32 is in light sleep, using little power. After 10 minutes of inactivity, the esp32 and displays enter deep sleep mode, which drastically reduces power consumption. In this manner, the device never needs to be turned fully off , and it can be awoken from deep sleep by pressing any of the buttons.

I am considering working this project further out into a crowdsupply campaign, please let me know if you'd interested in something like that.

Built a simple Pong game using two ESP32-S3 devices connected via ESP-NOW to play in versus mode 🕹️.

• Developed in PlatformIO + VS Code with the Arduino framework

• Runs on the kode dot, a pocket-sized dev board based on the ESP32-S3

• Full example repo here: GitHub – PongPlus

• Detailed docs on the device’s components and examples: Kode Docs

• More about the project: kode.diy

I did a review request here a coule of months ago https://www.reddit.com/r/esp32/comments/1k9i1rz/pcb_review_request_esp32c3_auckland_live_train_map/ and I now have it all set up and running. I have even been able to setup a little product page https://keastudios.co.nz/store/akl-ltm/

The PCB antenna based on SWCU125 PDF from TI works really well (my best antenna design to date with up to -25dbm).

The SN74LVC4245A works great with the ws2812b leds @ 8kbps (it's the only one the basic part list from jlc)

Also special thx to u/FirmDuck4282 for finding the mistake with my charliplexed leds and level shifter :)

You can check out the code, pcb and web installer here: https://github.com/CDFER/Auckland-LED-Train-Map

I’ve always wanted a sci-fi style pocketwatch (ever since I read The Diamond Age by Neal Stephenson)

None exist aside from a few people cramming a smartwatch into an antique case.

So I got a development board from waveshare that has a screen and motherboard (esp32s3 waveshare board with a 466x466 amoled screen), and programmed a UI that looks suitably sci-fi for my gaudy tastes using LVGL. It has time, network time update, a weather api using openweather, a tide tracker since I live near the coast, and I’m thinking of adding iOS notifications.

Then added a battery and designed this case in Fusion360 and had it 3d printed in stainless steel. Not perfect and I still need to do the buttons and a few other parts and then remake the case in sterling silver (I am a silversmith), but this is the first time seeing it assembled and working somewhat so I wanted to show it off.

EDIT:

The link to my GitHub can be found here

The print files are available on Printables

Recently, I realized that I didn’t want to use my phone as an alarm clock anymore, so I decided to build my own using an ESP32 and an e-ink display.

I wanted to make something that is super simple to use: rotate the encoder knob to set the alarm time, and press the button behind it to activate/deactivate the alarm.

You can also add custom alarm sounds through a small web server running on the local network.

The base of the clock doubles as a wake-up light. Before the alarm goes off, it slowly transitions from a warm orange/red glow to full daylight. It can also be used as a night light.

The hardware

The clock is built around an Elecrow CrowPanel ESP32-S3 5.79” E-Paper HMI Display. It has an ESP32-S3-WROOM-1-N8R8, a 5.79” e-ink display, an SD card reader and a GPIO expander. It’s also really easy to flash over USB-C, which made it a pretty convenient starting point.

For the audio, I used an external I2S amplifier board (MAX98357A) with a single 3W speaker that I had laying around (and sounds surprisingly well).

The wake-up light and front light are made using part of an SK6812 LED strip.

Everything fits into a custom 3D-printed enclosure that I designed from scratch. The base is made from translucent PETG so that it allows the wake-up light to shine through it.

The firmware

I do have some experience writing code for the ESP32, but nowhere near enough to build a GUI of this scale from scratch. I ended up designing everything in Figma, and used Claude to make everything "come to life".

The clock keeps time by syncing with NTP. If the WiFi connection is lost, it keeps running using the ESP32’s internal clock. In the future, I might add an RTC module so it can keep accurate time completely independently of WiFi.

Conclusion

I’ve been using it for almost two weeks now, and it’s definitely still a work in progress. There are plenty of things I’d like to improve, both in the hardware and the software.

But honestly, I’m really happy with how the first prototype turned out.

This is currently just a personal hobby project, but I’d be happy to share the code and 3D files if anyone is interested.

Curious what you guys think!

My teacher said we need to make a project on Atmega 16, but I also use my esp32, the Atmega reads buttons and joystick and send the information by serial to esp

Started as a simple idea for a pixel clock and somehow ended up with this :)

This is also a continuation of my earlier ESP32 project, SmallOLED-PCMonitor, where I used a tiny OLED to show PC stats:
https://github.com/Keralots/SmallOLED-PCMonitor

For this one I wanted to take the idea much further, so I used an ESP32-S3 with two 64x64 P2.5 HUB75E panels chained together as a 128x64 display.

I chose the S3 mainly because HUB75E needs quite a few GPIOs, while I also wanted WiFi, a web interface, OTA updates and enough headroom to keep animations running smoothly.

The display is driven with ESP32-HUB75-MatrixPanel-DMA. I went with a DMA-based library because I didn't want panel refresh timing to take over the main application loop, especially once WiFi, networking and animations were running at the same time.

There are 12 different clock faces now: Mario, Pac-Man, Tetris, Space Invaders, Snake, Asteroids, Dino, Matrix Rain and a few others. Most of them have their own animation whenever the minute changes.

The ESP32 also handles weather data, a web-based configuration page, GIF/custom animations and OTA updates.

I also wrote a small Windows companion app because apparently the clock wasn't complicated enough already. It can send CPU/GPU/RAM usage and temperatures to the display, and it can capture whatever audio is currently playing on the PC and send spectrum data over the network for an audio visualizer.

One of the more annoying parts was keeping everything smooth while network activity was happening in the background. Early versions had noticeable animation stutter, so quite a bit of work went into separating display updates from networking and keeping the render path lightweight.

The panels are powered directly from a separate 5V supply rather than through the ESP32, with shared ground between everything.

Demo is in the attached video. (4x speed so I can show all animations :))

Everything is open source, including the code and wiring/build info:
https://github.com/Keralots/AnimatedPixelClock

I also made a browser flasher:
https://pixelclock.stolaris.dev

I shoved an esp32 s3 into a altolids tin and heres what happened next!

https://www.youtube.com/playlist?list=PLgJKX8mp4p18ppYaszsPgn20gP01L1Byf

Parts:

ESP32-S3-WROOM-1 N16R8 — 240MHz dual-core, 16MB flash, 8MB PSRAM

2.3" ILI9341 TFT (320×240) driven over SPI with async DMA

Custom 30-key matrix keyboard — 3 rows × 10 columns

MAX98357A Class-D amp + small speaker for audio output

SD card for ROMs, music, movies, WADs

It boots into a DOS-style shell and you type commands to launch apps.

Apps so far:

- doom — DOOM via a PrBoom port

- nes — NES emulator (nofrendo fork)

- gb — Game Boy + GBC (gnuboy)

- mp — MP3 player with a file browser

- movie — plays MJPEG+MP3 AVIs from SD using a dual-core pipeline (demux+decode on core 0, JPEG decode+display on core 1). Has a portrait mode that software-rotates the frame so you can tilt the tin sideways to watch stuff

- radio — streams internet radio over WiFi (SomaFM, any Icecast HTTP stream)

- ask — Grok AI chat via xAI API, responds in synthesized voice through the speaker

- speak — HTTP endpoint so you can POST an MP3 and it plays it out loud

- eyes — animated googly-eyes avatar, because why not

- sats — a Fallout VATS-style targeting mini-app that locks onto a wireframe cockroach and plays a slow-mo kill-cam

- ota — type it and push new firmware over WiFi with a single curl command, no USB needed

Happy to answer questions about any of it.

I spent the last couple weeks building this minimalist, comfort and health-focused e-paper weather station. It uses a Seeed Studio XIAO ESP32-C3, a 4.2-inch e-paper display, a custom PCB, and a translucent frosted resin enclosure.

I managed to reduce the total active wake-up time from ~10 seconds to just 4.3 seconds per refresh cycle, using firmware optimisation techniques like HTTP Keep-Alive and static IP configuration. As a result, the built-in 1,500mAh Li-Po battery is estimated to last over a year and a half.

I wrote a detailed step-by-step building guide on Instructables and fully open-sourced the firmware and hardware files on my GitHub repository. I'll drop the link in the comment if you want to check it out!

ESP32 T-Display Screen Mirroring - Stream Desktop to a 1.14" LCD

I built a screen mirroring system that streams your computer display to an ESP32 T-Display over WiFi. It uses per-pixel updates with frame diffing on the tiny 135x240 display. It's not terribly efficient but it was a fun proof-of-concept.

What It Does

• Screen capture from your computer (any monitor)

• Streams to ESP32 over WiFi using a custom protocol

• Only sends changed pixels (frame diffing) to minimize bandwidth

• Overlays a cursor because macs don't include cursors in screen captures

Hardware

• TENSTAR T-Display ESP32-D0WD (aliexpress)

• 1.14" ST7789 LCD (135x240 pixels)

• ESP32 with WiFi

Performance

• Frame rates: 5-60 FPS depending on content and network (worse with many pixel changes better with few)

• Bandwidth: Only sends changed pixels

• Latency: <100ms end-to-end on good WiFi

Code & Documentation

Full source code, setup instructions, and documentation available on GitHub: https://github.com/tuckershannon/ESP32-Desktop-Monitor

Perfect for:

• Remote monitoring dashboards

• Secondary display projects

• IoT display applications

• Learning ESP32 + WiFi streaming

Built with Python (OpenCV, mss) and Arduino (TFT_eSPI library).

Here’s a quick demo of a working prototype:
An ESP32-controlled gate that allows only the robotic lawn mower to pass between front and back yard — but blocks the dog.

How it works:

• ESP32 scans for nearby Bluetooth devices

• It identifies the mower by selecting the strongest signal (RSSI-based) from previously observed devices

• If the mower’s tag is in range and signal is above threshold → gate opens

• No tag or weak signal → gate stays closed

• Gate is controlled via a simple relay to drive the actuator

• Entirely local logic, no WiFi or cloud dependency

• Took one weekend of fun to get it working

Lightweight, low-cost, and solves the problem: mower goes through, dog stays put.

Happy to hear feedback or suggestions.

I wanted to share a project I just completed where I retrofitted my regular dehumidifier with WiFi control capabilities using an ESP32.

Project Details

I've been diving into electronics in the past year, and as a learning project, I wanted to turn my standard dehumidifier into a smart device without relying on proprietary apps.

The technical implementation:

• Used an ESP32 to create a simple HTTP server that receives commands over WiFi

• Connected GPIO 5 to a 2n3904 transistor circuit that simulates pressing the capacitive touch button on the dehumidifier's PCB

• Created a specific circuit with 1N4148 diodes to properly trigger the capacitive sensor (this was tricky)

• Powered the ESP32 using an unused 5V port on the dehumidifier's PCB

• Mounted everything in an empty space under the main PCB

The most challenging part was figuring out how to trigger the capacitive touch sensor - I initially thought it was a simple mechanical connection until I realized it was responding to my finger without any electrical contact. After some research and experimentation with different circuit designs, I found a solution using the diode arrangement.

I've created a simple web interface (basically just a big green button) that lets me control the dehumidifier from anywhere on my local network. The ESP32 has plenty of GPIO pins to spare, so I'm considering adding temperature and humidity sensors to create a more comprehensive dashboard.

If you're interested in the full build process, check out my detailed write-up here.

I'd be happy to hear any feedback if you have it!

It is based on an ESP32 N16R8 with a 4G simcom modem, specifically the A7682E, with the ability to make phone calls, sms (soon), and take pictures with a 2MP ov2640, and a 3000mah battery! This is my first prototype pcb before things get serious, so don’t mind that lots of things are a module and not a bare chip.

ESP32-S3 Touch AMOLED 1.75C development board. Over four evenings, it somehow turned into a surprisingly nice little thingy.

UPDATE: this is now open source:
https://www.reddit.com/u/vadmalis/s/VbrUUvJCtW

It was very much a vibe-coding project. I guided some visuals, and forced optimization implementation decisions: how the display buffers and PSRAM should be used, which regions should be redrawn, how assets should be cached, and how animation should remain separate from slower network updates.

Getting beyond a basic mockup was a large part of the work: smooth radar and aircraft animation, partial screen updates, cached maps and imagery, and avoiding expensive full-screen redraws on the 466 × 466 gorgeous AMOLED.

It currently includes:

• Live nearby-aircraft radar with type-specific icons and detailed views

• Selected-flight tracking with world-map and custom 6-to-12 projections

• Weather, forecast, and animated weather radar

• GMT watch and world clock

• Solar-system, lunar-phase, and live ISS views

• NASA, Roscosmos, SpaceX crewed and Starship launch tracking

• Automatic Dock Mode

• A swift macOS companion app. Mainly for pre-render of the maps with different projection and to supply the list of flights to track.

There are still things to polish, but I’m amazed by how much this little ESP32-S3 can handle when the rendering pipeline is designed carefully.

I put this together a couple months ago. It was impressive to see what kind of beating the ESP32 can take and also fun to work with 01005 components. I made the hardware open source to see what use the community can come up with. Checkout the GitHub link if you'd like to build one yourself or for more info!

Akira! On Esp32-c6 waveshare screen.

Adapt the code to play multiple mjpeg videos in a loop from SD card.

mp4 videos convert with ffmpeg

All credits works to https://www.instructables.com/Train-Scene-Decoration/

I had this ceiling-mounted shower head that looked nice but was always too high, and eventually it started leaking. So I removed the rubber nozzles and replaced them with addressable LEDs behind the holes.

I then added a OneWire temperature sensor on the shower pipe, extended the shower arm, and installed a new shower head at a more reasonable height.

Now the old shower head acts as a ceiling-mounted temperature display while the new shower head does the actual work. The LEDs show the water temperature before stepping in, and the color changes gradually from blue when cold, through white around comfortable temperature, to red when hot.

Coding was a 10 minute job using AI: I told it was a string of addressable LEDs arranged into two 5x8 dot matrix display on GPIO 2 and a one-wire temperature sensor on GPIO 12, how how color should change based on temperature,

It was a fun little ESP32 weekend project, and much more useful than the leaking shower head it replaced.

"Halcyon Dawn" is a fanfic starship bridge game set in John Scalzi's "Old Man's War" universe. For the last year this thing has been my labor of love. I designed and built every detail of the hardware and software from scratch, including:

1. An entire family of USB console interface boards called "Enigma". They're deliberately generic (some panels have up to 3 Enigma boards inside them) rather than purpose-built so that I can use them on future projects, including escape room puzzles. I love escape rooms. The Enigma hardware is all open source, so if someone builds puzzles I get to play, all the better.

2. An associated Python-based game infrastructure library also called Enigma that includes the USB interface abstraction, in-game device simulation infra, remote pub/sub display screen integration, and an extremely robust multi-layer audio mixing system with haptic support. This too is open source.

3. The Halcyon Dawn game itself, a complex starship systems simulator. Far in the distant past I wrote commercial video games and adventure game development languages. Halcyon Dawn is vastly, vastly more complex and I'm quite proud of it. The game itself will never be released, in part because nobody else has the expensive simulator frame it requires (there is no way on this blue Earth I could be convinced to build another), and also Scalzi's "don't make money off my stuff" rule.

Build link and repo link in comments.

Found this jewel on Taobao. Appears to be a bunch of ESP32 dev boards plugged into a USB hub. Second pic is the product description (yes, the seller included an English version for whatever reason) I would assume powering the LEDs costs more than what this can mine lol. People appear to be actually buying these too 😅

Searching through this sub, a number of people have asked if mining with ESP32s is possible. Well here you go, someone out there is doing this! XD

Disclaimer: I don't know a thing about mining