The Type-Templates library allows you to define types and “template functions” that can be expanded into various type-specialized versions to eliminate runtime dispatch overhead. It was specifically designed to implement low-level numerical data types and functionality.

cl-sbcl-cl-ipfs-api2 is a pretty simple set of IPFS bindings for Common Lisp, using the HTTP API for (almost) everything, except for pubsub (which uses the locally installed go-ipfs program).

This library provides trivial percent encoding and decoding functions for URLs.

This is a wrapper for the SDL2_TTF library used for loading fonts and creating text assets. The library, in it's current state, can load TTF and OTF fonts and render fonts with the three different rendering modes provided by the C library (solid, shaded, and blended). While Latin text, UTF8, UNICODE, and Glyph text rendering is available only Latin text has been tested (as shown in the examples).

40ants-doc provides a rudimentary explorable programming environment. The narrative primarily lives in so-called sections that mix Markdown docstrings with references to functions, variables, etc., all of which should probably have their own docstrings.

The primary focus is on making code easily explorable by using SLIME's M-. (slime-edit-definition). Generating documentation in Markdown or HTML format from sections and all the referenced items is also implemented.

With the simplistic tools provided, one may obtain results similar to literate programming, but documentation is generated from code, not the other way around, and there is no support for chunking. Code comes first, code must look pretty, documentation is code.

40ants-doc is a fork of MGL-PAX with fewer dependencies (only named-readtables and pythonic-string-reader) for the core system, and additional features in the full system.

simple-neural-network is a Common Lisp library for creating, training and using basic neural networks. The networks created by this library are feedforward neural networks trained using backpropagation.

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.

cl-transmission is a library to interface with the Transmission torrent client using its RPC (remote procedure call).

This package provides a framework to unify arbitrary Common Lisp objects while constructing bindings for placeholders (unification variables) in a template sublanguage.

This package provides CFFI bindings for the stb_vorbis audio library to Common Lisp.

Often times we need to destructure a form definition in a Common Lisp macro. This library provides a set of simple utilities to help with that.

Moira is a library for monitoring and, if necessary, restarting long-running threads. In principle, it is like an in-Lisp process supervisor.

This is a small library to display a native GUI message box. This can be useful to show error messages and other informational pieces should the application fail and be unable to do so using its standard UI.

cl-change-case is a library to convert strings between camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.

BST is a Common Lisp library for working with binary search trees that can contain any kind of values.

one-more-re-nightmare is a regular expression engine that uses the technique presented in Regular-expression derivatives re-examined (Owens, Reppy and Turon, 2009; doi:10.1017/S0956796808007090) to interpret and compile regular expressions.

This package provides a recursive-descent parser DSL for Common Lisp. It's intended as a simpler alternative to parser generators.

This is a simple library to retrieve the argument list of a function.

Support library for numcl that provides Julia-like runtime parametric type correctness in Common Lisp. It is based on CLtL2 extensions.

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.

This library contains code that implements Common Lisp hash tables.

This package provides a JSON Pointer (RFC6901) implementation for Common Lisp. This library aims to be independent from any JSON libraries (as much as possible).

Common Lisp already has major 2 namespaces, function namespace and value namespace (or variable namespace), but there are actually more — e.g., class namespace. This library offers macros to deal with symbols from any namespace.

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