The Inky Impression running off a Pi Pico Plus 2 W on battery is a lovely idea, but the software side is where most makers get stuck. A refresh loop that takes 25 seconds and pulls two amps burns through a LiPo in a weekend. We looked at seven tools that keep the power envelope in check while still giving you a real dashboard to look at, from Python IDEs that make deep sleep straightforward to dashboard servers that generate the frames a low-power display can afford to redraw.
What to look for in an e-ink development stack
Battery-powered e-ink builds have a specific set of constraints, and the tools you pick either help you respect them or fight you.
- Deep-sleep support on the target microcontroller, not just “sleep” that leaves peripherals on
- Cross-compilation from a full desktop where debugging is bearable, not tiny screens over serial
- A way to render dashboard frames on a server so the Pico only handles the wake-and-draw cycle
- Support for the display’s exact refresh mode (partial vs full) to shave seconds off wake time
- A workflow that survives a device reboot, so the field-deployed frame recovers after a crash
- Open source, because you will need to read the driver code sooner or later
Quick comparison
| Tool | Best for | Platforms | Free | Starting price | Notes |
|---|---|---|---|---|---|
| Thonny | MicroPython beginners on Pi Pico | Windows, macOS, Linux | Yes | Free | Open source |
| Arduino IDE | C++ builds on ESP32/RP2040 | Windows, macOS, Linux | Yes | Free | Open source |
| PlatformIO | Serious cross-target work in VS Code | Windows, macOS, Linux | Yes | $15/mo (teams) | Open core |
| MicroPython | The runtime everything runs on | Runs on device | Yes | Free | MIT license |
| Home Assistant | Serving frames from a home server | Runs on server | Yes | Free (Green from ~$99 hardware) | Open source |
| MagicMirror² | Ready-made modular dashboard | Runs on server | Yes | Free | MIT license |
| Node-RED | Wiring sensor data to display frames | Runs on server | Yes | Free | Apache 2.0 |
1. Thonny, best for MicroPython on Pi Pico
Thonny is the IDE Pi Pico projects start with, and rightly so. It flashes the MicroPython firmware, opens a REPL on the board, and lets you save main.py straight to the device without a build step. For an e-ink build the important detail is that Thonny happily lets you drop into machine.lightsleep(seconds * 1000) and machine.deepsleep(...) while the debugger stays attached to the host side, so you can iterate on wake logic without pulling the USB every time. The plot panel is a nice bonus for battery-voltage traces.
Where it falls short: No proper C++ toolchain, so if your project outgrows MicroPython you have to move. Debugging past a hard fault still means reading the exception trace by eye.
Pricing: Free, MIT-licensed. No paid tier.
Platforms: Windows, macOS, Linux.
Bottom line: Start here. If your project stays in Python, you never have to leave.
2. Arduino IDE, best for C++ on ESP32 and RP2040
The Arduino IDE is the fastest way to compile a Pico e-ink firmware in C++ and get it under 40 kB. For the Inky Impression specifically, the community Arduino_GFX and the GxEPD2 libraries cover most of the Pimoroni display line, and you get real interrupts and DMA for pushing frames faster than MicroPython manages. The board manager pulls in the Earle Philhower core for the Pico, which is the one you want if you care about USB and Wi-Fi coexistence on the Pico W and Pico Plus 2 W.
Where it falls short: The editor is basic by 2026 standards. Serial monitor is fine, but any real refactor pushes you out.
Pricing: Free.
Platforms: Windows, macOS, Linux.
Download: Arduino IDE | GitHub (arduino-ide)
Bottom line: Pick this if you need the last ounce of battery life and are comfortable in C++.
3. PlatformIO, best for real project structure
PlatformIO lives inside VS Code and treats microcontroller work like normal software: a platformio.ini, a src/ folder, a lockfile for library versions. For an e-ink dashboard that pulls a rendered frame over Wi-Fi, PlatformIO’s dependency management keeps GxEPD2, the Wi-Fi stack, and the HTTP client on versions that actually compile together, which is the kind of misery Arduino IDE hands you when you upgrade a core. It targets both RP2040 and ESP32-C6 from the same config.
Where it falls short: The registry is smaller than Arduino’s, and a few Pimoroni-specific libraries need a lib_deps git URL rather than a package.
Pricing: Free open core. PlatformIO Labs (organization dashboards, RTOS insights) starts at $15 per seat per month.
Platforms: Windows, macOS, Linux (via VS Code).
Download: PlatformIO | VS Code Marketplace
Bottom line: The right choice once your firmware has more than one file.
4. MicroPython, the runtime worth committing to
MicroPython is not an app, it is the runtime that turns a Pi Pico into something you write scripts for. The Pico Plus 2 W port supports Wi-Fi through network.WLAN, HTTPS through urequests, and framebuffer writes fast enough for a partial refresh on an Inky pHAT. The deep-sleep functions actually cut current below 1 mA on the RP2350, which is what you need for months of battery. Community forks add Bluetooth LE and slightly better filesystem behaviour after a brownout.
Where it falls short: Startup takes a couple of seconds, which cuts into your battery budget on frequent wake cycles. For every-30-seconds refresh, C is still the answer.
Pricing: Free, MIT license.
Platforms: Runs on-device.
Download: MicroPython | GitHub
Bottom line: The default runtime for anything battery-powered on the RP2040 or RP2350.
5. Home Assistant, best for serving the dashboard frame
Once your Pico can pull a PNG over Wi-Fi and paint it, you need something on the server side to produce that PNG. Home Assistant is the obvious pick because it already has the sensor data, calendar, and weather that you probably want on the dashboard. Its Lovelace dashboards can be screenshotted server-side into a Pico-friendly resolution using the browser_mod add-on, or you can drop a custom template that renders the exact PNG the Pico requests. Home Assistant Green makes this practical without a full home lab.
Where it falls short: The initial setup is real work. Expect an afternoon before the first frame lands on the display.
Pricing: Free software. Home Assistant Green hardware starts around $99. Nabu Casa cloud remote access is $6.50 per month if you need it.
Platforms: Runs on any server (Linux, macOS, Windows via Docker, or on Home Assistant Green / Yellow hardware).
Download: Home Assistant | GitHub
Bottom line: If you already run Home Assistant, this is the shortest path to a good dashboard.
6. MagicMirror², best when you want a ready dashboard
MagicMirror² was built for two-way mirrors, but the module ecosystem, weather, calendar, transit, news, plus a lot of one-off community modules, is exactly what a battery e-ink display needs. Point a headless Chromium at a MagicMirror instance, screenshot it at your target resolution, run it through Floyd-Steinberg dithering, and you have a frame the Pico can paint in six seconds. The layout is JSON, so different Pico frames can render different regions of the same instance.
Where it falls short: MagicMirror expects to be rendered at 60 fps behind a piece of glass. Getting a clean single-frame screenshot needs a small headless-Chrome wrapper.
Pricing: Free, MIT license.
Platforms: Runs on Node.js on any server. Also runs on Raspberry Pi OS.
Download: MagicMirror² | GitHub
Bottom line: Pick this if you want a working dashboard by dinner and are willing to script the screenshot step.
7. Node-RED, best for wiring sensor flows into a frame
If your e-ink display shows something more custom than “weather and calendar”, Node-RED is where the plumbing lives. Drag an MQTT input from the sensors, a function block to transform, an image-render node to produce the PNG, and an HTTP endpoint the Pico polls. For a battery build, Node-RED can also expose a next_wake_seconds field the Pico honours, so a quiet period lets the device sleep longer instead of polling on a fixed schedule.
Where it falls short: The Node.js runtime is heavier than what you would run on a Pi Zero if that is the server. Prefer it on a home lab machine, not the same Pi that hosts the display.
Pricing: Free, Apache 2.0. Node-RED Dashboard 2.0 is also free.
Platforms: Any Node.js host (Linux, macOS, Windows). Runs well on a Raspberry Pi 4 or better.
Bottom line: The glue between sensor data and the frame your display draws.
How to pick the right tool
If this is your first battery e-ink build, install Thonny and MicroPython on the Pico, then serve a static PNG from any web server. That is the shortest loop to first light, and the one where most projects break.
Once the display works, put the dashboard on Home Assistant if you already run one. If not, MagicMirror² takes an evening to stand up and the module library will do most of what you want.
Move to Arduino IDE or PlatformIO only when your MicroPython version cannot hit the sleep target. That usually happens around a two-minute refresh interval on a small LiPo. For longer intervals, Python is fine and easier to hand off later.
Node-RED enters the picture when the frame becomes conditional on live data, presence detection, energy prices, or a family calendar with per-person filters. Below that complexity it is overkill.
FAQ
Can a Pi Pico Plus 2 W really run an Inky Impression on battery?
Yes, that is exactly what the recent XDA build showed. The trick is not the Pico, it is the display’s refresh current and the wake interval. A 7.3-inch Impression pulls around 100 mA for six or seven seconds during a full refresh, then drops to microamps. On a 2000 mAh LiPo with a 30-minute refresh, you are looking at weeks per charge.
Do I need Home Assistant, or is MagicMirror² enough?
MagicMirror² is enough for weather, calendar, transit, and news. Add Home Assistant when you want the display to reflect physical state, is the garage door open, did the last person leave, is the dishwasher done. If you already run Home Assistant, use it and skip MagicMirror².
Why not run everything on the Pi Pico itself?
The Pico can render simple text and icons directly, but the moment you want a full styled dashboard you are re-implementing HTML and CSS in a microcontroller. Pre-rendering a PNG on a proper machine and having the Pico paint it is the pattern that scales.
Is MicroPython slow enough to matter for battery life?
Startup is a couple of seconds, which matters at short wake intervals. At a 15-minute interval or longer, the difference between MicroPython and C is invisible on the battery gauge.
Which display driver library should I use?
For most Pimoroni Inky boards, the official Pimoroni MicroPython library covers everything. In C++ on Arduino or PlatformIO, GxEPD2 supports the widest range of panels with the least fuss.
