littlefs

Yes I've used sqlite with things like littlefs [1]. Without an OS. If that's what you mean. https://github.com/littlefs-project/littlefs

Pointers correctly round-trip through unrelated pointer types, provided the alignment for both types is compatible. At least one bit does look a bit questionable: lfs_mlist is treated as the common initial sequence of lfs_dir and lfs_file, even though it isn't, and common initial sequences only apply to union fields anyway. Example cast of struct dir * to struct lfs_mlist * (probably valid of itself, assuming the alignment is compatible): https://github.com/littlefs-project/littlefs/blob/c733d9ec57...; then use struct dir as if it were actually a struct lfs_mlist: https://github.com/littlefs-project/littlefs/blob/c733d9ec57... (There's other occurrences of the same kind of thing.) Strictly speaking, I think this might be unfixable without a bunch of work, but so much stuff does this kind of operation that any compiler that doesn't do what

We use littlefs in Flipper Zero's firmware[1] for storage in leftover flash space after the main firmware image. Flipper implements a virtual FS, where both external SD card and internal storage have own mount points. SD card is used for storing apps and user-created data, and internal littlefs contains persistent data like BLE pairing, system services' configs and such. LFS has neat features like wear leveling and optimizations for storing tiny files directly in their parent directory's data structures[2]. We never had any issues with littlefs - however, it cannot be easily resized when amount of available leftover space changes with firmware updates. So on installing an update, it gets fully backed up to SD card, reformatted and later restored. [1] - https://github.com/flipperdevices/flipperzero-firmware/blob/... [2] - https://github.co

RShell is a nice tool but the 'official' way to interact with a MicroPython device is with mpremote [1]. One of the key features of mpremote is that it allows folders to be mounted on your device from your PC. For me, this allows a workflow that's even more efficient than using USB since no copying is required at all. Work on your PC (often using the unix port in a container [2] to test), then mount the folder and execute on the device. Brilliant. :) I should probably write up how I use this workflow..! It would be good to also allow USB volume mounting on more MicroPython ports (stm32 only) as - I agree - it's more intuitive for beginners. But LittleFS [3] is a much more robust filesystem than FAT, which is required for USB mounting. LittleFS is preferred by the core team and has had more focus recently. [1] https://docs.micropython.org

Is that an issue with Arduino? This PR [0] suggests a R/W compile is around 13k (or R/O for 5k) on an M0. I don't know if there'd be a big difference compiling for AVR though. [0] https://github.com/littlefs-project/littlefs/pull/480

That is not true. See https://github.com/littlefs-project/littlefs/blob/master/DES... Sorry, as a commenter on this pointed out, the comment I was replying to was probably talking about eMMC. For which indeed no wear levelling is specified by the JEDEC standard - it is a standard that defines the communication protocol between a device and a host system. Newer JEDEC standards define the interface to access vendor specific "health reports", the actual method of wear levelling isn't regularly disclosed by vendors.

For microcontrollers, https://github.com/littlefs-project/littlefs has some mindshare (although not sure how much there is outside the mbed world).

as an aside, for our embedded system we use https://github.com/ARMmbed/littlefs for our flash file system, it has a bit of a description on its design and its copy on write system so that it can handle random power loss. Be nice to see some of these kinds of libraries done in Nim or Rust.

(obviously, i'm not one of the panel members, just chiming in.) if you're interested in looking at how C can be used in embedded realtime operating systems, i recommend diving into: https://github.com/ARMmbed/littlefs (i'm not affiliated.) it's a lean, logging flash filesystem implementation and i recommend it because the research, rationales, documentation, organization, codebase, test harness, and public API ergonomics all impressed me a lot. it was written for the mbed OS, but it is so well designed that i could integrate it into any realtime OS without too much trouble. and the documentation is thorough enough that after skimming the wikipedia article for filesystems, and maybe an article on how flash chips read and write data, you'll be able to work your way through it. i learned a lot by reading through that repository.