
Lisp Game Jam 2018 - tosh
https://itch.io/jam/lisp-game-jam-2018
======
carloscm
I'm beating my own drum here, but the gameplay code for my game Galactology is
90%+ done in a Lisp dialect (l2l with LuaJIT underneath), clocking at 51K
lines currently. It has been a huge productivity boost since I switched from
C++ two years ago, but I do miss some level of typing and static checking.
[http://thespatials.com/](http://thespatials.com/)

~~~
paines
In a lisp dialect? I thought you went with s7 as an embedde scripting language
for C++!

~~~
carloscm
I originally did. This was fine when the scripting was just doing data setup
in advance, and it wasn't being run per-frame as game logic. When I started
The Spatials V3 (aka Galactology) I also started doing real time game logic in
s7. After enough code it became clear that the fastest purely interpreted
scheme wasn't fast enough to be put into a soft real time path (the game grew
up to hundreds of systems, in the ECS sense).

So I made a 6 months long gameplay development freeze last year and I
converted all the s7-flavored Scheme code into the l2l Lisp dialect with a
custom transpiler (which had to be aware of all the s7-ism plus my own s7
reader macros), and replaced the C++ binding layer with sol2. This resulted in
a ten-fold increase in performance when the game is limited by logic perf
(it's not visible with an empty new game). LuaJIT is alien technology for all
I know.

I have to do a proper write up some day.

~~~
paines
Thanks man. I wish you the best with your game. Sounds like the total dream
job to me. I am eager to read that write up!

------
mbrock
If I had time and energy to participate, one fun idea I have would be to make
an Emacs Lisp game that's some kind of mystery sci-fi thriller based on
coding: like, an Emacs environment that simulates the workstation of an
engineer on a Mars base, with incoming emails from mission command, a fake
Unix shell with space base commands, etc. Kind of like an "epistolary
interactive fiction adventure" with a hacker angle.

~~~
pseudonymcoward
Mind if I steal this idea? I've been meaning to learn some elisp for a while
and games revolving around fictional computer interfaces appeal to me.

~~~
ddingus
Do share, should you end up with something others can enjoy.

------
nathcd
Something maybe of interest to HNers to keep an eye on: I noticed that the
creator of the Carp language tweeted about getting Carp ready for the Lisp
Game Jam.

[https://twitter.com/e_svedang/statuses/977569718101069824](https://twitter.com/e_svedang/statuses/977569718101069824)

[https://github.com/carp-lang/Carp](https://github.com/carp-lang/Carp)

------
swah
This dev does awesome cute little games in Lua in these kinds of competitions,
if you need inspiration: [https://rxi.itch.io/](https://rxi.itch.io/)

~~~
cosarara
Maybe using one of the lisps that compile to lua would be a good idea, since
löve is pretty nice to make games in.

There's quite a lot of them, I don't know how they compare:

[https://github.com/bakpakin/Fennel](https://github.com/bakpakin/Fennel)

[https://github.com/sctb/lumen](https://github.com/sctb/lumen)

[https://github.com/leafo/moonlisp](https://github.com/leafo/moonlisp)

[https://github.com/SquidDev/urn](https://github.com/SquidDev/urn)

------
mfiano
Organizer here. If you have any more questions, need help choosing a Lisp or
graphics framework, or just want to chat with other participants, the IRC
channel and Discord server linked on the jam page are nice resources with
helpful folks. Good luck!

------
skocznymroczny
This looks like it could be fun. I don't know Lisp, but I might be willing to
learn one just for this jam. Can someone recommend a Lisp version that works
on Windows and is easy to setup? Simple 2D graphics like SDL will be enough
for me.

~~~
baggers
I'm biased but I'd go Common Lisp

The basics:

\- SBCL: generates fast[0] code. runs well on windows

\- Quicklisp: The package manager which lets you install the packages
mentioned below

I've got a video here that should help with getting set up on windows
[https://www.youtube.com/watch?v=VnWVu8VVDbI&t=1s](https://www.youtube.com/watch?v=VnWVu8VVDbI&t=1s)

Then you could try the SDL2 approach:

\- cl-sdl2: Bindings over sdl2 [https://github.com/lispgames/cl-
sdl2](https://github.com/lispgames/cl-sdl2)

\- cl-sdl2-mixer: audio playback [https://github.com/lispgames/cl-
sdl2-mixer](https://github.com/lispgames/cl-sdl2-mixer)

\- Some basic math library like: 3d-matrices, rtg-math, sb-cga

Or maybe an existing engine:

\- [https://github.com/borodust/trivial-
gamekit](https://github.com/borodust/trivial-gamekit)

Come down to #lispgames on freenode if you need a hand as there is usually
someone there who has touched this stuff[1]

I'll also pimp my own stuff while I'm here just in case someone is looking for
a lispy layer over gl

\- [https://github.com/cbaggers/cepl](https://github.com/cbaggers/cepl)

Main downside of Common Lisp is that Emacs or Vim are pretty much a
requirement to get a nice development environment, without which you are
pretty much in 'writing Java in notepad' territory.

[0] for some definition of fast that I don't want to belabor this comment
with.

~~~
mtreis86
To get started quickly with SBCL/Quicklisp/Emacs/Slime on Windows:

[https://common-lisp.net/project/lispbox/](https://common-
lisp.net/project/lispbox/)

or

[http://www.iqool.de/lispstick.html](http://www.iqool.de/lispstick.html)

~~~
baggers
I couldn't get anywhere with those last time I tried (2013). LispStick doesn't
seem to have been updated since 2014 and LispBox has had no commits since
2010. Have you used either of these recently? For those wanting to go this
route I'd recommend Portacle which can run on off a usb and includes git

~~~
mtreis86
Thanks. I haven't used windows for development in years and was not aware they
went stale.

------
verytrivial
Please please please pick a theme. Even a vague, open-ended one will provide
some creative tension and give "reviewers" a starting point when reviewing.

~~~
mfiano
Organizer here. We tried a theme last jam and it didn't go so well.

~~~
danbolt
That’s interesting to hear! Usually game jam culture is very receptive towards
themes. What did you find didn’t work?

------
gnode
Can anyone recommend a Lisp dialect / environment which is suitable for web-
based publication, and game multimedia (graphics, audio, control, etc.)?

~~~
johnhattan
That's always my problem when I look at lisp for game programming. If I say "I
want to write a standalone 3D iPhone game using C#", there are plenty of sites
that'll show me exactly what tools are out there, how they work together, and
how to write/debug/package a complete game.

With Lisp, I often end up in the weeds looking at tools and tech that may or
may not still be supported. I have a hard time figuring out a well-established
set of tools that'll get me a first-class playable game in Lisp.

If anything I'm going to watch this game jam just to see what everyone's using
and how good the results look.

~~~
gameswithgo
if you can find bindings to SDL2 it is easy enough to do 2d games

add opengl and you can do 3d games

------
fulafel
Does using Arcadia (Clojure for Unity, [https://github.com/arcadia-
unity/arcadia](https://github.com/arcadia-unity/arcadia)) qualify?

------
holtalanm
i just started learning Common Lisp a couple of weeks ago. Coming from a
strong OO programming background, i can honestly say it is a completely
different mind-set.

So far, i like it a lot, but i wouldn't consider myself anywhere near
proficient enough in it to make a game. Looking forward to seeing what the
products of this Jam are.

~~~
kbp
> i just started learning Common Lisp a couple of weeks ago. Coming from a
> strong OO programming background, i can honestly say it is a completely
> different mind-set.

You might not see it much in beginner materials, but idiomatic Lisp code tends
to be fairly object-oriented, using the Common Lisp Object System (CLOS). CLOS
is still a bit different from OOP in a language like Java, though: it's a much
more powerful object system.

------
mtreis86
The discord invite on that page has expired, does anyone have a current
invite?

~~~
mfiano
Organizer here. The link on the jam page has now been fixed.

------
Grue3
>Must be written in any dialect of Lisp. This includes, but is not limited to
Common Lisp, Scheme, Emacs Lisp, and Clojure.

How are these dialects of each other? By this logic, Javascript is a dialect
of C.

~~~
rekado
They are not dialects of _each other_ but all are Lisp dialects. You would not
call Scheme a dialect of Emacs Lisp, but both are Lisp dialects.

~~~
lonjil
If your only qualifier for something being a dialect of "Lisp" is having lots
of parentheses, and a bunch of stuff that basically every high level language
has these days, like first class functions and garbage collection, sure.

I wouldn't consider something a dialect unless they were similar enough that
most code that works in one works in the other with minimal modification. Old
Lisp code does not work in Scheme. A lot of it _does_ however work in Emacs
Lisp and Common Lisp.

So Scheme being in a Lisp "family"? Sure. But not a dialect.

~~~
kbp
> I wouldn't consider something a dialect unless they were similar enough that
> most code that works in one works in the other with minimal modification.

I agree, but Scheme passes this test more than you might think. When it
originally appeared, it really didn't stand out from the crowd of Lisp 1.5
successors that much at all. It even piggybacked off of its host Maclisp
implementation, directly calling Maclisp functions extensively from Scheme, to
provide any functionality that there wasn't any point re-implementing (ie,
most of it). It was basically just a Maclisp package.

Modern Scheme still has a lot of features in common with Maclisp of this time
(and by extension Common Lisp), like DO (although Scheme's do has slightly
different semantics because it's a macro over tail recursion rather than
gotos; subtle differences like this are to be expected between dialects), and
it's still based off list structure in exactly the same way that Lisps always
have been, so there's still CONS, CAR, CDR, RPLACA (renamed set-car!), RPLACD
(renamed set-cdr!), NCONC (renamed append!), and so on.

Scheme's lexical scoping also made it back into mainline Lisp, and was a
pretty big contribution to Common Lisp. A lot of features like CLOS, SETF, and
DEFMACRO (none of which were in Lisp 1.5) are very commonly provided by Scheme
implementations.

Using the historical argument, there's no question at all that Scheme is Lisp.
The majority of ancient Lisp programs can be run under modern Schemes with
simple compatibility packages. When all the other Lisps either merged into CL
or died, though, Scheme continued to be actively used, and as time went on the
Scheme community shared less and less code with the mainline Lisp community.
Some people argue that with the modern state of things it's not really useful
to talk about Scheme as Lisp now, because they kind of "left" Lisp and went
off on their own, philosophically. Scheme definitely began as just another
Lisp, though.

~~~
kbp
As a side note, Scheme originally offered ASET (SET) but not a SETQ equivalent
(they hadn't adopted the ! convention yet), saying: "Those of you who may
complain about the lack of ASETQ are invited to write (ASET' foo bar) instead
of (ASET 'foo bar)."

