[ mona / prog / sol ]

prog


Cool Lisp projects

1 2020-02-28 22:49

Post them here as you stumble across them.

https://github.com/phantomics/april

Array Programming Re-Imagined in Lisp
Ken Iverson's masterpiece reflected in the medium of Lisp.

April compiles a subset of the APL programming language into Common Lisp. Leveraging Lisp's powerful macros and numeric processing faculties, it brings APL's expressive potential to bear for Lisp developers. Replace hundreds of lines of number-crunching code with a single line of APL.

2 2020-02-29 02:50 *

https://github.com/mihaiolteanu/lastfm.el

An interface to Last.fm API for Emacs.

3 2020-02-29 12:03 *

http://www.ulisp.com/show?2XZH

ARM Assembler in Lisp.

uLisp is a version of the Lisp programming language specifically designed to run on microcontrollers with a limited amount of RAM. It currently supports Arduino AVR boards, Arduino and Adafruit ARM SAMD21 and SAMD51 based boards, Adafruit nRF52840 based boards, BBC Micro Bit, STM32-based boards, ESP8266/ESP32-based boards, and MSP430-based LaunchPad boards. You can use exactly the same uLisp program, irrespective of the platform

4 2020-03-02 17:15

NASA quality Common Lisp library

https://github.com/nasa/pvslib

PVS is a verification system: that is, a specification language integrated with support tools and a theorem prover. It is intended to capture the state-of-the-art in mechanized formal methods and to be sufficiently rugged that it can be used for significant applications. PVS is a research prototype: it evolves and improves as we develop or apply new capabilities, and as the stress of real use exposes new requirements.

PVS 6.0 is the current version. It is open source (under the GPL license), and we also provide pre-built binaries using Allegro Lisp (commercial), and SBCL (open source) for Linux and Intel Macs. See the download page for details.

5 2020-03-04 05:03 *

Read this if you haven't already.
http://jmc.stanford.edu/articles/lisp/lisp.pdf

6 2020-03-04 16:36 *

A tiny Lisp written by Ian Piumarta

It started off really small (about 150 LOC) but I got carried away. I hope you will forgive the bloat. Compiled on x86 with gcc -Os it's about 17 KB for the interpreter and 4 KB the garbage collector (a cheesy, home-made, stop-world, precise collector -- although it can also use the classy, incremental, conservative Boehm-Demers-Weiser one in /usr/lib). That makes for about 21 KB of self-contained Lisp interpreter, including a rudimentary (but useful) FFI and macros, that runs at about 1 million funcalls per second on my Q9450. (If you do something interesting with it in the embedded space, I'd love to hear about that too.)

https://www.piumarta.com/software/lysp/

7 2020-03-05 03:05

Jupyter Kernel for MIT Scheme

https://github.com/joeltg/mit-scheme-kernel
docker image: https://github.com/antimatter15/jupyter-mit-scheme

8 2020-03-05 17:42 *

https://moviecode.tumblr.com/post/88826139010/in-real-humans-%C3%A4kta-m%C3%A4nniskor-some-common-lisp

check this defun make-dog

9 2020-03-06 00:14

Space shooter game that runs in terminal, written in Racket. Pretty fun.

https://gitlab.com/dustyweb/terminal-phase

10 2020-03-08 21:11

Looking for MIT Scheme code actually has a lot to do with archaeology.

https://oeis.org/A091247/a091247.scm.txt

This file contains the Scheme-functions that compute the sequence A091202-A091233 & A091238-A091257 A106442-A106447 & A106451-A106457 & A106490-A106495 found in Neil Sloane's On-Line Encyclopedia of Integer Sequences (OEIS) available at http://www.research.att.com/~njas/sequences/

11 2020-03-11 01:19

http://groups.csail.mit.edu/mac/projects/amorphous

engineering of emergent order: to identify the engineering principles and languages that can be used to observe, control, organize, and exploit the behavior of programmable multitudes

https://groups.csail.mit.edu/mac/projects/amorphous/hlsim/doc/hlsim.html

