v15.0 · The Great Refactor

The Complete MicroOS for RP2040 & RP2350

Kernel, scheduler, filesystem, shell, and SDK — unified in one platform. Picomimi is a full embedded distribution designed for complex projects, OTA updates, runtime inspection, and rapid development. Not another minimal RTOS. Not a superloop.

Explore on GitHub → Get Started
Full
OS Distribution
Dual-Core
Native Support
OTA
A/B Updates
100%
Pico-SDK Native

Just another RTOS
A complete embedded distribution

Most embedded "operating systems" hand you a scheduler, maybe a semaphore or two, and wish you luck. You spend weeks stitching together filesystems from this repo, memory managers from that blog post, shells that kinda work, and HALs that fight with everything else. The result? A fragile Frankenstein that breaks when you look at it wrong.

Picomimi takes a different approach. It's a unified platform where the kernel, scheduler, filesystem, memory manager, shell, and HAL were all designed to work together. You get a persistent, inspectable system where tasks, memory, peripherals, and IPC can be observed and controlled at runtime — not just deployed and prayed over.

Think of it like this: FreeRTOS gives you an engine. Arduino gives you a go-kart. Picomimi gives you the whole car — engine, transmission, dashboard, GPS, and a mechanic's toolkit in the trunk.

This isn't about being "better" than FreeRTOS or more convenient than Arduino. It's about being complete. When you need to debug why a task is starving, inspect memory allocation patterns, trace IPC flows, or push an OTA update without bricking devices — Picomimi has you covered out of the box.

Why Build on Picomimi?

The convenience of having your MicroOS and development platform as one unified base.

📦

Out-of-the-Box Complete

Stop assembling pieces. Kernel, filesystem, shell, SDK, memory management — everything works together from day one. Start building your actual project, not your infrastructure.

🔍

Runtime Inspectable

Interactive shell for real-time system inspection. See task states, memory usage, IPC flows, and peripheral status live. Debug without reflashing. Understand without guessing.

🔄

OTA-Ready Architecture

PMFS with dual A/B firmware banks built in. Safe updates, rollback capability, and crash recovery aren't afterthoughts — they're foundational to the design.

⚡

Convenient Development

Clean APIs, sensible defaults, and a project structure that scales. Picomimi gives you rapid development without sacrificing the control you need for production systems.

What You Get

Every component optimized for RP2040/RP2350's architecture and constraints.

⚙️

O(1) Scheduler

Preemptive multitasking with priority queues across both cores. Designed specifically for RP2040/2350's dual-core architecture.

📁

PMFS Filesystem

Journaling filesystem with write caching, dual OTA banks, and tmpfs. Power-safe and crash-recoverable by design.

🖥️

Interactive Shell

Real-time system control and inspection. Task management, filesystem access, live debugging — all via USB serial.

🧠

Memory Management

Per-task heap tracking with automatic cleanup on task exit. OOM handling and resource accounting built in.

💬

Priority-Aware IPC

Message passing, signals, and shared memory primitives. Deterministic inter-task communication with priority inheritance.

🔌

Clean HAL

Hardware abstraction that keeps kernel logic independent of MCU registers. Portable, testable, maintainable.

Different Philosophy

Not better or worse — different in what it provides out of the box.

Aspect FreeRTOS Arduino Picomimi
Structure Kernel only Superloop Full OS distribution
Filesystem Third-party Library Native PMFS (journaled)
Shell Third-party None Interactive, built-in
Process Model Tasks Single thread Tasks + resource ownership
OTA Support Manual integration None A/B banks, native
Focus Efficiency Simplicity Inspectability & completeness
Apps & User Tasks
Shell & SDK
PMFS Filesystem
IPC & Memory Manager
O(1) Scheduler (Dual Core)
Hardware Abstraction Layer
Pico-SDK / RP2040/2350 Hardware

Unix-Like, Microcontroller-Sized

