If you were to point to a single device responsible for much of Hackaday’s early success, it might be the Arduino Uno. The little board from an Italian university with its easy to use dev environment changed microcontroller hacking forever, and while it’s now very much old hat, its shadow lies long across single board computing.
Just in case you thought there wasn’t much more life in that old AVR in 2026, along comes [Arc1011], with KernelUNO, describing itself a “A lightweight RAM-based shell for Arduino UNO with filesystem simulation, hardware control, and interactive shell“. It’s an OS for your Arduino, of sorts.
For flashing it to your Uno, you get a shell with some familiar looking filesystem and system commands, the ability to write to files though no editor, and a set of commands to control pins. It’s extremely basic, but you can see the potential.
If we were to speculate as to how this might become more useful then perhaps it might involve a more permanent filesystem perhaps on a flash chip. If possible, the ability to run script files containing a list of commands would also be very nice. Though we are guessing that maybe the reason these features are not in place lies in the meager specifications of an ATmega328, for which we can’t blame the developer at all. Even if it can’t be extended in this way though, it’s still a cool project.
We have to go back quite a while, but this isn’t the first time something like this has appeared on these pages.
Being able to create and run something akin to a batch file on a simple microcontroller board could prove to be a great learning tool.
Being able to boot this from an SD card or perhaps EEPROM, would be pretty useful. Maybe untethering with some sort of keypad for input and even something as simple as a row of sixteen segment LEDs as a display. Being able to have a stand alone device like that could be interesting for small robotics projects, a genetic platform for a micro mouse perhaps.
Did you add age verification or is this illegal in CA?
XD
Made my day. BTW you forgot the declaration that it may cause cancer.
This is about as pointless as using a condom filled with wet corn starch to remove a lug nut.
That challenge is so last year. Too many people already succeeded.
Richard Feynman’s Nobel prize stemmed from his wondering why a cafeteria plate wobbled the way it did when spun and tossed into the air. Not everything that seems pointless is. Sometimes pointless exercises lead to unexpected places.
As someone who loves tinkering but has no clue how an OS kernel works, I will absolutely be playing with this just out of curiosity and storing any interesting bits and functions in the junk drawer of my mind.
Accusing it of being pointless says more about you than it does this project.
I wonder if the outcome was because of doing a pointless activity like tossing and spinning plates up in the air, or because Feynman was a creative genius who could have looked at just about anything and found something interesting in it.
Therefore, should we credit the Nobel Prize to Richard or the plate?
I agree. The plate definitely did the work here.
There’s a rather interesting question in what constitutes an operating system rather than just firmware.
To paraphrase my understanding, the absolute minimum requirement in the context of an Arduino is that you have:
– A timed interrupt routine that switches tasks
– A kernel function that does some hardware abstraction like toggling IO pins
– At least one other function that contains your program.
– A runtime method for the program function to message the kernel function and ask it to do something – such as a command queue or shared variables
How the OS switches between the kernel and the program is by splitting the RAM into two areas: the kernel stack and the program stack. When the interrupt routine switches between tasks, it takes the CPU register values of the currently running task and saves them to that task’s stack, then loads up the CPU register values of the next task from its stack, and that causes the CPU to switch between running the kernel and running your program. Each task continues from where it was stopped as if it was never interrupted.
You can see how we can define multiple stacks for multiple independent programs, and one of those happens to be your kernel, which is responsible for providing system level services, such as allocating more memory for more programs and changing when they are scheduled to run.
Flashforth is a better OS for this board
this seems more useful than anything people are doing with Commodore 64s these days, and there are a lot of those people
my Arduino I2C Slaves are a similar concept, except instead of being controlled by someone via some sort of shell, they are controlled by a master sending commands via I2C. there’s even a provision to reflash the Slave via the master. see here:
https://github.com/judasgutenberg/Arduino_I2C_Slave_With_Commands
That’s awesome! I’ve had some ideas for projects that could use a setup like this! Bookmarked the github for if/when I get around to those projects!
Raspberry Pi’s are old hat. Arduinos are old shield.
Neat project! Always fun to see what one can do in a limited environment. Good job!
I’ve settled on to the RP2040/2350 platforms in my world for small projects anymore. Like potato chips.