HLSIM is a simulator for an ensemble of `gunk' processors which allows programs to be written in (nearly) Scheme. The gunk processor is distinguished by having no input or output other than a short-range radio-like communications device, and possibly some local physical sensors and actuators. The need for HLSIM arises out of the desire to simulate thousands of identically-programmed processors running in parallel at a fine grained level of interleaving, without having to worry about the details of the interleaving.

12 2020-03-11 17:00

A fast non-blocking HTTP server on top of libev (Common Lisp)
https://github.com/fukamachi/woo

Cross platform async http-server for Chez Scheme
https://github.com/guenchi/Igropyr

13 2020-03-15 18:36 *

https://www.gnu.org/software/guile/libraries/

14 2020-03-20 06:10

Shill: A Secure Shell Scripting Language

http://shill.seas.harvard.edu/shill-osdi-2014.pdf

15 2020-03-22 07:35 *

Menelaus: Keyboard firmware in Microscheme: https://git.sr.ht/~technomancy/menelaus/tree/when/menelaus.scm

Atreus keyboard: https://atreus.technomancy.us/
Microscheme: https://github.com/ryansuchocki/microscheme

16 2020-03-23 01:23 *

>>15
I don't get the hype for those shitty keyboards with a tiny space bar. This one doesn't have as much as a number row. Maybe they're keyboards for phone users or just a way to brag about buying useless expansive toys?

17 2020-03-25 20:27

GDB can be scripted using Guile. It's very handy, but unfortunately many distros compile it without.

18 2020-03-27 11:09

>>17
Wasn't there a story about GDB maintainers wanting to ditch Guile and support only Python scripting?

19 2020-04-02 06:55 *

Retro game engine for Racket
https://r-cade.io/
https://github.com/massung/r-cade/

20 2020-04-03 15:17 *

slip.js - A performant Scheme interpreter in asm.js
http://noahvanes.github.io/slip.js/

21 2020-04-06 15:57

>>17
xbindkeys can also be configured with Guile, it's nicer than having to write many small shell scripts.
https://www.nongnu.org/xbindkeys/xbindkeysrc.scm.html

22 2020-04-09 16:02 *

https://framagit.org/tyreunom/guile-jsonld
Implementation of the JsonLD algorithms

23 2020-04-10 22:48

https://github.com/zevlg/telega.el
GNU Emacs telegram client

24 2020-04-12 02:23

>>23
It's perfect. Telegram is as far as I can go to communicate with normal people. At least their client is open source.

25 2020-04-13 01:07 *

OpenMusic (OM) is a visual programming language for computer-assisted music composition created at IRCAM, inheriting from a long tradition of computer-assisted composition research.

http://repmus.ircam.fr/openmusic/home

26 2020-04-13 22:12 *

https://github.com/nanomonkey/ssb_emacs
Secure Scuttlebutt for Emacs

27 2020-04-13 22:21 *

https://github.com/carp-lang/Carp
A statically typed lisp, without a GC, for real-time applications.

28 2020-04-27 05:45 *

https://github.com/inconvergent/weir

29 2020-05-07 11:09

https://gitlab.com/a-sassmannshausen/guile-hall

Hall is a command-line application and a set of Guile libraries that allow you to quickly create and publish Guile projects. It allows you to transparently support the GNU build system, manage a project hierarchy & provides tight coupling to Guix.

30 2020-05-08 11:15

>>3
ulisp has been ported to Sipeed Maixduino RISC-V board

http://www.ulisp.com/show?30X8

31 2020-05-23 13:15

An HPC library in CL: https://github.com/marcoheisig/Petalisp

A small web-based livecoding environment for editing images: https://100r.co/site/ronin.html (uses a Lispy DSL named Lain)

32 2020-05-23 20:53

A dependently-typed Lisp-like with dynamic memory: https://github.com/u2zv1wx/neut

33 2020-05-23 20:57

On that note, there's Turnstile, a Racket-based Lisp that implements dependent types on macros: https://dl.acm.org/doi/10.1145/3371071 https://docs.racket-lang.org/turnstile/index.html

34 2020-05-23 21:47

>>31

A small web-based livecoding environment for editing images: https://100r.co/site/ronin.html (uses a Lispy DSL named Lain)

This is damn cool. I needed something simple like that to draw a small logo.

35 2020-05-24 17:41

A Lisp-like language for barebones embedded devices: https://github.com/sbp/hedgehog

36 2020-06-01 15:12

Lisp Window Managers

* StumpWM, a tiling, keyboard driven X11 Window Manager written entirely in Common Lisp: http://stumpwm.github.io/
* CLFSWM is a 100% Common Lisp X11 window manager (based on Tinywm and Stumpwm): https://gitlab.common-lisp.net/clfswm/clfswm
* EXWM (Emacs X Window Manager) is a full-featured tiling X window manager for Emacs: https://github.com/ch11ng/exwm
* wm, A minimalist WM in CL: https://github.com/mgi/wm
* Sawfish, an extensible window manager using an Emacs Lisp-like scripting language: https://github.com/SawfishWM/sawfish (dead?)
* GuileWM, a framework for creating an X window manager: https://github.com/mwitmer/guile-wm (packaged in Guix, not so dead)
* SCWM, the Scheme Constraints Window Manager http://scwm.sourceforge.net/ (last release was 20 years ago, dead)
* Footwm - Focus On One Thing Window Manager, in Chez Scheme: https://github.com/akce/footwm-chez (new project)

37 2020-06-01 17:08 *

>>36
Scwm is also of (historic) interest: http://scwm.sourceforge.net/
https://www.nongnu.org/ratpoison/inspiration.html

38 2020-06-01 17:09 *

>>36,37
Oh, I somehow managed to miss Scwm in your post, sorry.

39 2020-06-06 12:43 *

Lisp Koans
https://github.com/google/lisp-koans

40 2020-06-08 04:27 *

Bintracker
A Chiptune Audio Workstation for the 21st Century
https://bintracker.org/

41 2020-06-15 17:38 *

https://twitter.com/NewLispRepos/
a bot that posts links to new Lisp repos

42 2020-08-16 09:05

I was looking for an open source text-to-speech software for a project. espeak isn't that great. Then I found festival: http://www.cstr.ed.ac.uk/projects/festival/

You interact with it through a Scheme interpreter (it's SIOD I think). Here's a tutorial: http://festvox.org/festtut/notes/festtut_toc.html

43 2020-08-23 13:46 *

Zrythm is a digital audio workstation with GNU Guile scripting: https://www.zrythm.org/en/

44 2020-09-14 19:51

http://nongnu.org/txr/index.html

What is it?

TXR is a pragmatic, convenient tool ready to take on your daily hacking challenges with its dual personality: its whole-document pattern matching and extraction language for scraping information from arbitrary text sources, and its powerful data-processing language to slice through problems like a hot knife through butter. Many tasks can be accomplished with TXR "one liners" directly from your system prompt. TXR is relatively new: the project started in 2009.

It is difficult to give a small introduction to TXR because it is no longer a small language. The PDF rendition of the reference manual, which takes the form of a large Unix man page, is 720 pages long, excluding any index or table of contents. There are many ways to solve a given data processing problem with TXR.

TXR is a fusion of many different ideas, a few of which are original, and it is influenced by many languages, such as Common Lisp, Scheme, Awk, M4, POSIX Shell, Prolog, Ruby, Python, Arc, Clojure, S-Lang and others.

TXR consists of two languages, which can be used separately or tangled together: the TXR Pattern Language, and TXR Lisp.

A comparison may be drawn between the TXR Pattern Language and the Unix utility Awk. Both provide an implicit, convenient way of scanning input. Whereas Awk implicitly reads a file, breaking it into records and fields which are accessible as positional variables, TXR has quite a different way of making input handling implicit: namely via a nested, recursive pattern matching notation which binds variables. This approach still handles delimited fields with relative convenience, but generalizes into handling messy, loosely structured data, or data which exhibits different regularities in different sections, etc. Constructs in TXR (the pattern language) aren't imperative statements, but rather pattern-matching directives: each construct terminates by matching, failing, or throwing an exception. Searching and backtracking behaviors are implicit. It has features like structured named blocks with nonlocal exits, structured exception handling, named pattern matching functions, and numerous other features. TXR's pattern language is powerful enough to parse grammars, yet simple to use in an ad-hoc way on trivial tasks. Speaking of Awk, TXR in fact contains an implementation of Awk, in the form of a Lisp macro, which brings us to the next topic.

The other language in TXR is TXR Lisp. This is not an implementation of an existing Common Lisp or Scheme, but a new dialect, which contains many new ideas. TXR Lisp is feature-rich, and oriented toward succinct, convenient expressivity. While staying completely true to the Lisp heritage, it takes cues from new scripting and functional languages.

TXR Lisp programs are shorter and clearer than those written in some mainstream languages "du jour" like Python, Ruby, Clojure, Javascript or Racket. If you find that this isn't the case, the TXR project wants to hear from you; give a shout to the mailing list. If a program is significantly clearer and shorter in another language, that is considered a bug in TXR.

45


VIP:

do not edit these