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.
been meaning to port lua/tcl/lisp
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.
It has not been tested on animals yet, so it is illegal, and since testing on animals is prohibited it will stay illegal.
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.
Technically true but without rings mechanic like in Intel x86 CPUs there’s no point writing an actual OS because any process is essentially running as root and is free to corrupt everything within the system. A simple attack surface would be to reprogram interrupt table to implement your own task handling to prevent other stuff (like antivirus) from running at all.
Perhaps some homework is due – look at MacOS on the MacSE, MacPlus etc. Or Palm Pilot. Or almost any OS that predates MMUs. Just because you don’t have memory management / process isolation does not mean you can’t have a meaningful and useful OS.
That’s a.. rather hyperbolic take that fails to acknowledge the other basic purposes of an OS.
Hardware based privilege modes like “rings” are an important feature of most modern non-embedded CPUs and the OSes that run on them, but the vast majority of OSes (every single-user OS I can think of) did just fine without any such thing up until at least the early 90’s.
Even on CPU architectures that supported some kind of privilege, like the 68k and 386, OSes like DOS, AmigaOS, and MacOS didn’t use these features, or at least didn’t use them to provide meaningful process isolation or memory protection.
True, but it begs the question about what the OS is for.
On an embedded system, it’s not about the user loading in new programs. It’s a tool for some level of hardware-agnostic modular firmware development, and implementing multitasking where the OS is enforcing the resource management.
Suppose we’re trying to implement different functions in a resource limited system. You might not have enough RAM to keep every functional module loaded, so you have to swap programs in and out. Maybe some operating mode of the device needs all the RAM, so you unload everything else you’re not using, like that calibration and diagnostics program that’s rarely needed.
Of course you could cowboy-code that in, but it would be nice if you had an operating system that can load and unload programs so you don’t have to re-invent the wheel, and other developers know how to use it as well.
All of those issues become irrelevant under a few scenarios.
It’s not a multiuser system. Like pretty much anything embedded.
It’s a Harvard architecture and there is no way for code to modify code.
Operating system are great for developing non trivial systems. FreeRTOS has none of the protections you say a critical, yet it is very popular. Potentially more deployed globally than Windows.
Right, but there were there were exceptions, too.
Minix 1.0 did run on IBM PCs in 8086 Real-Mode..
https://en.wikipedia.org/wiki/Minix
Also, a special Unix version of the Olivetti M24 (AT&T 6300, 8086 based PC) ran DOS applications on Unix System 5.
A custom logic was used to catch direct hardware access, so DOS applications could be virtualized.
https://en.wikipedia.org/wiki/Olivetti_M24#Versions
Then there was SINIX, Siemens’ Unix, which ran on 80186 PCs.
An external MMU was used on the Siemens PC-X models.
https://en.wikipedia.org/wiki/Siemens_PC-D#Hardware
Last but not least, multitasking DOSes such as Wendin DOS or PC-MOS/386 did run on plain 8086 systems, too.
Minus the advanced memory managment provided by 386+MMU, of course, but they ran. With preemtive multitasking, even.
Starch can be quite hard, if you let it dry. Then again, you must not handle enough hard things in condoms bb
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
C64 had GEOS..
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.
I see what you did there
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.
I second rp2040/2350. They are relatively inexpensive, available as clones from the usual suspects, etc. The dev choices are plenty, bugs are rather few, etc.
Overall this project kind of reminds me of bus pirate, a console with access to IO. That’s a compliment, not a criticism.
…much of Hackaday’s early success…
Has the author graduated HS yet? HAS been around long before, although since the Arduino, HAD has lost its way
You should never browse here or comment again. That’ll show ’em.
I was curious to see if I could make it run on the Arduino UNO Rev4 and I have done so succesfully with some small modifications to fix a few issues.. With the larger RAM on the Rev4 UNO it makes this much more practical. I have posted my progress of setting this up and fixing the small issues here… https://bsky.app/profile/nickt6630.bsky.social/post/3mkern4cglk2c
Anyone to add a text editor to this?