uLisp

• ferret

  8 1,057 0.0 Makefile

  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.

• ulisp

  33 361 2.6 C++

  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.

• InfluxDB

  www.influxdata.com featured

  Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  

• esprit

  5 136 0.0 Clojure

  ClojureScript on the ESP32 using Espruino

• ulisp-builder

  2 20 2.8 Common Lisp

  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/

• Lua-RTOS-ESP32

  5 1,147 0.0 C

  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/

• Fennel

  91 2,302 9.3 Fennel

  Lua Lisp Language

• fe

  6 1,278 0.0 C

  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

• SaaSHub

  www.saashub.com featured

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

  

• tinyscheme

  1 7 0.0 C

  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:

• abuse

  4 44 0.0 C

  Discontinued Abuse (1995) by Crack dot Com

  

• ecl

  15 - -

> 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)

• awka

  5 93 0.0 C

  Revive awka - Awk to C Compiler

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

https://github.com/noyesno/awka

• Carp

  85 5,393 0.7 Haskell

  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.

• terra

  38 2,676 5.1 C++

  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.

• nim-esp8266-sdk

  1 16 0.0 Makefile

  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

• nesper

  9 182 2.8 C

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

• llvm-project

  10 219 0.0 C++

  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.

• llvm-cbe

  14 792 6.5 C++

  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.

• SaaSHub

  www.saashub.com featured

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

  

Suggest a related project