Picomimi's architecture resembles a small Unix-like embedded environment: kernel, filesystem, shell, services, and user-space tasks as a unified system.

Clean separation between layers means you can understand, modify, and extend any part without breaking others. The HAL keeps kernel logic independent of MCU registers — the same code structure works whether you're debugging on hardware or testing components in isolation.

Built natively on pico-sdk for direct hardware access and optimal performance. No Arduino core overhead. No abstraction layers fighting each other. Just clean, efficient C/C++ that compiles to tight binaries.

What's Coming

Picomimi is a foundation. These projects extend it into new capabilities.

🔧

MimiC

On-Device Compiler

An AOT (ahead-of-time) C compiler that runs directly on RP2040/RP2350 silicon. Targeting C89/C99-style code, MimiC compiles and executes binaries on the device itself — no host toolchain required for simple programs.

  • On-device compilation and binary execution
  • C89/C99 subset for embedded constraints
  • REPL-style development directly on hardware
🌐

PicoNET

Network Stack

A full-fledged network extension for Picomimi. OTA updates over WiFi, data streaming, remote device management, and fleet orchestration. Built for Pico W and external network modules.

  • Network-capable OTA with rollback
  • Data streaming and telemetry
  • Remote shell and device management
🛡️

MimiSafeMEM

Memory Protection

Software-enforced memory protection for RP2040/RP2350 despite the lack of hardware MMU. Task isolation, bounds checking, and memory access policies — defense in depth for safety-critical applications.

  • Task memory isolation without MMU
  • Bounds checking and access policies
  • Fault detection and recovery
🧰

Mimi-SDK

Development Platform

The complete development platform for Picomimi. Auto-include the kernel, select only the modules you need, scaffold apps/drivers/services, and build optimized binaries with one command.

  • Modular kernel configuration
  • Project scaffolding and templates
  • Integrated build system and tooling

Where Picomimi Might Fit

Some ideas on where a complete MicroOS could be useful. No promises — just possibilities.

📊

Dashboards & Displays

Interactive status panels, info displays, or control interfaces. The shell lets you debug UI issues live without reflashing. Swap screens, tweak layouts, watch memory — all at runtime.

📡

Monitoring Systems

Environmental sensors, equipment monitors, data loggers. PMFS gives you persistent storage that survives power cuts. OTA means you can push fixes to devices in the field.

🎛️

Complex Controllers

Multi-axis motion, process control, automation systems. Dual-core scheduling lets you separate time-critical control loops from UI and communication tasks. Priority-aware IPC keeps things deterministic.

🔬

Sensor Arrays

Multiple sensors, multiple protocols, one coherent system. The HAL abstracts the hardware, the shell lets you inspect readings live, and per-task memory tracking helps you find that sensor driver that's leaking.

🔗

Interconnected Devices

Nodes that talk to each other, gateways, mesh participants. IPC primitives work locally; PicoNET (coming soon) extends that to the network. Same mental model, different transport.

⌚

Wearables & Portables

Small form factor, battery-conscious, user-facing. The AxisOS project is exploring Picomimi as the foundation for a smartwatch — because why not have a real OS on your wrist?

These aren't guarantees — Picomimi is still evolving, and your mileage will vary. But if you need more than a superloop and less than Linux, there might be something here for you.

Why RP2040/2350?

"Why not STM32? Why not ESP32? Those are more powerful."

On paper, RP2040/2350 looks mediocre. Dual Cortex-M0+ at 133MHz, 264KB SRAM, no built-in WiFi. STM32 has more variants, more peripherals, faster cores. ESP32 has WiFi and Bluetooth baked in. So why build a MicroOS specifically for Raspberry Pi silicon?

Because RP2040/2350 gives you something the others don't: complete ownership of your silicon.

🔓

You Own the Metal

