Running Linux 6.11 On The ESP32-S3 With A Few Tweaks

September 15, 2026 by Maya Posch 15 Comments

With the Xtensa Lx7 twin CPU cores in the ESP32-S3 running at a relatively zippy 240 MHz and accompanying PSRAM of up to 16 MB, you might find yourself wondering whether it could run Linux. As [Paulneja] demonstrates with Linux kernel 6.11, the answer is a ‘yes’, though with the usual caveats.

What complicates matters with the ESP32-S3 is that it lacks certain amenities that spoiled OSes like Linux have come to take for granted, such as a Memory Management Unit (MMU). To deal with this, the NOMMU Linux configuration was used, along with a custom fork() implementation. Although the previous 0.7 version sort-of worked, the current 0.8 release is the first that manages to actually boot reliably and has a usable amount of RAM available after boot.

You can see the comparison between the two versions in the header image, with v0.8 having a blistering 3.7 MB available after booting and with overall resource usage and performance having improved massively. Note that only one core is available to Linux, with the other used by the typical FreeRTOS ESP-IDF stack to provide WiFi and Bluetooth.

This was all run on an ESP32-S3 with the N16R8 configuration, meaning 16 MB Flash that’s also used for writable storage and 8 MB of octal PSRAM. As for practical applications, it’s noted by [Paulneja] that this is a research project, though one could imagine this being an embedded Linux project along the lines of a network router running something like BusyBox.

CircuitPython Goes Turbo With Precompiled Functions

September 14, 2026 by Tyler August 15 Comments

It would not be at all original to declare that Python is the new BASIC. Like BASIC, it has been the first programming language for a whole generation of coders, and its main advantage is that it’s quick and easy to write in. Like BASIC it is an interpreted language, and thus rather slow to execute.

Thus while CircuitPython can be very useful for beginners and quick projects, it hits the limitations of the hardware far sooner than it needs to — unless you can pre-compile critical parts of the code, which you now can, thanks to CircuitPython Turbo by [Mikey Sklar] with some help from Anthropic’s Claude LLM.

Now if that sounds a lot like MicroPython’s ‘Viper’ and machine-code compiler, that’s because it is. CircuitPython is a fork of MicroPython with some handy extras on Adafruit boards, but Viper wasn’t one of them until now. Before the Turbo version, CircuitPython only ran in interpreted mode.

Like MicroPython, using CircuitPython Turbo you can flag sections to run as ‘native’, where instructions are compiled but values stay as python objects, which gets you about a 3X speedup. A little more rewriting to declare your variables and pointers and you can use ‘viper’ mode, which can — depending on what you’re up to — result in a 20x to 70x speedup. In Adafruit’s documentation, they demonstrate a Metro RP2040 calculating the Mandelbrot set 3x faster in Native and 19.7 times faster with Viper than normal Python bytecode.

The one thing that we miss from BASIC that CircuitPython Turbo doesn’t give is inline assembly– though interestingly enough, that is in the upstream MicroPython implementation, so perhaps its day will come here too. Not every job is suited to the use of Python on microcontrollers, but we’ve seen it used for everything from e-bikes to a Winamp-inspired music player.

Lara Croft On A Microcontroller

September 10, 2026 by Zoe Skyforest 16 Comments

Once upon a time, you had to carefully budget your microcontroller’s resources if you wanted to do something as simple as flash a bunch of LEDs. These days, they’re powerful enough to humiliate the game consoles of yesteryear. [alexkid77] demonstrates this well, having the ESP32-P4 run Tomb Raider.

Now, [alexkid77] hasn’t gone so far as to create a PlayStation emulator on the ESP32 or anything quite like that. Instead, this is a port—and not of the original Tomb Raider release, either. [alexkid77] started with OpenLara—the classic game running in an open-source engine. With the ESP32-P4 having two cores running at 400 MHz each, there was plenty of processing power on tap to run the engine with a software renderer at 320×240, which is hardware scaled up to 1024×600 via the Pixel Processing Accelerator (PPA) built into the chip. There’s also stereo audio with an ES8311 codec hooked up, while input is via a USB HID keyboard.

It’s funny to think that it could actually be cheaper and quicker to get Tomb Raider running on an ESP32 and a cheap LCD display versus actually going out to buy a PlayStation and an original game disc. But that’s the way the cookie crumbles in 2026. At least you don’t have to play it on an S3 Verge. Continue reading “Lara Croft On A Microcontroller” →

Voicebox FX Is A Blueprint For CircuitPython I2S Audio

September 5, 2026 by Donald Papp 1 Comment

