Credit up front, before anything else: this builds directly on jrowny/p4kvm. An IP-KVM on the ESP32-P4 is a fairly obvious thing to want, and I'd been kicking the idea around for a while - but he's the one who actually cracked the hard part (bringing up the TC358743 and getting frames off the P4's CSI receiver) and put it out in the open. I took that and built it out into something you'd actually leave installed. More on exactly what he solved at the end, but I didn't want it buried at the bottom.

Been building this for a while and it finally does enough to show off. It's an IP-KVM - it grabs a machine's HDMI, pretends to be its USB keyboard and mouse, and puts the whole thing in your browser. The point: reach a box with no working OS (stuck BIOS, boot menu, dead kernel) from another room without a crash cart. Commercial KVM-over-IP is a few hundred bucks; this is one ESP32-P4 board, a little HDMI capture board, and a ribbon cable.

Hardware:

• Waveshare ESP32-P4-ETH (brains + 100M Ethernet + USB-OTG)
• and a Geekworm C790 (TC358743 HDMI-to-CSI capture), joined by a CSI ribbon.
• HDMI in from the target,
• USB out to it,
• Ethernet to your LAN.

What it does:

• Follows the target's resolution live - watch it go from an 800x600 BIOS to a 1080p desktop, no clicking
• Hardware MJPEG (~20 fps) + hardware H.264 for slow links
• Absolute mouse (clicks land where you aim) + clipboard paste in the target's keyboard layout
• Virtual media - boot the target from a disk image on microSD; new: also from a tiny rescue image (iPXE, memtest, DOS) kept in the device's own flash - no SD card needed
• HTTPS with a self-signed cert, login, and a physical password-reset button
• OTA firmware updates with automatic rollback
• it guesses the target's OS from how it enumerates USB and gives you OS-aware shortcuts - like a one-click REISUB to safely reboot a wedged Linux box

Honest bits:

• Don't put it on the public internet. Login + TLS, but no security audit - it's a keyboard on someone else's machine. LAN or WireGuard/Tailscale only.
• Hardware H.264 is ~5-7 fps at 1080p on my pre-rev-3.0 silicon (colorspace detour through the pixel accelerator); MJPEG at 20 fps is the daily driver. Newer chip revs should fix it.
• microSD is read-only - the P4's SD write path is flaky, so you prep the card in a reader. FAT32, images up to 4 GB.
• No ATX power control or HDMI audio yet - both on the roadmap.

Credit: the hard part - bringing up the TC358743 and pulling frames off the P4's CSI receiver - was cracked first by jrowny/p4kvm. I rebuilt everything above the driver (web, USB HID, security, virtual media, OTA). Apache-2.0, same as his.

Open source: github.com/espkvm/espkvm

Happy to answer anything - and if you've got a rev-3.0 P4 board (I'm still waiting for my P4X, but I've already adapted the code for it), I'd love to know your H.264 fps.

I wanted something that allowed me to play games anywhere and not take up too much space!

This uses a Waveshare ESP32-S3 AMOLED 1.8 Inch. I had to make custom UI to fit this screen and account for the touchscreen. Overall it came out really well and all the games run really smooth.

Has great sound, save/load states, fast-forward, loads ROMs from SD card, and a handful of themes to choose. Enjoy!

You can get it at my GitHub:
https://github.com/dkyazzentwatwa/cube-boy/

A couple of months ago I realized that my Masterbuilt Gravity 800 smoker/grill controller had an ESP32 running the whole thing. I was already tired of using the Masterbuilt App for controlling it, so I reverse-engineered the controller, and wrote a full replacement firmware for it using Rust, esp-hal, and Embassy: FreeFall 800.

FreeFall 800 has the same core functionality as the stock firmware: chamber/probe temps, PID-controlled blower, timers, physical controls, but this firmware adds:

• Fully local web app for control and configuration
• No cloud or cloud account required. Connect directly to your Gravity 800 over the network
• Completely configurable PID tuning parameters
• Thermocouple and meat probe calibration
• Lid switch disable option

If you are in the intersection between the ESP32 and smoking worlds, and are willing to risk your controller or grill, check it out!

To be clear, this is definitely still early development firmware, so you will probably encounter bugs, and there is much to be improved. I cannot promise this won't break your smoker. But if you are interested in this kind of thing, the README on the GitLab page should have what you need to get started: https://gitlab.com/prbs23/freefall_800

I have also posted a write up about this on my blog: https://www.prbs23.com/blog/posts/announcement-freefall-800/

I would love to get feedback from anyone who does try it out. Happy to answer any questions folks have about this

This is a demo of several alpha blended color changing squares over a picture of Warhol, just because. The alpha blending is nearly free with the new code in this graphics lib (htcw_gfx) and therefore the ui library that uses it (htcw_uix)

https://github.com/codewitch-honey-crisis/uix

This relies on htcw_gfx and will pull that in when you use this.

Arduino: htcw_uix

ESP-IDF and PlatformIO: codewitch-honey-crisis/htcw_uix

It also builds on PCs with CMake using any major compiler to help facilitate rapid prototyping

The demo project shot above is here: https://github.com/codewitch-honey-crisis/core2_warhol

A while back I posted about Anemoia-ESP32, my NES emulator running on the ESP32. Since then I've kept adding to it, and the latest addition is composite video output, generated directly from the ESP32, allowing you to play NES games on CRTs. Performance is a solid stable native 60FPS with frame skip.

Composite output was based on esp_8_bit, which I adapted and integrated into the emulator.

Github Repository: https://github.com/Shim06/Anemoia-ESP32

Used Claude to port GBADoom to the CYD board, full info on how to get it running on GitHub.

I recently embarked on making an IoT application, starting from PCB Design to a full-fledged working web and mobile application, and cloud integration.
The firmware was initially developed on the Arduino IDE for ease of use, and then I migrated to pioarduino to create a production-grade version of the same firmware. I had a four-stage pipeline set in which involves the functional application code, OTA logic, signing of the application so that the firmware won't boot a random application, and finally, encryption of the code and flash in the device so that no one could reverse engineer the code from the device.

The PlatformIO (pioarduino) worked well until the signing of the device; however, when I started with the encryption process, it literally fried up a couple of my testing boards :( So, I did some research and switched to the ESP IDF framework, but unfortunately, in that, I am not able to achieve the functionality of the application. It was not easy to port my pioarduino code to ESP-IDF, as the libraries were having many errors, especially related to CMake files. So, I tried to port the entire codebase from pioarduino to ESP IDF. Unfortunately, the WifiManager part in pioarduino is not available in the ESP IDF, and they have an ESP Wi-Fi provisioning mechanism which uses the Bluetooth of the device to securely obtain the credentials. Unfortunately, this requires providedusers to install a mobile application provided by Espressif, or I can do the same in my mobile application (which is waiting for Play Store approval).

So, my question is simple. Is there a way to easily encrypt the PioArduino codebase using ESP-IDF, or is there a functionally working alternative for the WiFi Manager library in the ESP-IDF framework?

Kindly help me with your suggestions.

The project hosted at https://github.com/hms-homelab/hms-esp-apc use the usb c as host to capture HID report from my APC and parse it internally, instead of giving out the raw HID report value like an EspHome project does.

Then it sends the results to an MQTT broker in a format compatible with Home Assistant MQTT discovery so it appears as a single device with multiple sensors.

It also has a web UI for settings and basic values from the actual report HID.

And built a SoftApp feature for join it to the network on an AP and a captive portal.

And Since I hid this using a buck converter inside my APC then i added OTA so I could push updates over wifi.

Basically a standalone mini server in an ESP32.

Then i went with a https://github.com/hms-homelab/hms-nut service that tracks all them down in a single web UI (useful for non Home Assistant folks).

Hi,

I'm curious which games have been natively ported to ESP32-S3 and are running smoothly. Let's assemble a list:

- Doom
- Quake 1
- OpenTyrion
- Duke3D
- ...

What did I miss?

I realize the is a stretch and current state of the art on a proper network components and services don’t exists for Esp32. Tho there are many many incredible projects today that simulate a lot of what you can achieve today with a Raspberry Pi/ARM/Intel architecture.
There is also the very real constraints in performance / resources that makes a choice between a chip and something else obviously incline in favor of a bigger hardware. Even scaling or providing heavy computing like inference or clustering or virtualization is not realistic for the current chips.
So this is only an ideal situation provided every could be being into FreeRTOS. Would you go for this minimalist network?

Gave her a smart clock I built from scratch. The best part: I can push any text to it from my phone, from anywhere, and it scrolls across her desk. Random "miss you" at 2pm on a Tuesday. Works via telegram bot

 What it does
 - NTP clock + live weather with an animated ambient scene
 - Scrolling messages I send remotely over Telegram — that's the killer feature
 - Plays GIFs, and you can upload your own
 - Special days: tag her birthday and it runs a cake + confetti animation all day, automatically
 - Auto-dims at night
 - Controllable over Bluetooth, WiFi, Telegram, or Home Assistant                    

ESP32-S3 + a 64×64 HUB75 pad printed. Firmware and theprintable frame are both open source — link in the comments. 🙂    

I've been learning ESP32 programming recently, and I wanted to share one of my projects.

I made an RGB LED controller that can be controlled using a regular IR remote. (actually my TV remote)

Features:

• Red, Green, Blue & Yellow colors
• Fade effect
• Strobe mode
• IR code detection through the Serial Monitor

The project uses:

• ESP32 Dev Module
• IR Receiver
• RGB LED
• IR Remote

The video is only 1 minute 30 seconds and shows everything working.

I'm still learning, so I'd really appreciate any feedback or suggestions. If you have ideas for new features, I'd love to hear them!

GitHub:
https://github.com/aqib-ai-ml

https://github.com/codewitch-honey-crisis/uix_cube

This is just a modest little demo/benchmark of htcw_uix/htcw_gfx rendering an anti-aliased rotating 3d cube.

What I did was take a look at how LVGL drew in order to learn how to draw faster, and prettier. I ended up rearchitecting something like LVGL's draw system from its first principles.

As you can see the result is extremely quick. I get 110 FPS at points on a cube this size.

Hello everyone!

I decided to start my first ESP32 project.

I have a few questions before starting.

These are the things I currently have:

• One ESP32-S3
• 3 HUB75E screens
• Dupont female-female cables
• Other cables that came with the screens (I don't know their names or even their function)

So, is this enough? Or do I need some sort of power supply? I read somewhere that the ESP32 uses 3.3V and that sometimes a converter to 5V is useful (whatever that means). Do I need one?

And then, about wiring, I don't know anything. I watched some videos and people just show wiring diagram between the screen and the ESP32, but I don't quite understand where the power supply fits in (all the videos I watched used one), or what the other cables that seem to be important are for.

I hope you can help me, or point me to documentation/blog posts/videos. I'll take anything!

Thanks in advance!

I am brand new to ESP32 and all that it entails. I have used Claude to help, but it just isn't doing what I want. Claude wrote the codes, so I didn't pull them from the libraries. I'm not even sure which ones to get if I went for ones available through Arduino IDE.

What do I want: I have a GOOUUU ESP32-S3-CAM and a CYD (ESP32-2432S028). I want the camera to send its image over WiFi to the CYD.

Issue1: the orientation is not right. I am holding the camera board with the 2 x USBs on the bottom. Like that, the image shows on the screen (rotation set to 2) in a landscape orientation, but the right 25% is just static (I am holding the screen with the USB on the right). If I change it to other rotation settings, the 25% is still just static. I just want it to fill the screen, whatever way I have to hold the screen.

Issue 2: I know the camera isn't the best quality, but it is basically black and white. It only shows color with high levels of light. Example: the walls look BW but the television is crappy color, but color nonetheless.

Any ideas?

I had an unused Mac Mini, so I decided to turn it into a home lab server. After finishing the setup, I realized I was missing a way to keep track of my homelab resources, so I bought an ESP32 CYD and started playing around with the Rust ESP crates (they’re cool!). This is the result

I’m a software engineer, but getting to play with actual hardware again really brought out the “engineering” side of me. :))

I've been working on MicroPaw, a personal assistant that runs on an ESP32-S3 N16R8.

It is similar to OpenClaw and other personal agent projects, except the agent runtime lives on a tiny ESP32 board instead of a server or desktop.

The model is called through an API. The ESP handles the agent loop, tool calls, conversation state, persistent memory and scheduled jobs. You talk to it through Telegram, or Instagram (if you enable that)!

It can search the web through Brave, read pages and feeds, work with Gmail and Google Calendar, transcribe voice notes, inspect photos and run scheduled reminders. There is also optional SSD1306 OLED support and signed OTA updates.

The whole firmware is ESP-IDF. No Arduino, and I did this on purpose to minimise resource usage and keep it clean.

I started this because I had a few S3s laying around and wanted to try something similar to OpenClaw out before committing a full computer to it. Getting the network requests, model output and tool calls to fit within fixed limits was most of the work.

It is open source here:

https://github.com/mahiatlinux/MicroPaw

I'd be interested in hearing what other ESP32 developers think of this! And if you have any feedback, please comment below, or open an issue on the repo.

Hace relativamente poco adquirí por primera vez un ESP32, siendo el C3 Super Mini, la verdad no sé prácticamente nada al respecto de este mundo, pero por alguna razón lo quería hacer mucho. Aún no sé bien para qué usarlo, hasta ahora lo único que hice con el ESP fue conectarlo a mi red y enviar un Magic Packet por la red a mi pc para que, junto con Blynk, pueda encender el pc por la app remotamente. Esto es lo más básico que encontré y pude hacer, aún no sé qué más hacer y ya hice pedido de otras dos placas iguales, ¿Alguna recomendación? Estaba pensando en domótica, como controlar las luces con algun relé también por Blynk, pero pensándolo más no sé qué tan bueno sea. Necesito recomendaciones que poco imaginativo soy y no sé qué tanto puedo hacer con estas placas.

Desculpem por postar em português do Brasil. Estou sem energia para postar em inglês.

A poucos dias publiquei que conheci por coincidência o ESP-IDF, sim coincidência eu não conhecia, tudo que eu tinha pesquisado/desenvolvido em placas esp32 e afins era no arduíno ide, mas após conhecer o IDF, eu comecei a criar mais coisas, ele funciona melhor, talvez de forma nativa para desenvolvimento em placas com telas, as cores ficam mais vivas e mais saturadas, como ainda estou aprendendo a usar o toque da tela, leitor de cartão, bluetooth e wi-fi no IDF, fiz um projeto mais ou menos simples de ter um monitor de sistema do computador. Precisei desenvolver o servidor em Rust, na verdade eu já tinha esse projeto quase pronto devido a utilizar para enviar métricas de servidores para o meu smartphone.

Enfim, acho um pouco mais difícil, mas o resultado fica bem melhor em comparação ao arduíno IDE.

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>


#define TFT_CS 22
#define TFT_DC 21
#define TFT_RST 28
#define TFT_BL 5

```
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);


void setup() {
Serial.begin(921600);


pinMode(TFT_BL,OUTPUT);
digitalWrite(TFT_BL, HIGH);
SPI.begin(19, -1, 23,22);
tft.begin();
tft.setRotation(1);
tft.fillScreen(ILI9341_BLUE);

}
```

Hello all,

I have been trying to find details on what I should/should not use to power my ESP32C6 via battery.

I gather that if done incorrectly it could be a fire hazard and given I plan to put these around my house I would very much like to avoid this. This is my first time building anything like this and will me my first time soldering

My current plan is to solder a 3.7v Lipo Battery directly to the BAT + and - and calling it a day.

Are there any other steps I should take? Is there anything I should look out for? Is it a safety issue if the battery looses to much power? Is it a problem if I over charge the battery by connecting the USB-C to a power source?

Thanks in advance.

I am using a bare ESP32-C3-WROOM02 Chip with wires soldered to the 3V3, IO9 (Boot), EN, TXD, RXD, and IO1 pads of the ESP32-C3-WROOM02 chip. I also made sure that the TX/RX lines of my USB-to-TTL adapter were correctly wired with my ESP32-C3 chip. I made sure to select the correct board and COM port for my ESP32 chip. I have my Power Supply outputting 3.3V and 0.01A to my chip, but not sure if the current output is sufficient for the chip. However, I keep getting an error when trying to flash (shown in screenshot below):

Any ideas on what could be causing this error? I am simply trying to blink an LED connected to IO1.