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.

CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp library for working with OpenGL.

Its definition of success is making the user feel that GPU programming has always been part of the languages standard.

The usual approach to using CEPL is to start it at the beginning of your Lisp session and leave it open for the duration of your work. You can then treat the window it creates as just another output for your graphics, analogous to how *standard-output* is treated for text.

Splits sequence into a list of subsequences delimited by objects satisfying the test.

Clop is a Common Lisp library for parsing strings in the TOML configuration file format.

BOOST-JSON is a simple JSON parsing library for Common Lisp.

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

This package provides a concise, intuitive and flexible macro for trivial lambdas that eschews explicit naming of parameter variables in favor of positional references, with support for a used or ignored &rest parameter and automatic declaration of ignored parameters when logical gaps are left in the positional references. Further convenience features are provided.

ALEXA is a tool similar to lex or flex for generating lexical analyzers. Unlike tools like lex, however, ALEXA defines a domain-specific language within your Lisp program, so you don't need to invoke a separate tool.

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.

This package provides a canonical way of converting generalized booleans to booleans.

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.

This library implements efficient algorithms that calculate various string metrics in Common Lisp:

• Damerau-Levenshtein distance

• Hamming distance

• Jaccard similarity coefficient

• Jaro distance

• Jaro-Winkler distance

• Levenshtein distance

• Normalized Damerau-Levenshtein distance

• Normalized Levenshtein distance

• Overlap coefficient

Infix-Math is a library that provides a special-purpose syntax for transcribing mathematical formulas into Lisp.

This Common Lisp library provides a simple FIFO implementation with no external dependencies.

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

Py4CL is a bridge between Common Lisp and Python, which enables Common Lisp to interact with Python code. It uses streams to communicate with a separate python process, the approach taken by cl4py. This is different to the CFFI approach used by burgled-batteries, but has the same goal.

CL-STORE is a portable serialization package which should give you the ability to store all Common Lisp data types into streams.

This is an interface to the git binary to make controlling it from within Common Lisp much easier. It might not ever reach full coverage of all features given git's immense size, but features will be added as they are needed. The low-level command API is fully mapped however.

Parse-Declarations is a Common Lisp library to help writing macros which establish bindings. To be semantically correct, such macros must take user declarations into account, as these may affect the bindings they establish. Yet the ANSI standard of Common Lisp does not provide any operators to work with declarations in a convenient, high-level way. This library provides such operators.

Hunchenissr works together with issr.js for the development of interactive (changing without page refreshes) websites making use of websocket and Common Lisp server HTML generation instead of mountains of convoluted Javascript.

The Common Lisp Application Directories (CLAD) library is a simple API collection that provides access to a set of standard Common Lisp folders on a per-application or per-library basis.

This Common Lisp library provides reader macros for concise expression of function partial application and composition.

This is a Common Lisp autowrapping facility for quickly creating clean and lean bindings to C libraries.

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