FSet is a functional set-theoretic collections library for Common Lisp. Functional means that all update operations return a new collection rather than modifying an existing one in place. Set-theoretic means that collections may be nested arbitrarily with no additional programmer effort; for instance, sets may contain sets, maps may be keyed by sets, etc.

This is a bindings and wrapper library to libmpg123 allowing for convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3) files.

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.

Convenient macros for common lambda patterns.

This is a binding to the libyaml library. It's not meant as a full library for YAML, just a bare binding with a couple of utility macros. For a YAML parser and emitter using this, check out cl-yaml.

This package provides CFFI bindings for Common Lisp to the Cairo C library.

This package implements an algorithm for the spelling of enharmonics and dealing with ties and dots in rhythm notation.

CLML (Common Lisp Machine Learning) is a high performance and large scale statistical machine learning package

CL-FAST-ECS is a Common Lisp library providing an implementation of the ECS pattern, primarily focused on speed and interactive development.

ECS is an architectural data-oriented design pattern that allows for the effective processing of a large number of in-game objects while keeping the code and data separated. This provides flexibility in the way that game objects are built at runtime.

This is a Common Lisp library for simplifying packaging and loading of compiled foreign library collection.

FLARE is a library designed to allow quick and precise particle effect creations. It does not concern itself with displaying and only with the management and movement of particles. As such, it can easily be integrated into any existing or future application.

Dissect is a small Common Lisp library for introspecting the call stack and active restarts.

This library provides a tiny Common Lisp wrapper around setlocale(3) and can be used in conjunction with other FFI wrappers like cl-charms.

This library implements various functions to access status information about the machine, process, etc.

This package provides prototype Common Lisp implementations of TLS, RFC5246, ASN.1, x501,509, and PKCS1,3,5,8.

This is futures implementation for Common Lisp. It plugs in nicely to cl-async.

HTTP-Body parses HTTP POST data and returns POST parameters. It supports application/x-www-form-urlencoded, application/json, and multipart/form-data.

This is a Common Lisp library providing functions to read/write CSV from/to strings, streams and files.

nontrivial-gray-streams is a compatibility system for Gray streams, which is an extension to Common Lisp that makes it possible to implement Common Lisp streams using generic functions.

Common Lisp library for channel-based concurrency. In a nutshell, you create various threads sequentially executing tasks you need done, and use channel objects to communicate and synchronize the state of these threads.

cl-template is a template engine for Common Lisp, taking inspiration from Ruby's ERb module.

This is a purely math-related utility kit, providing functions which can be useful for games, 3D, and GL in general.

This package provides a client for SMTP.

This package provides Common Lisp system collecting tools written to wrangle OpenGL Shader Language (GLSL) source files.