A Lisp Games Jam is a timed, community-driven event in which participants create video games using dialects of the Lisp programming language (such as Common Lisp, Scheme, Clojure, or Emacs Lisp). Typically lasting from a weekend to a month, these jams emphasize creativity, rapid prototyping, and the unique expressiveness of Lisp's symbolic computation paradigm. They often encourage use of specific Lisp-based game libraries or retro aesthetics, and serve as both a technical challenge and a celebration of the language family's culture.
1 History
1.1 Origins in the Lisp hacker community
The concept of Lisp Games Jams emerged from the long‑standing hacker tradition of short‑duration programming contests. Lisp hackers, already known for exploratory programming and interactive development, began organizing informal gatherings to create small games. These early events were often announced on mailing lists and Usenet groups such as comp.lang.lisp, where participants shared a love for the language’s flexibility and macro system.
1.2 Notable earlier jams (e.g., "Lisp Game Jam" on itch.io)
One of the earliest documented Lisp‑specific jams was the “Lisp Game Jam” first hosted on itch.io around 2014. It attracted a small but dedicated group of developers who built games using Common Lisp, Scheme, and Clojure. The jam’s repository on itch.io recorded dozens of entries over subsequent editions, many of which showcased the capabilities of Lisp game libraries like cl‑game and Qtools.
1.3 Relation to broader game jam movements (Ludum Dare, Global Game Jam)
Lisp Games Jams were directly inspired by larger, language‑agnostic events such as Ludum Dare (founded 2002) and the Global Game Jam (founded 2009). Organizers adopted similar time constraints (e.g., 48 hours) and theme‑voting mechanisms. However, the Lisp‑focused jams carved out a niche by emphasizing the language’s unique features—such as REPL‑driven iteration and homoiconic code—over cross‑platform compatibility or mass appeal.
2 Format and Rules
2.1 Duration and time zones
Most Lisp Games Jams run for 48 hours over a weekend, mirroring Ludum Dare’s classic format. Some extended jams last a full week or even a month to accommodate participants with limited free time. Start and end times are typically announced in UTC to allow global participation, with a grace period of a few hours for submission.
2.2 Theme announcement and voting
Themes are either pre‑selected by organizers or decided through community voting. In the voting phase, participants propose themes (e.g., “one button,” “minimalist,” “growth”), and the most popular one is announced at the start of the jam. Some jams allow optional sub‑themes related to Lisp idioms, such as “use a macro” or “maximize recursion.”
2.3 Submission platforms (itch.io, GitHub)
The primary submission platform is itch.io, which offers dedicated jam pages, tags, and rating systems. Many participants also archive their source code on GitHub or GitLab, often under permissive licenses to facilitate learning. Organizers may provide a central repository listing all entries.
2.4 Judging criteria
2.4.1 Gameplay
Gameplay is judged on fun, clarity, and polish. Given the time constraints, a simple but well‑executed mechanic is valued more than a complex but buggy implementation.
2.4.2 Lisp idiom usage
Entries are evaluated on how effectively they leverage Lisp‑specific features, such as macros, higher‑order functions, and interactive development. A game that feels “written in Lisp” (rather than a port from another language) scores higher.
2.4.3 Code elegance
Code elegance encompasses readability, proper use of data structures, and minimal duplication. Judges often reward concise, idiomatic Lisp code that demonstrates the language’s expressive power.
3 Participating Lisp Dialects
3.1 Common Lisp
Common Lisp is the most prevalent dialect in Lisp Games Jams, thanks to its mature implementations (e.g., SBCL, CCL) and extensive library ecosystem. Participants frequently use its condition system for error handling during rapid prototyping.
3.1.1 Libraries and frameworks (e.g., cl-game, Qtools)
The library cl‑game provides low‑level graphics, input, and audio handling for Common Lisp. Qtools, built on the Qt framework via Common Lisp bindings, offers a higher‑level widget‑based interface. Other popular libraries include lispbuilder‑game for 2D graphics and cl‑SDL2 for direct SDL2 access.
3.2 Scheme
Scheme dialects appear less frequently but are valued for their minimalism and educational appeal. R5RS and R6RS are common, but many participants use Racket for its richer library support.
3.2.1 Racket-based game development (e.g., 2htdp/image)
Racket’s 2htdp/image library, part of the “How to Design Programs” curriculum, allows easy creation of 2D graphics with simple function calls. Additionally, the racket/gui and racket/draw libraries enable more advanced game loops. Racket’s macro system is occasionally used to embed domain‑specific game description languages.
3.3 Clojure
Clojure, a modern Lisp dialect running on the Java Virtual Machine and JavaScript runtimes, is popular for web‑based games. Its immutable data structures and concurrency support suit turn‑based and real‑time games alike.
3.3.1 ClojureScript for web games
ClojureScript, a Clojure compiler targeting JavaScript, allows participants to deploy games directly in the browser. Libraries such as re‑frame (for reactive state management) and play‑clj (a game engine) are commonly used. The convenience of hot‑reloading during development aligns well with the jam’s iterative spirit.
3.4 Emacs Lisp
Emacs Lisp (Elisp) is a niche but beloved dialect for creating text‑based games that run inside the Emacs editor. Its tight integration with Emacs’ buffer and keybinding system makes it ideal for interactive fiction and roguelikes.
3.4.1 Text-based and terminal games
Elisp games typically use insert, overlay, and key‑binding functions to display ASCII art and handle input. The ert testing framework and Emacs’ built‑in debugger help participants iterate quickly. Notable examples include terminal roguelikes and choose‑your‑own‑adventure stories.
4 Typical Game Genres
4.1 Roguelikes and dungeon crawlers
Roguelikes are a staple of Lisp Games Jams because they rely on procedural generation and state management—areas where Lisp’s list processing and recursion shine. ASCII or tile‑based representations are common, with turn‑based mechanics that fit the 48‑hour development cycle.
4.2 Puzzle games
Puzzle games, such as Sokoban clones or block‑sliding puzzles, are frequently submitted. Their logic can be expressed concisely using Lisp’s functional abstractions, and the absence of complex real‑time graphics reduces development time.
4.3 Interactive fiction and text adventures
Text adventures and interactive fiction leverage Lisp’s symbolic nature and macro capabilities for natural language parsing. Participants often implement simple parsers using read and pattern‑matching libraries. Z‑machine emulators built in Lisp also appear.
4.4 Retro arcade clones (pong, space invaders)
Classic arcade games like Pong, Space Invaders, and Snake are popular for their simple mechanics and minimal graphics. These serve as excellent platforms for demonstrating the performance of Lisp’s game loops and low‑level graphics bindings.
5 Known Instances
5.1 "Lisp Game Jam 2020"
The “Lisp Game Jam 2020” was hosted on itch.io in September 2020, with the theme “Limitation.” It attracted over 40 participants who submitted games in Common Lisp, Clojure, and Racket. The jam emphasized code sharing and post‑jam improvements.
5.1.1 Winning entries
First place went to a roguelike titled “Dungeon of Macros,” which used Common Lisp macros to procedurally generate both the dungeon layout and player spells. Second place was a Racket‑based puzzle game called “Crate Expectations.” Third place was a ClojureScript browser game, “One‑Button Alchemy.”
5.2 "Clojure Game Jam" (2018)
The “Clojure Game Jam” took place in March 2018, organized by the Clojure community on Slack. Its theme was “Growth,” and submissions were required to use Clojure or ClojureScript. The event saw 25 finished entries, many of which were web‑based.
5.2.1 Collaboration with ClojureBridge
The jam partnered with ClojureBridge, a workshop series for underrepresented groups in tech, to offer mentoring and pair‑programming sessions. Several ClojureBridge participants submitted their first game ever during the jam.
5.3 "SBCL Spring Jam"
The “SBCL Spring Jam” (2021) was a small, informal event centered around Steel Bank Common Lisp (SBCL). It focused on optimizing game performance and featured a workshop on using SBCL’s profiling tools. The jam produced a half‑dozen games, including a fast‑paced asteroid shooter.
6 Community and Culture
6.1 Use of REPL-driven development
A defining characteristic of Lisp Games Jams is the heavy reliance on REPL‑driven development. Participants frequently modify game state and functions live while the game is running, allowing instant feedback. This workflow reduces iteration time and is often cited as a major advantage over traditional edit‑compile‑run cycles.
6.2 Sharing code and post-mortems
After each jam, participants are encouraged to share their source code, often on GitHub with detailed README files. Many write “post‑mortem” blog posts analyzing what went well and what challenges they faced, fostering a culture of learning and mutual support.
6.3 Inside jokes and Lisp-specific memes
The community nurtures a playful atmosphere with inside jokes rooted in Lisp culture. Jokes about parentheses, macro abuse, and the “Lisp curse” (the tendency to over‑engineer solutions) are common.
6.3.1 "(format t " hello world")"
The classic Lisp one‑liner (format t "hello world") is a recurring meme, often used ironically in jam announcements and code reviews. It symbolizes the simplicity and elegance that participants strive for—or deliberately subvert by writing overcomplicated “hello world” programs.
7 Legacy and Influence
7.1 Contributions to Lisp game engines
Several libraries and tools have been developed or refined as a direct result of Lisp Games Jams. For example, the “cl‑game” library gained new features like sprite batching and audio mixing after being tested in multiple jams. Racket’s “2htdp/image” was inspired by the need for beginner‑friendly graphics in jam settings.
7.2 Cross-pollination with functional programming game jams
The success of Lisp Games Jams inspired similar events for other functional languages, such as Haskell Game Jams and OCaml Game Jams. Organizers often cross‑promote and share infrastructure (e.g., itch.io templates, judging rubrics). Concepts like REPL‑driven game development have since been adopted by non‑Lisp jams, particularly those for F# and Elixir.