Given the incredible power of modern microcontrollers, we’ve seen quite a few attempts to turn them into more general purpose computers over the years. KryonOS from [Haris] is the latest, and it takes a slightly different path from the norm in that it’s a JavaScript based operating system for the ESP32.
It takes the form of an OS with a simple GUI and graphics library, and a built-in JavaScript runtime interpreter. It runs on a wide variety of ESP32 boards with screens, including the ubiquitous Cheap Yellow Display. It has full access to the SD card filesystem, and an API for using the hardware. Perhaps most interestingly it has an app store for downloadable software, which immediately reminds us of Europe’s Badge.Team. Their SHA2017 badge spawned a succession of devices that continues to this day, and offered a similar experience using Python.
We like this project, and think it has potential due to the ease of JavaScript development for so many people used to working with the web. There was a time when Python running on microcontrollers sounded pretty far fetched, and look where we are now.
That´s quite nice, especially if running a web server on the ESP32, with a web socket, and pipe JS objects through it. Not very secure but very flexible.
I do that with micropythonOS on the ESP32 micropythonVM in Webasm on the client (web browser) side. All files are served by the ESP32, but there is still this JS layer running on the client side.
Using JS everywhere makes sense, one layer less. With JS pruning-minifying in the browser and sending over the JS objects through the socket, would make a very flexible development chain.
prolifetaring javascript make a different javascript ;(
like java
I love that all the familiar commodity general-purposed devices in my life all are getting OSes. I used to collect old Palm Pilots and LinkSys routers to do this sort of thing. But the supply of those is running out, and neither has a color touchscreen.
My first thought is, “oh cool! an OS for my ESP32!” And then my second thought is “wait, what would I do with this?” I don’t want to assume my lack of need (or perhaps imagination) is everyone’s story, so… what would you do with an OS on an MCU?
KryonOS is a GUI OS once you flash you will install the Apps From Appstore you will create your own apps all apps are gui what you need you just need esp32 and ili9341 2.8 inch touch display
I don’t think that an OS is always required, but what I find missing, is a framework with common services, implemented on a variety of microcontroller.
I’m thinking about logging (possibly on an SDcard), a software timer, sleep mode, common interface for uart/i2c/ etc… Arduino had something going on the standardisation, but fell short for more complex need (which the open community
I heard that embassy (rust library) wasn’t bad at all but didn’t tried it out for the moment.
If someone has a better solution other than such a framework, I’m all ears!
Check out Zephyr
i might want something to allow me to quickly change the state of devices controlled on my web-based remote control system. i coukd do that with a phone or a chromebook, but those devices cost a lot more than $15, so i can’t just have one in the bathroom or on top of the boiler in the basement. and maybe i want a customized calculator taking into account environmental data. that could be a web app on a phone or a chromebook too, but adding a custom sensor on those gets ponderous in a way that it doesn’t if i am building a special-purpose device around an $15 core of functionality. also, these are great for any home-built device that needs a quick and dirty UI
Looks like Espruino, the OG JavaScript on microcontrollers is still alive too
https://github.com/espruino/Espruino
Espruino mostly focuses on running JS over the serial monitor, whereas KryonOS is a full GUI OS that renders JS apps directly onto displays with touch support.
This is pretty darned impressive and will make a long list of projects even easier to implement. Thanks!!
There are plenty of real use cases, from practical apps that control the ESP32 to interactive 3D tools and even playable 3D games running directly on the screen.
Hey everyone! I built KryonOS around a hardware abstraction layer and an embedded JavaScript runtime. The idea is simple: you write your app once in JS, and it handles the display, touch, and peripheral mapping across different ESP32 boards so you don’t have to reflash C++ constantly.
In the next update, I’m rolling out cloud services directly accessible from the JS runtime:
KryonBeam: direct device-to-device messaging using handles, with offline queueing if a board is off
KryonDrive: sandboxed cloud storage and sync
Kryon AI: streaming AI responses straight to the screen
Fleet tools: email notifications and dynamic version telemetry
Really curious to hear what you guys think, and happy to answer any questions about the setup or memory management!
My first thought when I saw the project was “oh neat! I wonder what I could use it for”
And then you come here talking about the direction you want to move with it and examples.
Eww. No.
Thanks for quickly squashing my enthusiasm with your app-centric, cloud-whatever, ‘AI’ visions. Yuck.
Espruino is worth mentioning. https://en.wikipedia.org/wiki/Espruino
From 2012, open sourced in 2013. Runs JS on embedded devices, like the Bangle.js 2 smart(ish) watch. Its not terribly pricey for what you get: a sunlight-readable watch with an always-on display that goes for many days on a single charge, that also doubles as a fun little toy for anyone such things appeal to.
my cardputer adv kinda has an online app store in a way. its like early podcasting where you download a list and select what you wanna download next from that list of apps and run tjem as flashes and its like…one at a time but thats fine. its a whole new way to use computers. each program is like a gameboy cartridge.
im happy to see more stuff like this. lets get a writer deck app made thats popular and uses a wide variety of keybaords
Hey everyone!
We have a massive milestone in the works. With KryonOS v2.0.0, we are taking KryonOS beyond standalone GUI devices by introducing KryonCloud a suite of native cloud services built directly into the operating system and exposed to the JavaScript runtime.
Here is an overview of what is landing in v2.0.0:
Kryon AI
Use AI directly inside KryonOS and integrate it into your own custom JavaScript apps.
Build interactive AI assistants, dynamic content generators, and smart in-app tools entirely in JS.
Simple native API to add intelligence to games, dashboards, and utility applications.
KryonDrive
Sync app assets, game save states, and configuration files seamlessly between devices and your web dashboard.
Isolated device configuration scoping paired with shared account storage pools.
KryonBeam
A dedicated device-to-device messaging network built specifically for KryonOS hardware.
Device Handles: Every device claims a human-readable slug (like @desk-spark-52 or @pocket-fox-42).
Hardware-Only Transmission: Messages are sent directly from physical hardware to keep the network free of web bot spam.
Offline Store-and-Forward: If a friend’s board is powered off or disconnected, messages wait securely in an
ephemeral inbox queue and deliver automatically as soon as it reconnects.
Fleet & Friend Graphs: Send private messages to friends, broadcast alerts across your personal device fleet, or discover other community builders via opt-in public directory discovery.
What’s Next?
Core backend routes and C++ runtime bindings are currently being finalized and tested. We will be sharing firmware flashing instructions, JavaScript API documentation, and migration guides as we approach the official v2.0.0 release.
KryonOS Github : https://github.com/Haris16-code/KryonOS
Drop your thoughts, ideas, or questions below we would love to hear what kind of connected apps and games you plan to build with KryonCloud!
Hey everyone! Creator here with a quick update:
KryonOS v2.0.0 is officially released!
The project has outgrown the original single breadboard setup and received a massive architectural overhaul. Instead of being hardwired to one specific display, KryonOS now supports popular off-the-shelf maker boards out of the box:
M5Stack Cardputer: Full 56-key matrix keyboard scanning (with Shift & Fn layers) to run as a standalone pocket cyberdeck.
Cheap Yellow Display (CYD) & LilyGO T-HMI: Dedicated SPI/parallel display and touch drivers.
ESP32-S3 DevKitC-1 N16R8 Flagship: Configured with 16MB Flash and 8MB Octal PSRAM for heavy JS heap headroom.
Hardware-Accelerated 3D Engine (Kryon3D): Double-buffered rasterizer in C++ using DMA SPI flushes, backface culling, and FPU-accelerated matrix math (FastMath) exposed directly to JavaScript.
Wireless Dual-OTA Updates: Automatic Wi-Fi updates with anti-rollback recovery on 8MB+ boards.
Embedded Web Server & WebSockets: Run an Express-like server and WebSockets directly on the chip.
Full release notes, hardware docs, and precompiled binaries are live on GitHub:
https://github.com/Haris16-code/KryonOS/releases/tag/v2.0.0
Thanks again to Hackaday and the community for all the feedback and support on the initial launch!
KryonOS v2.0.1 Released: Security Hardening, App Sandboxing, and New Features
We’re releasing KryonOS v2.0.1, a new update to our open-source graphical operating system and JavaScript application platform for ESP32 microcontrollers.
KryonOS brings a desktop-like graphical interface, a JavaScript runtime powered by Duktape, hardware APIs, and standalone applications to supported ESP32 boards. This release focuses on security, application isolation, storage permissions, and runtime reliability while introducing several new features.
What’s New?
Security and Application Isolation
This release introduces several security improvements across the operating system:
TLS certificate validation: Added centralized certificate validation and trusted CA support, replacing insecure TLS verification bypasses throughout the codebase.
Encrypted Wi-Fi credentials: Network credentials are now encrypted using AES-256-CBC, with a unique per-device key generated using the ESP32 hardware random number generator.
Application filesystem sandboxing: JavaScript applications are restricted to their own package directories or explicitly configured data directories, with protection against path traversal and unauthorized filesystem access.
Runtime storage permissions: Applications can request permission when accessing storage outside their own directory, including cross-access between LittleFS and SD storage.
Web Manager security: Added session-based authentication, protected API endpoints, login rate limiting, and stricter filesystem path protection.
App Store integrity verification: Downloaded application packages are checked using SHA-256 before installation.
New Permissions Manager
KryonOS now includes a dedicated Permissions Manager in Settings. Users can review application permissions, revoke individual permissions, or reset all permissions with a confirmation dialog.
Applications can install without unnecessary pre-install permission barriers and request access when it is needed.
Improved Web Manager
The Web Manager has received several improvements:
Session-based login with HTTP cookies.
A Remember Me option.
Protection against repeated failed login attempts.
Recursive folder uploads and drag-and-drop support.
On-device controls for changing Web Server credentials.
Improved handling of large file uploads.
Better Runtime Memory Management
We fixed a memory leak involving display buffers when JavaScript applications terminate. The runtime now explicitly releases graphics buffers and resets display caches, potentially freeing up to 153.6 KB of RAM, depending on the buffers allocated.
On a resource-constrained microcontroller, reclaiming memory between applications is particularly important.
Additional Improvements
Dynamic system-time initialization and background SNTP synchronization for TLS certificate validation.
A new eight-category online Help Center.
A reorganized Settings interface.
Reduced automatic telemetry, with GitHub star-count requests now opt-in and locally cached.
Improved App Store update status and package verification error messages.
Important: Experimental board targets have not necessarily been physically verified by the maintainers. Check the hardware documentation before flashing.
Get KryonOS v2.0.1
Source code and firmware releases: https://github.com/Haris16-code/KryonOS/releases/tag/v2.0.1
Download the firmware binaries for your exact board, verify the published SHA-256 checksums, and flash them using a compatible ESP32 flashing tool. Follow the release instructions for the correct binary offsets.
KryonOS is open source, and contributions, bug reports, compatible board testing, and feedback are welcome.
If you’re working with ESP32 graphics, embedded JavaScript, microcontroller operating systems, or standalone embedded applications, we’d love to hear what you think.
Project: https://github.com/Haris16-code/KryonOS