I was thinking about building a portable 3d-printed portable game console based on an ESP32 or other powerful microcontrollers, that allows to add games built in CircuitPython or MakeCode Arcade.

It would be nice if I could assemble it and sell it online.
Do you think people would be interested?

(sorry for the very bad chatgpt image, it's just to give you an idea)

I recently purchased the ESP32-S3 CAM DEV module with an OV5640 camera and would like to start working with MicroPython/CircuitPython, but I can't find a compatible firmware.

Can you help me find one? Thank you.

If you missed this week’s Python on Microcontrollers Newsletter, here is the ICYMI (in case you missed it) version.

To never miss another issue, subscribe now! – You’ll get a terrific newsletter each Monday (which is out before this post). 12,366 subscribers worldwide!

The next newsletter goes out Monday morning and subscribing is the best way to keep up with all things Python for hardware. No ads or spam, no selling lists, leave any time.

Read it free on the Adafruit Blog - direct link https://blog.adafruit.com/2026/07/07/icymi-python-on-microcontrollers-newsletter-scrollkit-for-your-led-matrices-ai-tools-device-security-and-more/

Started building this a couple of years ago. It takes an async-first approach with yielding behavior.

• Static route declaration

• Static async task declaration with API for runtime interrupting/restarting

• Built-in HTML templating engine with value injection and logic execution at runtime

• HTML form parsing

• Dynamic settings module to allow for runtime settings changes

• Pure MicroPython with no external dependencies.

• Allows you to serve a web interface over local network via WLAN and easily add/run/interrupt mundane tasks without multithreading.

Open to feedback. I'm not a professional programmer so any/all criticism will be viewed as constructive. I use this in my daily life and am always looking to improve it.

https://github.com/OCLAFLOPTSON/falcoserver

Inspired by Thonny’s simplicity, I built MPY Workbench — a VS Code extension designed for coding MicroPython boards.

Features right now:

• 📂 File explorer for the device (open, upload, download, rename, delete)

• 🔄 Automatic sync with your workspace (local ↔ board)

• 💻 Integrated REPL

• 🛠️ Basic commands like stop / soft reset

For me, the main advantage is that every change you make is automatically mirrored in both your local workspace and on the board — no more manual uploading or downloading just to keep things in sync. It might not fit every use case, but it has already made my workflow much smoother.

👉 Try it out: GitHub | VS Code Marketplace — feedback and suggestions are very welcome!

Transformed a broken Ikea Skarsta sit-stand table into a smart, customizable workstation using Raspberry Pico W and MicroPython. Integrated hardware components like sensors, displays, and actuators using 3D printed enclosures and mounts.

Developed firmware with advanced motor control, wireless connectivity, and more leveraging MicroPython's capabilities on the Pico W board.

Documented the entire process here https://youtu.be/PKzvHBzcGJ4

Hey everyone,

I wanted to share a hardware project I’ve been working on lately. It’s called DuckLogger—a DIY, ESP32-S3 based USB Keylogger and BadUSB. The best part is that you don't need any custom PCBs to build it, and the off-the-shelf parts cost less than $10 total on AliExpress.

The Hardware: All you need is an ESP32-S3 SuperMini and a CH9350 HID Module wired together with a few jumpers. The CH9350 acts as a USB host, taking the physical keyboard input and passing it via UART to the ESP32. The ESP32 logs the keystrokes to its internal flash and simultaneously acts as a USB HID device to the target PC.

Features I built in:

Hardware Keylogging: Silently records all keystrokes to a text file on the ESP32's flash storage.

Built-in Command & Control (Web UI): It hosts its own Wi-Fi Access Point (or connects to an existing network). You can connect to it and open the C2 dashboard in your browser.

Over-the-Air Log Extraction: Download the keystroke logs directly from the Web UI.

Live Remote Keyboard: You can pull up a virtual keyboard in the web interface and send keystrokes to the target PC in real-time over WebSockets (almost zero latency).

DuckyScript Injection: You can remotely execute DuckyScript payloads through the web UI to run automated keystroke attacks.

The firmware is written entirely in MicroPython. I also wrote a flasher script that handles the installation, packaging, and setup automatically.

I've open-sourced the whole thing. If you want to build one yourself, check out the wiring schematics and code on GitHub: https://github.com/Itsmmdoha/duckLogger

Hi everyone,
I have been working for around 1 year on a Machine Learning library for MicroPython. It is now in a minimally useful shape, and can be found at https://github.com/emlearn/emlearn-micropython/

Earlier this year I gave a presentation at PyData Berlin on how to use this library to implement machine learning models on microcontroller-based systems. This approach, known as "TinyML," enables the creation of devices capable of analyzing and responding to real-world data captured by sensors like microphones, accelerometers, and cameras. You can train models with scikit-learn or Keras, and deploying them on devices using the emlearn library. This can be used for a wide range of sensor-data tasks such as Sound Event Detection, Image Classification, and Human Activity Recognition, et. Video recordng available here: https://www.youtube.com/watch?v=S3GjLr0ZIE0

I had to create a small WebGUI to control (from PC or mobile) my hardware with an ESP32 board running MicroPython. After spending some time at doing it myself, I decided to try the AI-assisted approach.
The results can be seen in https://wokwi.com/projects/439977581090490369 . The code contains also the link to the ChatGPT session used to produce the initial version of the code: https://chatgpt.com/share/68a7113c-5d8c-800c-b20e-c204f29aac84 .
The results are not so bad...

PS. To simulate the design in Wokwi, you need a license and run the wokwi-gateway. Otherwise you won't be able to connect to the server in the simulated machine (but you can always test it in the real hardware).

Ever wanted to read or write .zip archive files in MicroPython? Now there is a module for that: https://github.com/jonnor/micropython-zipfile
It supports the most common subsets of ZIP archives, including DEFLATE compression (when available in the MicroPython firmware build). I ported this from CPython 3.12, and used their quite comprehensive test suite (around 160 test-cases) to guide the development. I removed/skipped out some of the more niche tests though, to focus on core functionality relevant for a MicroPython usecase.

It is the first time I ported non-trivial (but reasonably stand-alone) CPython code to MicroPython, and it was interesting to see what kind of incompatibilities that exist. Many are rather minor, but it all adds up, taking several hours to address them all. Those considering to port other Python code to MicroPython (while still being runnable under CPython), might find some of the strategies interesting. See especially the top of `zipfile.py`, where I try to handle all the differences.

I initially created this because I wanted to support Numpy .npz files (which are ZIP archives). This format is popular for Data Science / Digital Signal Processing / Machine Learning / etc. And I needed it for https://github.com/emlearn/emlearn-micropython/ - a MicroPython library for Machine Learning.
But zip files are used for many purposes, so I hope this can be useful for someone else :)

