16 applications. A Daedric interface. Generative synthesis, wireless reconnaissance, experimental motion sensing, and a tiny browser for the forgotten internet. All running on an ESP32-S3.
There's something profoundly irritating about how boring computers have become.
We have absurd amounts of processing power. Graphics hardware capable of simulating realistic lighting. Neural networks that can generate entire applications while confidently inventing three nonexistent dependencies. Yet practically every interface looks like it escaped from the same corporate design meeting.
Rounded rectangles. Carefully selected shades of gray. A sidebar. Another sidebar. A button that used to do something useful but now opens a subscription page.
Your computer has sixteen cores and apparently the imagination of an insurance company.
Meanwhile, a tiny ESP32-S3 with a 240 × 135 display is perfectly capable of becoming a synthesizer, a network observatory, a procedural graphics machine, and a portal to the weirder corners of the internet.
So I built something called DIVINER.
It's a custom firmware environment for the M5Stack Cardputer ADV, containing sixteen applications inside a hand-crafted Daedric interface. Wireless networks become constellations. Bluetooth devices drift across the display like strange little familiars. Mathematical expressions produce audio. The menu is written in the fictional alphabet from Morrowind, and its glyphs dissolve into English when you navigate through it.
Some of the software is genuinely practical. Some of it is experimental. Some of it exists because I believe a computer should occasionally do something that makes you wonder whether it's entirely pleased to see you.
The complete source code is available here:
And the hardware project, build details, and development documentation live here:
The firmware is open source. There's a prebuilt binary in the repository, and a desktop simulator for anyone interested in exploring the software without owning the hardware.
But the part worth discussing isn't simply that I managed to cram sixteen applications into a small computer.
It's why I wanted to.
We Used to Let Computers Be Weird
There was a period when interacting with a computer felt like entering somebody else's peculiar universe.
Amiga workbenches. Macintosh System 7. Shareware applications with interfaces designed by people who had clearly never been introduced to a branding consultant. Late-night BBS systems. Software with obscure keyboard shortcuts, ugly but memorable icons, and documentation written like the author had personally declared war on conventional typography.
Not all of it was good.
A fair amount was objectively terrible.
But at least it was identifiable.
You could recognize an application by its personality. Interfaces weren't all desperately trying to disappear. Some of them practically demanded that you learn their internal logic.
I miss that.
I don't particularly want my computer to feel invisible. I want it to feel like an instrument.
DIVINER came out of that frustration, mixed with an unreasonable affection for Morrowind, Serial Experiments Lain, experimental music software, and tiny machines that look like they were designed to receive messages from abandoned satellites.
The idea was simple enough: stop treating the Cardputer as a miniature smartphone and start treating it as a completely different kind of computer.
Not a dashboard. Not a gadget full of unrelated demonstrations.
An environment.
The Hardware Is Ridiculously Small. That's the Point.
The M5Stack Cardputer ADV is built around an ESP32-S3.
It has a compact keyboard, a small color display, wireless connectivity, audio hardware, and enough interfaces to become surprisingly useful without attaching an entire graveyard of external peripherals.
Its screen contains exactly 32,400 pixels.
For perspective, that's not much real estate when you're trying to build a custom interface, display network information, render procedural graphics, and interact with multiple independent applications.
You cannot simply shrink a modern desktop interface down and expect things to work.
Every unnecessary panel becomes expensive. Every poorly designed menu becomes an obstruction. Every line of text needs to justify the pixels it occupies.
And that's when things get interesting.
Constraints force decisions.
A high-resolution monitor can conceal mediocre interface design under layers of padding and decorative nonsense. A 240 × 135 screen gives you nowhere to hide.
DIVINER uses the limitations deliberately.
The primary interface is dark, spare, and aggressive. A blood-and-ember palette. Sharp typography. Subtle audiovisual feedback. Animations that serve the interaction rather than existing to impress a design portfolio.
At least, that's the practical explanation.
The less respectable explanation is that I wanted the thing to look like a cursed piece of consumer electronics from 2001.
Sixteen Applications, or Sixteen Rites
DIVINER doesn't refer to its applications as apps.
It calls them rites.
Yes, that's theatrical. No, I don't particularly care.
They're organized into four domains: Sound, Sight, The Wired, and Wards.
The naming gives the environment a vocabulary of its own, but underneath it is fairly straightforward modular C++ software.
And the applications are not just variations of the same scanning utility.
Sound: Turning an ESP32 Into an Instrument
The first domain contains three separate sound engines.
DRONE is a five-voice generative synthesizer. It combines drifting voices, resonant low-pass filtering, wind-like textures, bell elements, and delay.
It's designed less for writing conventional melodies and more for generating evolving sound environments.
Think unstable ambient textures rather than cheerful ringtone synthesis.
SEQ is a miniature groovebox with kick, snare, hi-hat, acid-style synthesis, Euclidean fills, four pattern banks, song mode, and save/load functionality.
This is where the firmware starts becoming an actual portable musical instrument instead of a curiosity.
BEAT is a bytebeat livecoding environment.
If you're unfamiliar with bytebeat, the premise is beautifully deranged: mathematical expressions involving a time variable can generate audio samples directly.
A tiny expression can produce rhythmic structures, melodies, grinding digital noise, or something resembling a malfunctioning modem experiencing a personal crisis.
All without conventional audio samples.
DIVINER's audio path operates at 24 kHz on the device, with shared DSP utilities supporting its sound-generating applications.
One of the things I enjoy about this arrangement is that the machine doesn't require a computer to explain itself. You can type into the little keyboard and produce sound directly.
No DAW startup sequence. No plugin manager. No seventeen-minute tutorial on configuring an audio interface.
Just an expression and whatever strange noise emerges from it.
Sight: Mathematical Hallucinations
The second domain deals with procedural visuals.
WIRED renders ASCII-based 3D objects, including toruses, wireframe geometry, tunnels, and a navigation sphere.
VISIONS produces animated plasma fields, falling Daedric glyphs, an Oblivion-inspired gate, ash-fire effects, and a heptagram kaleidoscope.
ORACLE casts three runes accompanied by bell-like audio.
No, the rune generator will not predict your future.
Although if it starts correctly predicting compiler errors, I'll reconsider that position.
The graphics applications are interesting because so much visual character can emerge from relatively simple mathematical operations.
You don't need a sophisticated graphics pipeline to make something feel alive.
You need movement, timing, recognizable patterns, and a little willingness to be strange.
I've always liked the idea that procedural graphics are a form of visual synthesis. You're not displaying a completed image. You're describing the rules by which an image continuously comes into existence.
On a tiny display, that distinction matters.
The Invisible World Is More Interesting Than Your Home Screen
The third domain is where DIVINER turns toward networking.
And this is probably the part that will interest the hardware hackers and security researchers.
We spend our lives surrounded by wireless infrastructure. Access points, Bluetooth peripherals, local devices, broadcasts, background activity.
An enormous amount of communication is happening in the air around us, and most people experience absolutely none of it.
Their phone displays a Wi-Fi icon.
That's the entire interface to the invisible machinery surrounding them.
I find that weird.
DIVINER experiments with making that information visible, audible, and spatial.
SCRY transforms nearby Wi-Fi networks into a constellation.
KIN represents discovered Bluetooth devices as drifting familiars.
LISTEN provides receive-only channel monitoring with an audible representation of activity.
LINK handles conventional Wi-Fi connectivity, remembered networks, and captive-portal detection.
NET explores hosts, names, and exposed ports on a local network.
These tools don't all have the same purpose.
Some are diagnostic. Some are informational. Some are experiments in presenting familiar data through an unfamiliar interface.
The central question is whether a network scanner has to look like a network scanner.
Why should access points always appear as a depressing list of SSIDs?
Why couldn't their relationships become part of the interface?
An alternative visualization doesn't automatically make information more accurate or actionable. It can introduce new ambiguities, and that's worth acknowledging.
But the conventional presentation isn't sacred either.
Sometimes changing how information is displayed changes which questions you're inclined to ask.
And occasionally it just looks significantly cooler.
Both are acceptable motivations for making software.
Yes, It Has Experimental Wi-Fi Motion Sensing
The fourth domain, Wards, contains some of the more ambitious and technically uncertain work.
PULSE explores Wi-Fi Channel State Information, or CSI, for detecting changes associated with movement and presence.
The interesting concept here is that wireless communication isn't occurring in a perfectly static environment.
Signals reflect, scatter, and interact with physical surroundings.
When those surroundings change, properties of the observed radio channel can change too.
Under suitable conditions, CSI measurements can provide information related to motion.
This doesn't mean the Cardputer has suddenly acquired magical radar abilities.
Radio-based presence sensing is complicated. Multipath effects, hardware behavior, environmental noise, available traffic, and physical layout all influence what can actually be inferred.
An observed change does not necessarily mean a human walked past the device.
That uncertainty is precisely what makes it worth experimenting with.
I think there's something fascinating about repurposing a communications radio as a crude environmental sensor. It's the same physical hardware, but you're asking it a completely different question.
SENTINEL takes another approach to environmental monitoring.
It learns a baseline of nearby devices, then flags newly observed ones. It also looks for wireless indicators potentially associated with drones.
That last part needs a qualification: it's heuristic. A radio signature is not definitive proof that an object is a drone, and the absence of such a signature doesn't prove there isn't one.
Still, baselining a local wireless environment and watching for changes is an interesting foundation for experimentation.
PROBE adds active HTTP reconnaissance and default-credential checks for explicitly authorized hosts.
The firmware's security-oriented capabilities are intended for equipment and networks the operator owns or has permission to test. It doesn't implement phishing or denial-of-service functions.
The goal is observation and assessment, not turning a handheld computer into an indiscriminate nuisance machine.
We have enough of those already. Most of them are employed in marketing.
There's a Gemini Browser in Here Because Apparently I Have Priorities
This is one of my favorite details.
DIVINER includes GEMINI, a gemtext browser using TLS, with posting support.
Gemini, for anyone unfamiliar, is a lightweight document-oriented internet protocol with a much simpler model than the modern web.
It's closer in spirit to the idea that you should be able to retrieve and read a document without loading half a megabyte of JavaScript, asking permission to accept cookies, and being offered a discount on a newsletter you never wanted.
The Cardputer is an oddly appropriate place to browse it.
A small keyboard. A tiny display. Modest hardware resources.
Nothing about the device suggests that it should be pretending to run a full contemporary browser.
But Gemini doesn't demand that.
There's a satisfying symmetry to using a deliberately minimal computer to access a deliberately minimal part of the internet.
Modern web development has become an extraordinary exercise in industrial-scale complexity.
Sometimes I just want a page containing words.
Preferably without a chatbot asking if I need help finding the words.
The Most Useful Part Might Actually Be the Desktop Simulator
Here's the less glamorous engineering detail that deserves more attention.
DIVINER isn't built exclusively for the physical Cardputer.
It also has a native SDL2 simulator.
This is significant because developing embedded graphical software can be extraordinarily annoying.
Change a few pixels. Recompile. Flash the firmware. Restart. Navigate through the menu. Check whether the animation looks right. Discover that the animation still looks wrong.
Repeat until the sun goes out.
Instead, DIVINER separates application behavior from the hardware through dedicated abstraction layers.
The device implementation handles the actual Cardputer display, keyboard, and audio system.
The native implementation runs the interface on a desktop computer, reproducing the 240 × 135 display at an enlarged scale.
It also supports audio output, WAV recording, scripted input, and headless screenshot generation.
The native network implementation uses simulated data, so it isn't pretending to reproduce actual radio conditions. Wireless functionality still needs to be validated on the physical device.
But graphical and audio development can happen without constantly involving the hardware.
That's a meaningful architectural improvement.
It makes experimentation cheaper in time, which is often the most expensive resource in a project like this.
It also makes the firmware easier for other developers to investigate.
They don't necessarily need to own a Cardputer just to examine the interface or experiment with some of the application code.
For me, this is an important part of what open-source embedded software should be doing.
Not merely releasing code, but making the code practical to explore.
Building and Installing DIVINER
The firmware is written in C++ and built with PlatformIO.
The repository includes source code, build configuration, screenshots, interface previews, a desktop simulator, and a prebuilt firmware image.
To compile for the Cardputer ADV:
pio run -e cardputer
The generated firmware is located at:
.pio/build/cardputer/firmware.bin
To build the desktop simulator:
pio run -e native
And to launch it:
.pio/build/native/program
The firmware is designed to work with the Cardputer Launcher, allowing installation from an SD card or supported USB serial workflow.
Replacing the factory firmware can erase the existing device installation, so back up the device first and follow the current instructions in the repository.
One other important detail: this project specifically targets the Cardputer ADV. Don't assume hardware compatibility with earlier Cardputer models simply because their names are similar.
The full installation process and current files are available in the repository:
github.com/numbpill3d/cardputer-adv-diviner
Why the Interface Is Written in Daedric
I could claim that the Daedric interface is some elaborate experiment in cognitive ergonomics.
And, well, parts of it are genuinely interesting from an interaction-design standpoint.
But the actual reason is simpler.
I like fictional alphabets, strange old software, and the idea that a computer might possess a little mythology of its own.
The main menu displays application names in a hand-rasterized Daedric script. When you navigate to an entry, the characters dissolve into ordinary English.
It's a little theatrical.
It also communicates selection state without requiring additional interface furniture.
There's a lesson in that somewhere.
Decorative systems don't necessarily have to remain decorative. An animation can become a navigational cue. A fictional alphabet can establish atmosphere while also organizing interaction. Sound design can communicate state changes without consuming screen space.
Obviously, none of this would be particularly useful if the machine became impossible to navigate.
An interface that values personality still has to function.
But I reject the premise that usability requires everything to look like the settings screen on a corporate tablet.
There are other ways to make software understandable.
And I'd rather explore them than spend the rest of my life selecting between twelve slightly different border radii.
The Trouble With Calling Everything a Tool
Something else bothers me about the modern maker ecosystem.
We tend to evaluate small computers almost exclusively by the number of recognizable tasks they can perform.
Can it scan Wi-Fi?
Can it send infrared commands?
Can it identify devices?
Can it run this or that utility?
Those are useful questions, but they're incomplete.
A computer is not merely the sum of its utility functions.
It's also an environment for thinking.
A musical instrument changes your relationship with sound. A visualizer changes your relationship with data. A programming language changes how you express processes and structures.
A well-designed personal computer can combine these things into something much more interesting than an electronics multitool.
I don't think DIVINER has solved that problem. Far from it.
Some of its applications are more mature than others. The environmental-sensing functions are experimental. The interface has to coexist with real hardware limitations. There's plenty of room for further optimization, testing, and expansion.
But the underlying idea feels worth pursuing.
What if personal computing stopped being exclusively about convenience?
What if the machine could encourage curiosity instead of constantly trying to eliminate every moment of friction?
Not pointless friction, obviously. Nobody needs their Wi-Fi password entry transformed into an interpretive dance.
But exploratory friction. The kind that makes you notice something, wonder how it works, and follow the question somewhere unexpected.
That's the sort of relationship I want with hardware.
A Small Computer Doesn't Need to Pretend to Be a Large One
The most interesting machines are often the ones that have accepted their limitations.
An old synthesizer doesn't need to reproduce an entire recording studio to be worthwhile.
A Game Boy doesn't need photorealistic graphics to support an extraordinary amount of creativity.
A tiny computer doesn't need to provide a miniature imitation of macOS to become a meaningful personal computing environment.
DIVINER has sixteen applications, but I don't want its future to become a contest to see how many icons can be stuffed into a menu.
I'd rather improve the connections between its existing systems.
Make the audio engines more expressive. Explore better ways of representing wireless activity. Improve CSI experimentation and validation. Make the simulator more useful for testing. Develop the architecture so additional applications can integrate without losing the coherence of the environment.
And yes, probably add a few more deeply unnecessary visual effects.
There are standards to maintain.
The point is not to build the most practical handheld computer in existence.
It's to demonstrate that practical computing and distinctive computing are not mutually exclusive.
You can create a useful diagnostic tool without making it visually miserable.
You can write serious embedded C++ while enjoying an absurd fictional interface.
You can turn an ESP32 into a synthesizer, a network observer, a tiny-web browser, and a peculiar little electronic companion.
A computer is still a remarkably open-ended object if you stop accepting the default assumptions about what it's supposed to be.
DIVINER is one attempt to explore that.
And it's available for anyone curious enough to take it apart.
Get DIVINER
DIVINER is free and open source.
The GitHub repository contains the C++ source, PlatformIO configuration, interface previews, simulator, and firmware distribution.
Download DIVINER and explore the source on GitHub
For project documentation, hardware details, development logs, and updates:
If you're running a Cardputer ADV, I'd be especially interested in hardware feedback, bug reports, and experiments with the wireless sensing functions.
And if you're one of those people who thinks software should always have a perfectly ordinary interface, I regret to inform you that the glyphs are staying.
Further Down the Rabbit Hole // numbpilled
DIVINER is part of a wider obsession with embedded systems, unusual hardware, wireless research, and computers that don't need somebody else's cloud account to justify their existence.
If you want to go deeper, I've also published paid technical guides and field manuals through numbpilled on Gumroad.
PHYSICAL AGENTS: Bridging OpenClaw With ESP32 Microcontrollers
A practical guide to connecting AI-agent workflows with physical microcontrollers using WebSocket services, custom device commands, telemetry, and hardware control. For anyone interested in building devices that interact with a larger automation environment instead of living entirely inside their own firmware.
ULTRAWIDEBAND STRIKE: UWB Hacking and Proximity Security
An advanced field manual examining UWB security and proximity systems. A separate research topic from DIVINER's ESP32 Wi-Fi features, but relevant to readers interested in the broader problem of how wireless hardware observes, measures, and trusts the physical world.
Explore the complete numbpilled technical archive
Firmware, experimental hardware, wireless research, security tooling, automation, and other projects from the parts of computing that still have sharp edges.
Xenotrek | v. Splicer
numbpilled
Build strange machines. Read their source code. Keep the interesting parts of computing alive.
