MGL-GPR is a library of evolutionary algorithms such as Genetic Programming (evolving typed expressions from a set of operators and constants) and Differential Evolution.

fast-websocket is an optimized low-level WebSocket protocol parser/composer.

This is a keymap facility for Common Lisp inspired by Emacsy (keymap.scm) which is inspired by Emacs.

• Support prefix keys to other keymaps. For instance, if you prefix my-mode-map with C-c, then all bindings for my-mode will be accessible after pressing C-c.

• List all bindings matching a given prefix. (Also known as which-key in Emacs.)

• List the bindings associated to a command.

• Support multiple inheritance.

• Support keycode.

• Validate keyspec at compile time.

• define-key can set multiple bindings in a single call.

• Support multiple scheme to make it easy to switch between, say, Emacs-style and VI-style bindings. This orthogonality to keymaps composes better than having multiple keymaps: changing scheme applies to the entire program, which is easier than looping through all keymaps to change them.

• Translate keyspecs as a fallback. For instance if shift-a is not bound, check A.

• Behaviour can be customized with global parameters such as *print-shortcut*.

• The compose function can merge multiple keymaps together.

• Support multiple arguments when that makes sense (e.g. multiple keymaps for lookup-key).

• Key remapping à-la Emacs.

• Typed keymaps, i.e. keymaps where bound values can only be of a given type. This is convenient to catch typos, for instance when binding 'FOO instead of #'FOO.

Common Lisp implementation of Graham Cormode and S. Muthukrishnan's Effective Computation of Biased Quantiles over Data Streams in ICDE’05.

Cells is a mature, stable extension to CLOS allowing one to create classes whose instances can have slot values determined by instance-specific formulas.

This package provides a simple yet powerful value inheritance scheme.

This package provides a Common Lisp wrapper system for the SDL 2.0 Mixer C Library.

This library is a collection of functions and macros for manipulating Common Lisp arrays and performing numerical calculations with them.

This is a small library providing the ISO-639 language code to language name mapping.

Metatilities-base is the core of the metatilities Common Lisp library which implements a set of utilities.

Typo is a portable library for Common Lisp that does approximate reasoning about types, but without consing.

Colony provides a system and workflow that helps describe the elements needed to write 2D or 3D games. It was designed with several domain specific languages that make it easier to describe, manipulate, and use assets commonly found in game making. Such assets include (but are not limited to) textures, materials, shader programs, and scene trees of actors that are available for instantiation. Colony Engine also knows how to accept input from keyboards and most joysticks and gamepads.

The component system is a hybrid model between an ECS and an object model. The components are defined similar to CLOS defclass, and regular generic methods can be used with them. Components are added to Actors which represent game concepts like players, scenery, effects, etc. We define a component protocol invoked by Colony Engine to move your components to the next state and render them each frame.

This library is a collection of utilities for writing compiler macros. It is intended to make it possible to make compiler macros much more useful, by granting them access to lexical type information, making the protocol for declining expansion more convenient, and establishing some information for signaling optimization advice to programmers. Some utilities to support this, especially for reasoning on types, are also included.

This package provides a SuperCollider client for Common Lisp.

This is a system for two dimensional computational geometry for Common Lisp.

Note: the system assumes exact rational arithmetic, so no floating point coordinates are allowed. This is not checked when creating geometric objects.

ASDF-FLV provides support for file-local variables through ASDF. A file-local variable behaves like *PACKAGE* and *READTABLE* with respect to LOAD and COMPILE-FILE: a new dynamic binding is created before processing the file, so that any modification to the variable becomes essentially file-local.

In order to make one or several variables file-local, use the macros SET-FILE-LOCAL-VARIABLE(S).

Spatial-trees is a set of dynamic index data structures for spatially-extended data.

This is a wrapper library to allow you to interface with the Valve SteamWorks API.

This is a Common Lisp library to build and compose SXQL queries dynamically.

This package provides an example implementation of the Common Lisp condition system and library, based on the original condition system implementation by Kent M. Pitman.

This package contains the specification of all functions and variables from GLSL as data.

Croatoan provides high-level Common Lisp CLOS bindings for the ncurses terminal library.

This library is a redefinition of the standard Common Lisp package that includes a number of renames and shadows.

FLOW is a flowchart graph library. Unlike other graphing libraries, this one focuses on nodes in a graph having distinct ports through which connections to other nodes are formed. This helps in many concrete scenarios where it is important to distinguish not only which nodes are connected, but also how they are connected to each other.

Particularly, a lot of data flow and exchange problems can be reduced to such a flowchart. For example, an audio processing library may present its pipeline as a flowchart of segments that communicate with each other through audio sample buffers. Flow gives a convenient view onto this kind of problem, and even allows the generic visualisation of graphs in this format.