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.

This is a Common Lisp library to calculate std140 or std430 layouts for a glsl UBO/SSBO.

A common lisp library that provides extensible function result caching based on arguments (an expanded form of memoization).

This is a Common Lisp kernel for Jupyter along with a library for building Jupyter kernels, based on Maxima-Jupyter which was based on cl-jupyter.

Optima is a fast pattern matching library which uses optimizing techniques widely used in the functional programming world.

Trivia is a pattern matching compiler that is compatible with Optima, another pattern matching library for Common Lisp. It is meant to be faster and more extensible than Optima.

trivial-clipboard gives access to the system clipboard.

This is a collection of useful helper modules and standard implementations for Radiance interfaces.

Generic documentation builder for Common Lisp projects.

This library implements the base58 encoding algorithm. It's basically base64 but with a smaller alphabet (58, as in the name) that doesn't include similar looking characters, among other things. See https://github.com/bitcoin/bitcoin/blob/master/src/base58.h for a full reference.

string-case is a Common Lisp macro that generates specialised decision trees to dispatch on string equality.

This is a Common Lisp package for hash table creation with flexible, extensible initializers.

Nsymbols extends the regular package API of ANSI CL with more operations, allowing one to list:

• package-symbols.

• package-variables.

• package-functions.

• package-generic-functions.

• package-macros.

• package-classes.

• package-structures.

• And other symbol types, given define-symbol-type for those.

Nsymbols can also find symbols by their name/matching symbol with resolve-symbol. All these operations are aware of symbol visibility in the given packages, due to a symbol-visibility function.

An additional nsymbols/star system has a set of functions mirroring the regular Nsymbols ones, but using closer-mop to provide better results and returning structured data instead of symbols.

This is a utility kit for functionality related to OpenGL. It provides the following:

• kit.glm: This re-exports sb-cga and mathkit for convenience.

• kit.gl.shader: This provides shader dictionary and compilation functionality similar to what was originally found in sdl2kit.

• kit.gl.vao: This provides an interface for Vertex Array Objects.

A client for the Stripe payment API.

This package provides a standard interface to the various package lock implementations of Common Lisp.

This package provides a common lisp CFFI wrapper for the SciPy version of Cephes special functions.

This is a simple extension to MODULARIZE that allows modules to define and trigger hooks, which other modules can hook on to.

Parseq (pronounced parsec) is a parsing library for common lisp. It can be used for parsing lisp's sequences types: strings, vectors (e.g. binary data) and lists. Furthermore, parseq is able to parse nested structures such as trees (e.g. lists of lists, lists of vectors, vectors of strings).

Parseq uses parsing expression grammars (PEG) that can be defined through a simple interface. Extensions to the standard parsing expressions are available. Parsing expressions can be parameterised and made context aware. Additionally, the definition of each parsing expression allows the arbitrary transformation of the parsing tree.

The library is inspired by Esrap and uses a very similar interface. No code is shared between the two projects, however. The features of Esrap are are mostly included in parseq and complemented with additional, orthogonal features. Any resemblance to esrap-liquid is merely coincidental.

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

BOOST-PARSE is a simple token parsing library for Common Lisp.

Clack is a web application environment for Common Lisp inspired by Python's WSGI and Ruby's Rack.

This Common Lisp library provides bindings for the ZeroMQ lightweight messaging kernel.

This package provides a Common Lisp library for defining OpenGL shader programs. There are also functions for referencing shader programs by name, querying for basic information about them, modifying uniform variables throughout the lifecycle of an OpenGL application, and managing certain OpenGL buffer object types (UBO, SSBO currently).