Haserl is a small program that uses shell or Lua script to create cgi web scripts. It is intended for environments where PHP or ruby are too big. It was written for Linux, but is known to run on FreeBSD. A typical use is to run cgi scripts in an embedded environment, using a small web server, such as mini-httpd, lighty, or the server built into busybox.
he haserl binary typically compiles to less than 20KB (stripped). The lua language adds less than 150K if linked in statically. Parses like other scripting languages: Anything that is not enclosed in <% ... %> tags is sent verbatim to the client. Form elements sent from the client are automatically parsed and placed into environment variables. The script can then reference the variables without any extra work. Mime data sent via the enctype="multipart/form-data" method is transparently decoded. This method is used when uploading files from the client. Attempts to drop its privileges to the uid/gid of the owner of the script for security.
The Haserl Framework is a set of shell scripts and functions that allow one to build MVC-style web applications based on shell scripting and haserl templating. It is similar to Ruby's Sinatra framework in structure, functionality, and spirit. Haserl Framework is developed primarily for embedded systems running minimal Linux distributions with limited space and shell functionality. The framework itself is relatively bare-bones but can easily be extended.
Effort has be made to keep the framework as POSIX compliant as possible, but that is an ongoing pursuit. The original development platform for Haserl Framework was OpenWRT's Ash/Busybox shell.
Has its own DSL (domain-specific language) but it's shell-based. Uses either scgi requests or FIFO files. Request processing is done in subshells for isolation. Requires Haserl, socat, gpg, base64, and a web server that supports CGI or SCGI.
RIOT is a free, open source operating system developed by a grassroots community gathering companies, academia, and hobbyists, distributed all around the world. RIOT supports most low-power IoT devices, microcontroller architectures (32-bit, 16-bit, 8-bit), and external devices. RIOT aims to implement all relevant open standards supporting an Internet of Things that is connected, secure, durable & privacy-friendly.
Supports over 200 boards based on AVR, MSP430, ESP8266, ESP32, RISC-V, ARM7 and ARM Cortex-M microcontrollers.
RIOT supports DTLS transport layer security, IEEE 802.15.4 encryption, Secure Firmware Updates (SUIT), multiple cryptographic packages, and crypto secure elements. Modular to adapt to application needs. We aim to support all common network technologies and Internet standards. RIOT is open to new developments and often an early adaptor in networking.
Develop in standard languages using standard tools. Modular. Real-time capable. Multithreaded with low overhead (less than 25 bytes/thread). Supports common and specialized protocols (6LoWPAN, IPv6, RPL, UDP, TCP, QUIC, MQTT-SN, CoAP, CBOR) and interfaces (BLE, LoRaWAN, 802.15.4, WLAN, CAN). Static and dynamic memory allocation.
Github: https://github.com/RIOT-OS/RIOT
A MicroPython port for the famous Flipper Zero. No need to learn C: Use your favorite programming language to create apps, games and scripts. .py files are copied onto the Flipper Zero's microSD card. Adding Python support to the Flipper Zero platform was only possible by rigorously sorting out unnecessary language features. I didn't know it was possible to sift even more stuff out of Python to make an embedded version, but so far the list of what they removed makes sense. Be careful with external Micropython modules, though.
Support for basic language constructs like functions, classes, loops, and so forth. Access the Flipper’s hardware: buttons, speaker, LED, GPIO, ADC, PWM, etc. No custom firmware required so no risk of bricking your Flipper.
API documentation: https://ofabel.github.io/mp-flipper/reference.html
DeltaDB is a lightweight, fast, and scalable database built on polars and deltalake. It is designed to streamline data operations, providing features like upsert, delete, commit, and version control while harnessing the high performance of polars and deltalake.
Linux-like shell interface for MicroPython. ( See cpy_shell for the CircuitPython version.) Inspired by mipyshell and busybox, here is a command-line shell for your MicroPython board carefully implementing a range of useful commands and features.
Everything is written to save RAM and Flash; command bytecode is not loaded if you don't run the command, history is stored in a file, not in RAM, pipes use flash instead of RAM, command recall and editing and tab-completion is intelligent, etc.
import sh starts the shell.
Has a surprising amount of functionality! Very Busybox-like.
Buildroot is a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation. It includes a cross-compilation toolchain, root filesystem generation, kernel image compilation and bootloader compilation. Thanks to its kernel-like menuconfig, gconfig and xconfig configuration interfaces, building a basic system with Buildroot is easy and typically takes 15-30 minutes. The X.org stack, Gtk3, Qt 5, GStreamer, Webkit, Kodi, a large number of network-related and system-related utilities are supported.
Github: https://github.com/buildroot/buildroot
Official Git repo: https://gitlab.com/buildroot.org/buildroot/
ObjectBox Python is a lightweight yet powerful on-device database & vector database. Store Python objects and vectors directly with an easy-to-use CRUD API while enjoying exceptional speed and efficiency. And because it's an embedded database, there's no setup required. Its advanced vector search empowers AI applications including RAG, generative AI, and similarity searches. Designed for high performance, the ObjectBox database runs locally on-device. As an offline-first solution, ObjectBox makes sure your app reliably works offline as well as online.
ACID compliant. Claims to be scalable and sustainable (i.e., it doesn't need a lot of horsepower to run). Queries can be filtered, even across relations.
PikaPython is an ultra-lightweight Python interpreter that runs with only 4KB of RAM, zero dependencies. It is ready to use out of the box without any configuration required and easy to extend with C.
Specifically supports a large number of microcontrollers.
A minimalist yet useable, CLI-oriented toybox/Linux distribution. 80x25 terminal (per default) with options to even run in 80x24; 25th line is used as menu- / navigation- / statusbar as customary from Terminals like the DEC VT320. Lack of X.org/Wayland/... and 'bloated' GUI apps per default make it extremely low-power friendly. Can run on extremely low powered systems. Besides the basic core system, it's kept very lean just to ensure it's not bloated, with only concessions being made to reduce avoidable and burdensome inconveniences and incompatibilities. OS/1337 is still in early development and has yet to make an initial release.
Toybox combines many common Linux command line utilities together into a single BSD-licensed executable. It's simple, small, fast, and reasonably standards-compliant (POSIX-2008 and LSB 4.1).
Toybox's main goal is to make Android self-hosting by improving Android's command line utilities so it can build an installable Android Open Source Project image entirely from source under a stock Android system. After a talk at the 2013 Embedded Linux Conference explaining this plan (outline, video), Google merged toybox into AOSP and began shipping toybox in Android Marshmallow in 2015.
Toybox aims to provide one quarter of a theoretical "minimal native development environment", which is the simplest Linux system capable of rebuilding itself from source code and then building Linux From Scratch and the Android Open Source Project under the result. In theory, this should only require four packages: 1) a set of posix-ish command line utilities, 2) a compiler[1], 3) a C library, and 4) a kernel. This provides a reproducible and auditable base system, which with the addition of a few convienciences (vi, top, shell command line history...) can provide a usable interactive experience rather than just a headless build server.
freezeFS.py is a utility program that runs on a PC and converts an arbitrary folder, subfolder and file structure into a Python source file. The generated Python file can then be frozen as bytecode into a MicroPython image together with the Virtual File System driver vfsfrozen.py.
When the generated Python file is imported, the file structure is mounted with os.mount() as a read only Virtual File System, which can be accessed on the microcontroller with regular file operations such as open in "r" or "rb" mode, read, readinto, readline, seek, tell, close, listdir, ilistidr, stat.
If the deploy option is used, the files and folders of the frozen files are copied to the standard flash file system. This enables installing configuration and data files when booting the MicroPython image the first time.
An important topic is that opening files in "r" mode requires to buffer the file in RAM. However, many libraries such as web servers and json support reading text modes in "rb" mode, and no overhead is incurred.
This is a plugin for the Flipper Zero that ports pForth.
Once started the plugin will add a forth command to the CLI that can be used to call up a basic forth shell.
Calling the forth command with a file path as parameter will cause that file to be executed as a forth script. Examples are provided under forth_scripts.
To use one of the provided scripts (for example notif_success.fth), copy it to your SD card. Then run the plugin and execute forth /ext/<path to your file> (for example forth /ext/notif_success.fth) on the CLI.
A small webserver and templating library specifically designed for MicroPython on the Pico W. It aims to provide a complete toolkit for easily creating high quality web based interfaces for your projects. Basic web server that implements GET and POST. Optimized for speed and minimal memory use. Parameterized routing. Templating engine. Query string decoding and parsing included. Multiple types of POST bodies. connect_to_wifi and access_point (enable AP mode) convenience methods.
Tiny research project build on top of MicroPython providing DOS/POSIX-like operating system. Designed for ESP8266 and RP2040. Should work on any board with no or little changes.
I always wanted to make my own small operating system. I grew up using MS-DOS and now using Linux exclusively on all my computers. So my system will look very similar to those, just simpler. Another dream was to build as small a computer as possible. Now with 32-bit ESP8266 and MicroPython I could do that! So I did.
A data compression/decompression library for embedded/real-time systems. Low memory usage (as low as 50 bytes). You can chew on input data in arbitrarily tiny bites. This is a useful property in hard real-time environments. The library doesn't impose any constraints on memory management.
This repository contains code to control Raspberry Pi Pico, ESP8266, ESP32 or other MicroPython projects using a browser-based user interface. It allows you to interact with your Pico projects remotely from any device with a web browser, including smartphones, tablets, and computers.
Serve static and dynamic web pages from your Raspberry Pi Pico. Run Python functions on your microcontroller device from a web browser. Create dynamic web pages with live data from your Pico or other microcontroller. Blink the IP address using the built-in LED, handy when you're out in the field with no screen or computer. Display a file and folder list of your root directory with an attractive and responsive user interface.
M5's custom build of Micropython for the StackC series of products.
Snek is a tiny embeddable language targeting processors with only a few kB of flash and ram. Think of something that would have been running BASIC years ago and you'll have the idea. These processors are too small to run MicroPython.
Snek borrows semantics and syntax from python, but only provides a tiny subset of that large language. The goal is to have Snek programs able to run in a full Python (version 3) implementation so that any knowledge gained in learning Snek will transfer directly to learning Python.
Github and list of supported microcontrollers: https://github.com/keith-packard/snek