ESP32 ships with FreeRTOS baked into the SDK. You're a guest in someone else's house. Want to replace the scheduler? Good luck. Want to understand what's actually running on your chip? Prepare to dig through Espressif's proprietary layers.

RP2040/2350 boots your code. Picomimi doesn't hesitate to let you own your silicon — every cycle, every register, every interrupt is yours to control.

🎯

ARM, But Accessible

ARM Cortex-M is the industry standard for a reason. Massive toolchain support, battle-tested compilers, debugging tools that actually work. RP2040/2350 gives you ARM's ecosystem without the complexity tax of STM32's 47 different product lines and HAL configurations.

One chip family. One SDK. One set of docs. And those docs are actually good — the RP2040/2350 datasheets are a masterclass in documentation.

⚡

Deceptively Capable

Dual cores with deterministic timing. PIO state machines that can bit-bang almost any protocol at hardware speeds. DMA that actually works without fighting the silicon. 133MHz doesn't sound impressive until you realize there's no RTOS overhead eating your cycles.

With Picomimi, you're running your scheduler, your memory manager, your priorities. That 133MHz goes a lot further when you control where every cycle goes.

💰

Cheap & Scalable

$4 for a Pico. $1 for the bare RP2040/2350 chip. Build prototypes without worrying about burning expensive dev boards. Scale to production without licensing fees or vendor lock-in. Same ecosystem across the family.

Huge community, mountains of existing libraries, and compatibility with everything from logic analyzers to $2 display modules. The ecosystem matters as much as the silicon.

The point isn't that RP2040/2350 is "better" than STM32 or ESP32. It's that RP2040/2350 is the right foundation for what Picomimi is trying to be: a platform where you have absolute control, where the OS serves you instead of the other way around, and where "understanding your system" is actually achievable.

Let's Be Honest

Picomimi is a passion project built by a polytechnic student who struggles with Computer Engineering. It started because someone handed me a few RP2040/2350 boards and I started building things. That's it. No corporate backing, no funded research team, no grand institutional support.

Development is slow. This is a nights-and-weekends project that competes with assignments, exams, and life. Major features take months, not weeks. The v15 refactor has been ongoing because rewriting 12,000 lines of monolithic code into clean modules while learning proper embedded architecture isn't fast work.

But, I see some potential.

🎯

"Only targets Raspberry Pi silicon" — Yes, intentionally. RP2040/RP2350 are cheap, well-documented, and widely available. Focused scope beats scattered mediocrity. Better to do one platform excellently than five poorly.

🎓

"High schooler project" — Polytechnic, actually. And the codebase has grown from a 700-line scheduler into a 12,000+ line microOS with journaling filesystem, shell, IPC, and dual-core support. Learning by building real systems beats toy examples.

⏱️

"Slow development" — True. The architecture is still being reworked — it's a massive work in progress. But it aims to be proper. Some projects ship fast and die fast. This one is building foundations, even if they take a while to set.

Get Started

Clone, build, flash, connect — straightforward pico-sdk workflow.

1

Clone the Repository

Grab the latest source from GitHub:

git clone https://github.com/MilkmanAbi/Picomimi.git cd Picomimi
2

Build with CMake

Standard pico-sdk workflow. Set your SDK path and compile:

export PICO_SDK_PATH=/path/to/pico-sdk mkdir build && cd build cmake .. && make -j$(nproc)
3

Flash & Connect

Hold BOOTSEL, plug in your Pico, copy the UF2, then connect:

cp picomimi.uf2 /media/$USER/RPI-RP2/ picocom /dev/ttyACM0 -b 115200

Related Projects

Picomimi is part of a growing ecosystem of embedded tools.

🌀 AxisOS 🔧 MimiC Compiler ⚡ Pico-Governor

Ready to Try Something Different?

Picomimi won't be for everyone. But if you want a complete MicroOS that's inspectable, OTA-ready, and designed as a unified platform — it might be exactly what you need.

Explore on GitHub → Read the Wiki