uLisp

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Nutrient – The #1 PDF SDK Library, trusted by 10K+ developers
Other PDF SDKs promise a lot - then break. Laggy scrolling, poor mobile UX, tons of bugs, and lack of support cost you endless frustrations. Nutrient’s SDK handles billion-page workloads - so you don’t have to debug PDFs. Used by ~1 billion end users in more than 150 different countries.
www.nutrient.io
featured
CodeRabbit: AI Code Reviews for Developers
Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.
coderabbit.ai
featured
  1. ferret

    Ferret is a free software lisp implementation for real time embedded control systems. (by nakkaya)

    Another commenter already mentioned Gambit Scheme. That provides for inline C and therefore very easy interop with external libraries. It still has a runtime and GC though - those might pose a problem depending on your platform and task.

    Ferret (https://github.com/nakkaya/ferret) and Carp (https://github.com/carp-lang/Carp) are both Lisp-like low level languages. Both seem to be fairly experimental in nature though.

    > anything but C

    Taking you literally, Rust and D can both compile for bare metal. D in particular has a "Better C" subset. (https://dlang.org/spec/betterc.html)

    In the same vein, Terra is a C like language (manual memory management) that you metaprogram with Lua. (https://github.com/terralang/terra)

    Taking you very literally, Forth is also an option.

  2. Nutrient

    Nutrient – The #1 PDF SDK Library, trusted by 10K+ developers. Other PDF SDKs promise a lot - then break. Laggy scrolling, poor mobile UX, tons of bugs, and lack of support cost you endless frustrations. Nutrient’s SDK handles billion-page workloads - so you don’t have to debug PDFs. Used by ~1 billion end users in more than 150 different countries.

    Nutrient logo
  3. ulisp

    A version of the Lisp programming language for ATmega-based Arduino boards.

    I think its hilarious that this project is basically a 5k-line .ino file + immeasurable awesomeness: https://github.com/technoblogy/ulisp/blob/master/ulisp.ino

    This is something that is accessible to read and modify in a weekend. Really cool.

  4. esprit

    ClojureScript on the ESP32 using Espruino

  5. ulisp-builder

    Builds a version of uLisp for a particular platform from a common repository of source files

    I'm a big fan of uLisp, got it running on an ESP8266. Love how the whole language fits in a single file, making it easy to hack around.

    Recently I learned how the author generates the uLisp variants for different platforms using Common Lisp:

    https://github.com/technoblogy/ulisp-builder

    ..And an accompanying article to describe how it works:

    uLisp Builder - http://www.ulisp.com/show?3F07

    Also, a treasure trove of other Arduino and AVR projects by the author here:

    http://www.technoblogy.com/

  6. Lua-RTOS-ESP32

    Lua RTOS for ESP32

    There's also Lua RTOS[1] plus Fennel[2]. Lua is easy to embed, but I find the syntax pretty bad, and Fennel fixes most of it for me.

    [1] https://github.com/whitecatboard/Lua-RTOS-ESP32/

  7. Fennel

    Lua Lisp Language

  8. fe

    A tiny, embeddable language implemented in ANSI C (by rxi)

    Very cool! Quite similar to fe [1], a tiny, embeddable Lisp by the magnificent rxi. Seriously, if you like games and gorgeous C and Lua code, check out his projects and the games on itch.io!

    [1] https://github.com/rxi/fe

  9. CodeRabbit

    CodeRabbit: AI Code Reviews for Developers. Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.

    CodeRabbit logo
  10. tinyscheme

    Discontinued TinyScheme is easy to learn and modify. It is structured like a meta-interpreter, only it is written in C. (by zpl-c)

    There are actually a few of these.

    https://github.com/zpl-c/tinyscheme/blob/master/source/schem...

    And Scheme in one defun (SIOD), although it seems the recent version of this has been split into multiple files.

    The video game Abuse also had a simple embedded Lisp:

  11. abuse

    Discontinued Abuse (1995) by Crack dot Com (by videogamepreservation)

  12. ecl

    > I would love to program my fleet of ESP8266s with anything but C.

    Have you looked into Embeddable Common-Lisp? (https://gitlab.com/embeddable-common-lisp/ecl)

  13. awka

    Revive awka - Awk to C Compiler

    Having never heard of Gambit, it looks like Gambit:Scheme::Awka:AWK

    https://github.com/noyesno/awka

  14. Carp

    A statically typed lisp, without a GC, for real-time applications.

    Another commenter already mentioned Gambit Scheme. That provides for inline C and therefore very easy interop with external libraries. It still has a runtime and GC though - those might pose a problem depending on your platform and task.

    Ferret (https://github.com/nakkaya/ferret) and Carp (https://github.com/carp-lang/Carp) are both Lisp-like low level languages. Both seem to be fairly experimental in nature though.

    > anything but C

    Taking you literally, Rust and D can both compile for bare metal. D in particular has a "Better C" subset. (https://dlang.org/spec/betterc.html)

    In the same vein, Terra is a C like language (manual memory management) that you metaprogram with Lua. (https://github.com/terralang/terra)

    Taking you very literally, Forth is also an option.

  15. terra

    Terra is a low-level system programming language that is embedded in and meta-programmed by the Lua programming language.

    Another commenter already mentioned Gambit Scheme. That provides for inline C and therefore very easy interop with external libraries. It still has a runtime and GC though - those might pose a problem depending on your platform and task.

    Ferret (https://github.com/nakkaya/ferret) and Carp (https://github.com/carp-lang/Carp) are both Lisp-like low level languages. Both seem to be fairly experimental in nature though.

    > anything but C

    Taking you literally, Rust and D can both compile for bare metal. D in particular has a "Better C" subset. (https://dlang.org/spec/betterc.html)

    In the same vein, Terra is a C like language (manual memory management) that you metaprogram with Lua. (https://github.com/terralang/terra)

    Taking you very literally, Forth is also an option.

  16. nim-esp8266-sdk

    Nim wrapper for the ESP8266 NON-OS SDK

    I went down many of those routes myself, though not the lisp ones. There's also TCL. But I've settled on Nim as my favorite for embedded (at least for a while). For the esp2866 Rust (or D) would be tricky. Nim can compile to C, unlike Rust which doesn't support the Xtensa architecture found on most esp chips. Not sure about D bit it seems unlikely to support Xtensa.

    There's a Nim Esp2866 sdk: https://github.com/clj/nim-esp8266-sdk

  17. nesper

    Program the ESP32 with Nim! Wrappers around ESP-IDF API's.

  18. llvm-project

    Fork of LLVM with Xtensa specific patches. To be upstreamed. (by espressif)

    Just to clarify - Gambit, Chicken, and Carp all compile to portable C.

    I hadn't realized LLVM mainline doesn't support Xtensa. I'm surprised.

    D does support Xtensa via LDC (https://forum.dlang.org/thread/[email protected]...). It looks like GDC also nearly supports it, requiring only a minor patch at present.

    A functioning LLVM backend does exist (https://github.com/espressif/llvm-project/issues/4) and might be making very slow progress towards being merged. A quick search shows that it works for Rust. I suspect (but don't know) that it might work for Terra as well.

    There's also the LLVM C backend (https://github.com/JuliaComputingOSS/llvm-cbe) but I've no idea how efficient such an approach is when applied to real world embedded tasks.

  19. llvm-cbe

    resurrected LLVM "C Backend", with improvements

    Just to clarify - Gambit, Chicken, and Carp all compile to portable C.

    I hadn't realized LLVM mainline doesn't support Xtensa. I'm surprised.

    D does support Xtensa via LDC (https://forum.dlang.org/thread/[email protected]...). It looks like GDC also nearly supports it, requiring only a minor patch at present.

    A functioning LLVM backend does exist (https://github.com/espressif/llvm-project/issues/4) and might be making very slow progress towards being merged. A quick search shows that it works for Rust. I suspect (but don't know) that it might work for Terra as well.

    There's also the LLVM C backend (https://github.com/JuliaComputingOSS/llvm-cbe) but I've no idea how efficient such an approach is when applied to real world embedded tasks.

  20. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts

Did you know that C is
the 6th most popular programming language
based on number of references?