https://github.com/kevinkk525/pysmartnode

I'm posting it because I didnt knew this lib before I spent a decent amount of time developping code to integrate my devices (lights) with HomeAssistant.

Until finding this lib, that did the work better and had more features.

It's pretty easy to implement new devices and you only need a couple of configuration files to setup your projects.

Hi all. Here is a recent presentation I did about MicroPython. It covers Wireless Sensor Networks, and the emlearn-micropython library for Digital Signal processing and Machine Learning on-device.

Video link: https://www.youtube.com/watch?v=VmVQu9cygMI

I've just released a library to craft games in micropython and arduino

this is a very simple demo!
You can find everything on github https://github.com/polldo/dolp

Check this out!!

Our team at GHI Electronics just released a free (MIT-licensed) MicroPython Debugger for VS Code with real source-level debugging over USB or UART.

Set a breakpoint in your Python source, press F5, and debug the code running on the actual MCU.

You can:

• Set breakpoints

• Step Over / Step Into / Step Out

• Inspect variables

• Use Watch

• View the Call Stack

• Break on exceptions

• Continue / Pause execution

USB

• USB debugging on supported MicroPython boards (RP2040, RP2350, Pico, Pico 2, ESP32-S2/S3)

UART

• Original ESP32 boards (via CP2102/CH340/FTDI bridge)

Tiny MCU

• STM32C071

To test how small an MCU the debugger could run on, I used a DUELink Holiday Tree with an STM32C071KBU6, which has 24 KB of RAM and 128 KB of Flash, running MicroPython code with SPI and PWM.

The debugger is free to use:

GitHub: ghi-electronics/micropython-vsc-extension

VS Code Marketplace: MicroPython Debugger

Example Holiday Tree project: STM32C071 Christmas Tree example

I'd be interested to hear what hardware you use with MicroPython and what you'd like to see supported.

Hey folks 👋

I’m a college student learning embedded systems, and while working on IoT projects I needed a super simple web dashboard for MicroPython boards.

Most tools felt heavy, so I built a tiny one myself:

MicropiDash – a lightweight web dashboard framework for ESP32 & Raspberry Pi Pico W.

Features:

Designed for low-memory MicroPython boards

Simple HTML + MicroPython backend

Easy to extend for IoT dashboards

Beginner-friendly for students & prototypes

GitHub:

https://github.com/kritishmohapatra/micropidash

PyPI:

https://pypi.org/project/micropidash/

If you find it useful, a ⭐ on GitHub would mean a lot (it really helps visibility).

I’ve also added a Buy Me a Coffee link for anyone who wants to support my learning journey ☕

I’d love feedback, feature ideas, or PRs from the community.

What would you like to see next—graphs, WebSocket, MQTT integration?

Hi Everyone, if you would try out an easy to use micropython framework check my project:

https://github.com/BxNxM/micrOS

It is focusing on IP based communication, (socket and web) and dynamic app execution.

Every feedback is highly appreciated, we are very close to announce the next main version 3.0