Skip to content


Subversion checkout URL

You can clone with
Download ZIP
2D game programming library for GNU Guile - Moved to Gitorioius and renamed to Sly

This branch is 128 commits behind master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.


Guile-2d is a 2D game programming library for GNU Guile. It is a layer above SDL and OpenGL that provides abstractions for common 2D game programming requirements such as:

  • Sprites
  • Animation
  • Tilesets
  • Tile maps
  • Scene graph
  • Input handling
  • Scripting


Every programming language should have a fun, easy to use 2D game library. Guile-2d draws its inspiration from great libraries/frameworks such as LÖVE, Pygame, and Pyglet.


Here is the simplest Guile-2d application (so far).

(use-modules (2d sprite)
             (2d game-loop)
             (2d window)
             (2d helpers))

(define window-width 800)
(define window-height 600)

;; Open the window.
(open-window window-width window-height)

;; Load a sprite and center it on the screen.
(define sprite
  (load-sprite "sprite.png"
               #:position (vector (/ window-width 2)
                                  (/ window-height 2))))

(define (quit-demo)

(define (key-down key mod unicode)
  (cond ((any-equal? key 'escape 'q)

;; Draw our sprite
(define (render)
  (draw-sprite sprite))

;; Register hooks. Lambdas are used as "trampolines" so that render
;; and key-down can be redefined later and the hooks will call the
;; updated procedures.
(add-hook! on-quit-hook (lambda () (quit-demo)))
(add-hook! on-render-hook (lambda () (render)))
(add-hook! on-key-down-hook (lambda (key mod unicode) (key-down key mod unicode)))

;; Start the game loop.
;; The render callback will be called through this procedure.



Sprites encapsulate the presentation of an image or a region of an image.

The simplest way to get started with sprites is to use the load-sprite procedure. All arguments except the filename are optional keyword arguments.

Guile-2d uses the FreeImage library and can load many different image formats. See the FreeImage features page for a full list of supported formats.

(define sprite
  (load-sprite "cirno.png"
               #:position #(0 0)
               #:scale (1 1)
               #:rotation (0)
               #:color white
               #:anchor 'center))

Alternatively, you can make a sprite from an existing texture. The same keyword arguments in load-sprite are also available here.

(define sprite (make-sprite (load-texture "cirno.png")))

Position, scale, rotation, color, and anchor are mutable.

(set-sprite-position! sprite #(100 100))

Drawing a sprite is simple.

(draw-sprite sprite)

Sprite Batches

When drawing many sprites, it is inefficient to send them to the GPU individually. Sprite batches resolve this issue by sending sprites to the GPU in large chunks.

To take advantage of this, create a sprite batch and use with-sprite-batch. All calls to draw-sprite will use the sprite batch within this form.

(define sprites (make-a-ton-of-sprites))

(define batch (make-sprite-batch))

(with-sprite-batch batch
  (for-each draw-sprite sprites))

Coroutines and Agendas

The ability to write scripts is very important for most games. A script for an RPG NPC could look like this:

;; Walk up one tile and then down one tile, forever.
(while #t
  (walk 'up)
  (walk 'down))

Unfortunately, running this script as it is means completely locking up the program in an unbounded loop. However, coroutines (and a scheduler known as the “agenda”) are here to save the day! Coroutines are procedures that can be exited at any point and resumed later.

It would be nice if after every call to walk, the NPC would wait for one second before taking its next step. This is where the agenda comes in. The agenda is used to schedule procedures to be run after an arbitrary number of game updates (1 by default). Since coroutines and the agenda go hand in hand, there exists a wait procedure to pause a coroutine and schedule it to be resumed later.

Using a coroutine and the agenda, the NPC script can be rewritten such that it does not halt further program execution.

 (colambda ()
   (while #t
     (walk 'up)
     (wait 60)
     (walk 'down)
     (wait 60))))

colambda is a useful macro that is syntactic sugar for a lambda expression executed as a coroutine. agenda-schedule accepts a thunk (a procedure that takes 0 arguments) and schedules it to be executed later. In this example we do not provide a second argument to agenda-schedule, which means that the thunk will be executed upon the next game update.

Since guile-2d enforces a fixed timestep and updates 60 times per second, waiting for 60 updates means that the NPC will wait one second in between each step.


Actions encapsulate a procedure that operates over a certain period of time. Action objects have two properties: an arbitrary procedure and a duration in game ticks. Action procedures accept one argument: a time delta in the range [0, 1]. Use actions in combination with coroutines for things that are a function of time, such as moving a sprite across the screen.

 ;; Move horizontally across the screen, starting at x=0 and moving to
 ;; x=800, in 60 ticks.
  (lerp (lambda (x)
          (set-sprite-position! sprite (vector x (/ window-height 2))))
        0 800 60))

schedule-action is used to schedule a coroutine that will perform the given action in the current agenda. lerp is a type of action, short for linear interpolation. lerp takes an arbitrary procedure to apply at each tick, a start value, an end value, and like all other actions, a duration. The code above interpolates from 0 to 800 over 60 ticks. The result of this action is a sprite moving across the screen from left to right.

Actions can be combined to run in a sequence or in parallel.

  (lerp (lambda (x)
          (set-sprite-position! sprite (vector x (/ window-height 2))))
        0 800 60)
  ;; Rotate sprite 1080 degrees in 120 ticks.
  (lerp (lambda (angle)
          (set-sprite-rotation! sprite angle))
        0 1080 120)))

action-parallel will combine many actions into one action that does everything at the same time. In the example above, the sprite will still move across the screen from left to right, but while it’s doing so (and for 60 ticks after), it will be rotating from 0 to 1080 degrees.

REPL Driven Development

The read-eval-print-loop present in Guile allows you to develop your game while it is running! This allows you to see in real time what your changes do to the game without having to restart the program every time.

** This section needs to be completed. **


guile-2d uses the typical GNU build system. First run `` and then do the usual incantations.

sudo make install

Running Examples

To run an example when guile-2d has been installed:

cd examples
guile simple.scm

To run an example using the not-yet-installed files (useful when developing):

cd examples
guile -L .. simple.scm


  • GNU Guile >= 2.0 (>= 2.0.9 recommended)
  • guile-figl

    No official release. guile-2d runs off of the latest master version.

    As of this writing, make will fail due to errors with building texinfo files. Currently there is an error on line 19152 of doc/low-level-gl.texi. To fix, join lines 19152 and 19153 together.

  • guile-sdl >= 0.5.0
  • SDL 1.2
  • FreeImage >= 3.0
  • FTGL >= 2.1



Something went wrong with that request. Please try again.