[Adafruit]’s Voicebox FX gadget is a fun, well-documented project that serves another useful purpose: being a fantastic reference design for audio on CircuitPython, with I²S audio components. Be sure to check it out if you have a project that involves any of that and could use a few pointers, or if you just want to jog a few ideas loose.

I²S (Inter-IC Sound) is a protocol aimed squarely at moving audio data between components as digital signals. Our own [Jenny List] can tell you everything you need to know about I²S. It’s a relatively simple interface that is not at all fussy about actually being used for audio, and that has led to it being put to some unusual uses.

The Voicebox FX uses an I²S microphone, an I²S amplifier, and an RP2350 microcontroller to record and play sound as well as offer a variety of effects controlled by physical inputs. It’s all wrapped up in a slick 3D printed case, and while it’s a fantastic reference design, it looks like a fun toy in its own right.

Continue reading “Voicebox FX Is A Blueprint For CircuitPython I2S Audio” →

Hackaday Europe 2026: Fluid Kernels And Optimizing C++ For MCUs

September 3, 2026 by Zoe Skyforest 6 Comments

Oftentimes, when we’re using a microcontroller, we’re whipping up some very specific code focused on executing a particular task. The device is set up to execute code that does exactly what we want with minimal overhead. However, sometimes, there are scenarios where it pays to go with a somewhat heavier setup, wherein the microcontroller runs an operating system for the benefits that offers.

Federico Terraneo came to Hackaday Europe to discuss this very topic. He talks about kernel architecture, real-time operating systems, and how to best use C++ in the world of microcontrollers.

Continue reading “Hackaday Europe 2026: Fluid Kernels And Optimizing C++ For MCUs” →

Wikipedia On A Cheap Yellow Display

August 29, 2026 by Jenny List 6 Comments

The Cheap Yellow Display (CYD) is a board carrying a slightly older ESP32 variant, a display with a resistive touchscreen, an SD card, and not much else. It’s often used for straightforward microcontroller applications that need a user interface, but that’s not the limit of its possibilities. [Alun Morris] has a CYD on which you can brows an entire offline Wikipedia.

The trick is to take the offline Wikipedia builds from the Kiwix project, and process them further into a custom format suited for a browser firmware on the ESP32. A modern SD card can hold so much data that a full Wikipedia is well within its abilities even with images included.

We like this idea, because it takes the knowledge away from the center of the network to its edge. We expect to see it gaining a following among enthusiasts for offline living, because all that knowledge without a network can only be useful. If you recognize [Alun]’s work, it might be because of his ESP32 web browser.

Mini Blinking Barrels Keep Desktop Traffic In Check

August 19, 2026 by Tom Nardi 19 Comments

Your desk or bench is a work area, so why not make it look the part? That’s the idea behind the miniature blinking traffic barrels that [Glen Akins] recently put together. Of course, just a single blinking light doesn’t really sell the idea of a busy construction zone, so he spent a somewhat surprising amount of time and effort optimizing the design for small-scale production.

The end result is a fascinating write-up that dives into the design decisions [Glen] made. Every aspect of this project, from the overhang of the “handle” on the 3D printed barrel to the number of passive components on the PCB was carefully considered. Critics may say [Glen] put too much thought into something that didn’t need to be so complex, but projects like these are an excellent way to keep your skills sharp — there’s no such thing as practicing too much.

Starting with the design of the barrel itself, we appreciate that [Glen] kept the capabilities of his desktop 3D printer in mind. By breaking the design up into multiple pieces and avoiding overly steep angles, he produced a design that prints cleanly without the need for support material. His step-by-step documentation and screenshots also serve as a great introduction to designing parts in Fusion if that’s something you’re interested in.

From there, things switch over to the electronics. Some in the audience will bemoan that he’s using a PIC12F1612 microcontroller to blink a single LED instead of a 555, but [Glen] brought the receipts on this one. Not only does the PIC offer more flexibility in terms of getting the blinking to look the way he wants, but it requires fewer passive components on the board and is considerably more energy efficient than the iconic timer IC. Even if you ignore all the other advantages, he calculates that going with a 555 would have cut the battery life of the finished product by approximately 15%.

This is one of those projects that’s difficult to summarize in such a terse format, as every time you think the write-up must be about over it takes a new turn on you. We were mildly bemused when the second iteration of the PCB popped up, but by the time he introduced the custom programming adapter board, we knew [Glen] wasn’t messing around.

Unsurprisingly, this isn’t the first time we’ve seen [Glen]’s handiwork. You may recall seeing his RP2040-powered sound board earlier this year, but his name has been popping up on these pages for more than a decade now.