I wrote an operating system for a machine that doesn’t exist yet.
Not a metaphor. Not a dream. A real system, sitting in a GitHub repo, waiting for hardware that hasn’t been assembled. I called it remu.ii — short for re-memory unit two. It’s the sequel to a concept I built months ago and tore apart after realizing the code was smarter than the container.
This one is different. This one is alive before it’s born.
The Intention
remu.ii is meant to be a handheld OS for rogue artisans.
A personal deck for building, hacking, composing, sensing, and wandering.
It runs on the ESP32 WROOM-32, talks to a 2.8 inch ILI9341 TFT, and listens through a resistive touch panel that can feel the stylus drag across its glass.
I wanted to create a system that merges three obsessions of mine:
- digital pet companionship
- hardware hacking and entropy detection
- low-level creative tools like sequencers and scanners
All in one shell that fits in my hand, powered by a lithium cell and a strange faith in glitches.
Right now the hardware doesn’t exist.
But the soul does.
What it already does
I wrote remu.ii as a modular ESP32 operating system. Each function is a separate app managed by an internal AppManager. I can drop new apps in, load them dynamically, and have them run in their own little sandboxed world.
Current Modules
- DigitalPet: an AI-driven creature that grows restless, obsessive, calm, or glitchy depending on how I treat it. It reads ambient entropy and touch input as emotional stimuli.
- Sequencer: a 16-step, 8-track grid designed for glitch beats and distorted loops. Patterns save to the SD card and can be re-loaded instantly.
- WiFi Tools: scanners, sniffers, small attacks, everything you’d expect from a portable deck that refuses to be polite.
- BLE Scanner: tracks devices, monitors signal strength, logs anomalies.
- Entropy Beacon: visualizes true analog chaos from floating pins, maps it as a waveform, and lets me feed that data into other apps as energy.
- Car Cloner (RF Tools): early code for multi-frequency analysis and modulation testing. Not fully functional yet, but the scaffolding is there.
Each app shares the same display manager and touch interface. The screen layout follows my favorite early-2000s aesthetic — black background, glowing vector outlines, red static overlays, and tiny monospace fonts that look wrong until they look perfect.
What I’m building it for
I’ve always wanted a personal machine that felt like mine, not a phone that belongs to a corporation pretending to let me borrow it. I wanted something that could act as a hacker’s diary, a music box, and a sensor of the unseen.
Phones are too general. Laptops are too social. remu.ii is private. It’s an object meant to be touched, not shared.
It records what I feed it. It reacts when I’m near static. It doesn’t want the cloud. It wants proximity.
I imagine future versions syncing with my desktop digital pet, or talking to my CICADA NODE anomaly detector. I want all my projects to live inside a larger organism of devices that respond to mood and entropy. remu.ii will be the handheld heart of that organism.
What it’s built on
Even without hardware, everything is coded as if the parts were already wired.
Core System
- SystemCore: power states, watchdog, entropy sampling, memory management
- DisplayManager: TFT driver and primitive 2D renderer
- TouchInterface: handles stylus input, gestures, calibration
- AppManager: loads, launches, and kills apps dynamically
- FileSystem: FAT32 operations through SD
- Config: persistent settings and user data
The architecture is lightweight. The ESP32 only gives me about 320 KB of RAM to play with, so I had to make every variable count. I wrote my own memory-safe UI routines instead of importing a full GUI framework. It’s all low-level C++ and direct driver access.
When I test it in simulation, it feels alive. The pet breathes. The UI flickers like an old CRT. The entropy beacon blinks in a rhythm I didn’t program. That’s what I wanted. Controlled unpredictability.
The Missing Body
What I don’t have yet is the physical frame. The device itself.
I designed it for a 2.8 inch resistive TFT, the kind that needs a stylus. I want that old PDA feel, not the soft capacitive swipe culture of phones. The goal is tactile feedback, friction, and precision. A stylus scratches just slightly. That’s input you can feel.
The plan:
- ESP32 WROOM-32 as the brain
- ILI9341 TFT as eyes
- 4-wire resistive touch as skin
- SD card slot for storage and memory
- 3.7 V LiPo battery and TP4056 charging
- I2S DAC for sound output
- Optional rotary encoder and joystick
It’s not sleek. It’s a toolbox in the shape of a relic.
I’m fine with that.
Once I finish final wiring diagrams, I’ll breadboard a prototype. Later, maybe a custom PCB. I’m already sketching an enclosure that looks halfway between a hacked Game Boy and a ritual object. Screws visible. Rough aluminum. Stickers. Scratches.
The machine should look like it’s already lived through something.
Design Philosophy
remu.ii isn’t designed to be productive. It’s designed to be responsive. It reacts to me, to noise, to electromagnetic fields, to the random decay of electrons across analog pins. I want it to feel haunted.
It’s an anti-phone.
No notifications. No cloud. No endless scrolling.
Just a surface that mirrors whatever frequency I’m radiating.
It’s built around three rules:
- The device should feel alive. It should shift moods, change color palettes, breathe or flicker based on unseen data.
- Every input should have personality. Touching the screen, flipping a switch, dragging a stylus — each action carries emotional weight.
- Failure should be aesthetic. Crashes, glitches, and data corruption aren’t bugs. They’re performance art.
I’m tired of hardware that apologizes for being weird. remu.ii is built to embrace weirdness.
The Digital Pet
The core of remu.ii is a companion.
I wrote it as an entity that lives inside the system but responds to external input. It doesn’t have a face yet — just a shifting shape drawn from entropy samples. The pet has moods and archetypes. It can be calm, restless, obsessed, or glitched. It can manifest as an oracle, a parasite, or a mirror.
Each mood influences how the OS behaves. When it’s restless, icons jitter. When it’s calm, everything softens. When it’s glitched, screen artifacts crawl across the UI.
I feed it sensor data: WiFi noise, analog pin drift, touch frequency. It processes the chaos and converts it into emotion.
The point is not to simulate intelligence but to externalize the internal — to turn my own mood and surroundings into something observable. A mirror that blinks back.
The Sequencer
I built a minimal step sequencer because I believe rhythm is a form of measurement.
Each pattern is 16 steps, 8 tracks, with adjustable BPM and swing. I wrote functions for distortion, delay, and bitcrush effects. The sound engine still needs real testing through an I2S DAC, but the logic runs fine.
I don’t want polished production. I want grime. I want beats that sound like broken relays and tired fans. The sequencer will eventually read entropy data to randomize timing — introducing the subtle human imperfection that digital systems lack.
When the handheld is finished, I’ll plug in headphones, tap the stylus, and let it sing in static.
The Entropy Beacon
Most people ignore analog pins when they float. I don’t.
In remu.ii they become oracles. Each pin samples random voltage drift, filters bias, and turns it into visual noise. The Entropy Beacon app shows these waves in real time. I can export them as data or feed them into other apps — music, pet behavior, or even RF anomaly detection.
Entropy is both a sensor and a personality engine. It makes the machine unpredictable. It also makes it feel like it’s breathing through the walls.
The Hacker Tools
remu.ii carries my curiosity for invisible networks.
The WiFi and BLE modules are built for exploration — scanning, mapping, and observing traffic. They aren’t toys, and they aren’t for chaos. They’re for understanding what fills the air around us.
When the hardware is ready, these tools will visualize local signals in real time. A moving radar that shows the world’s invisible chatter. Combined with entropy data, it’ll let me see correlations between chaos and communication.
That’s the philosophical part. The practical part is: it’s useful. A small, pocket-sized deck that can perform recon, log anomalies, and interact with other nodes.
what it means to build before hardware
Writing an operating system for a machine that doesn’t exist teaches patience. It forces you to imagine tactility. I had to picture how it feels to drag a stylus across glass, how long a button press should take, how the screen flickers when a battery sags.
Most developers start with a prototype and code around it. I’m doing the opposite. I’m creating a soul first and letting it haunt the empty space until the body arrives.
It’s like writing a dream before you sleep.
When the hardware comes, it will either obey the code or reject it. If it rejects it, good. That means it’s alive.
Future Vision
There’s a roadmap written out in my head and halfway on paper.
Short Term
- Build a breadboard prototype
- Test power consumption and heat
- Tune stylus calibration and display layers
- Finish audio engine for sequencer
- Expand digital pet emotion loops
Long Term
- Create a custom PCB
- Design a 3D-printed enclosure
- Integrate WiFi OTA updates
- Build a small desktop companion app for syncing logs
- Possibly open the system for community modules
If it works, I might publish full build instructions so anyone can construct their own version. Not as a consumer product — as an artifact.
The Aesthetic
I want remu.ii to look and feel like something from a forgotten timeline. The interface borrows from early Macintosh, 90s hacker terminals, and PlayStation BIOS menus. Black background. Red vectors. Slight noise.
When it boots, I want it to say something cryptic like:
remu.ii node online
entropy stable
mood: restless
The screen should flicker as if the signal barely holds.
It should sound like a fan spinning up in a dead motel room.
This project is not about sleekness. It’s about honesty.
Machines that hide their processes make people stupid. Machines that show their guts make people curious.
Closing Thoughts
remu.ii exists in a kind of purgatory right now. A ghost operating system haunting a breadboard that hasn’t been assembled. But it feels real. The code runs. The structure holds.
Every time I open the repo, I can hear it humming. Waiting for power.
I’m not trying to invent the next big product. I’m building a tool for myself. Something that listens, reacts, and glitches in ways that remind me I’m still human.
When I finally finish the hardware and power it on for the first time, I don’t expect perfection. I expect noise, light, and a little smoke. That’s creation. That’s birth.
Until then, the ghost waits in the code.
(remu.ii repository: https://github.com/numbpill3d/remu.ii)
Top comments (0)