The Spring Lisp Game Jam 2024 ended one week ago. 48 games were submitted, a new record for the jam! This past week has been a time for participants to play and rate each other’s games. As I explored the entries, I noticed two distinct meta-patterns in how people approached building games with Lisp. I think these patterns apply more broadly to all applications of Lisp. Let’s talk about these patterns in some detail, with examples. But first! Here’s the breakdown of the jam submissions by language: I haven’t rolled up the various Schemes (Guile, Racket, S7, Kawa) into a general scheme category because Scheme is so minimally specified and they are all very distinct implementations for different purposes, not to mention that Racket has a lot more going on than just Scheme.
Description: A creative illustration representing game development with Lisp.
For the first time ever, Guile came out on top with the most submissions! There’s a very specific reason for this outcome. 11 out of the 15 Guile games were built for the web with Hoot, a Scheme-to-WebAssembly compiler. Two of those 11 were official Spritely projects. We put out a call for people to try making games with Hoot before the jam started, and a lot of people took us up on it! Very cool!
The next most popular language, which is typically the most popular in these jams, is Fennel. Fennel is a Lisp that compiles to Lua. It’s very cool, too! Also of note, three games used S7. There might be something relevant to this post going on there. The patterns I’m about to talk about could sort of be framed as “The Guile Way vs. The Fennel Way”, but it’s not an “us vs. them” thing. It’s wonderful that there are so many flavors of Lisp these days that anyone can find a great implementation that suits their preferences. Not only that, but many of these implementations can be used to make games that anyone can easily play in their web browser!
Lisp as Icing
The icing pattern is using Lisp as a “scripting” language on top of an application largely built with static languages like C or Rust. This pattern involves embedding a Lisp interpreter into a larger program. If you're most interested in writing the high-level parts of an application in Lisp, then this pattern is the fastest way to achieve that goal.
For example, Fennel integrates well with existing applications like Love2D, providing a lispy syntax on top of Lua without changing the underlying system. This approach provides instant gratification but ties closely to static languages and their toolchains.
Lisp as Cake
The cake pattern uses Lisp to implement as much of the software stack as possible. Rather than embedding Lisp into a non-Lisp program, the cake pattern does the inverse: the majority of the program is written in Lisp, calling necessary shared libraries only when absolutely needed. This approach usually takes longer to yield results due to the time spent implementing missing libraries and writing C library wrappers.
Guile is an excellent example of a Lisp that shines best as cake.
Case Studies
Fennel + Love2D
Love2D has been popular for small team game development. It's a C++ program that embeds a Lua interpreter, making it a perfect target for Fennel. This stack is an example of Lisp as icing, as Fennel sits at the very top without extending into the underlying layers.
S7 + Raylib
Two games used this stack, combining the S7 Scheme interpreter with C’s Raylib library. This stack represents another instance of Lisp as icing, providing a Lisp syntax on top of a well-established C library.
Guile + Chickadee
Chickadee is a game library for Guile that implements almost all of the interesting parts in Scheme. This stack exemplifies Lisp as cake. Chickadee wraps some C libraries for low-level tasks but is written in pure Scheme.
Edworking is the best and smartest decision for SMEs and startups to be more productive. Edworking is a FREE superapp of productivity that includes all you need for work powered by AI in the same superapp, connecting Task Management, Docs, Chat, Videocall, and File Management. Save money today by not paying for Slack, Trello, Dropbox, Zoom, and Notion.
The Cake/Icing Spectrum
Even the tallest of Lisp cakes sits atop an even larger cake made mostly of C. Modern Lisp systems typically bottom out at some point: Emacs, Guile's VM, and Hoot’s necessity for mammoth JavaScript engines. Despite this, each reclaiming of stack components written in Lisp is a small victory.
As more of the stack becomes Lisp, it begins to look less like icing and more like cake. A great example is the Guix project, which replaces the Nix language with Guile. This allows for improved hackability and code sharing. The insistence on maximizing the use of Lisp has contributed to Guix’s success over the years.
Remember these 3 key ideas for your startup:
Leverage Existing Tools – Utilize existing tools and libraries such as Fennel and Love2D to build upon robust and proven systems.
Innovate with Lisp – Embrace both patterns (icing and cake) depending on your project’s needs, aiming for innovative and flexible solutions.
Maximize Hackability – Follow Guix's successful model by prioritizing hackability and code sharing within your development process.
Description: A visual metaphor of the "Lisp cake" approach highlighting layers of Lisp code.
By embracing these patterns and leveraging Lisp for both scripting and comprehensive implementations, startups can enjoy robust, adaptable, and innovative project developments.
For more details, see the original source.
