Common Lisp implementation of UUIDs according to RFC4122.

Cl-async is a library for general purpose, non-blocking programming in Common Lisp. It uses the libuv library as backend.

This Common Lisp library interprets escape characters the same way that most other programming language do. It provides four readtables. The default one lets you write strings like this: #"This string has a newline in it!".

A modern and consistent Common Lisp string manipulation library that focuses on modernity, simplicity and discoverability: (str:trim s) instead of (string-trim '(#\Space ...) s)), or str:concat strings instead of an unusual format construct; one discoverable library instead of many; consistency and composability, where s is always the last argument, which makes it easier to feed pipes and arrows.

clingon is a command-line option parsing library for Common Lisp. Its features include:

• Support for subcommands

• Support for command aliases

• Support for short and long options

• Related options may be grouped into categories

• Short options may be collapsed into a single argument, as in -xyz

• Long options support the notations --long-opt arg and --long-opt=arg

• Automatic generation of help/usage information for commands and subcommands

• Out-of-the-box support for --version and --help

• Support for various kinds of options including string, integer, boolean, switch, enum, list, counter, filepath, etc.

• Subcommands can look up global options defined in parent commands

• Support for required options

• Options can be initialized via environment variables

• Single interface for creating options using CLINGON:MAKE-OPTION

• Generate documentation for your command-line application

• Support for pre-hook and post-hook actions for commands, which allow invoking functions before and after the respective handler of the command is executed

• Support for Bash and Zsh completions

• Extensibility, so if you don't find something you need you can extend it by developing a new option kind, or even a new mechanism for initializing options, e.g., by looking up an external key/value store

Common Lisp comes with quite some functions to compare objects for equality, yet none is applicable in every situation and in general this is hard, as equality of objects depends on the semantics of operations on them. As consequence, users find themselves regularly in a situation where they have to roll their own specialized equality test.

This module provides one of many possible equivalence relations between standard Common Lisp objects. However, it can be extended for new objects through a simple CLOS protocol. The rules when two objects are considered equivalent distinguish between mutating and frozen objects. A frozen object is promised not to be mutated in the future in a way that operations on it can notice the difference.

We have chosen to compare mutating objects only for identity (pointer equality), to avoid various problems. Equivalence for frozen objects on the other hand is established by recursing on the objects' constituent parts and checking their equivalence. Hence, two objects are equivalent under the OBJECT= relation, if they are either identical, or if they are frozen and structurally equivalent, i.e. their constituents are point-wise equivalent.

Since many objects are potentially mutable, but are not necessarily mutated from a certain point in their life time on, it is possible to promise to the equivalence relation that they remain frozen for the rest of their life time, thus enabling coarser equivalence than the often too fine-grained pointer equality.

KMRCL is a collection of utilities used by a number of Kevin Rosenberg's Common Lisp packages.

RUTILS is a syntactic utilities package for Common Lisp.

core-gp is a Common Lisp library for genetic programming (GP) algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as well as standard genetic algorithms.

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

A miniature toolkit that contains some useful shifting/popping/pushing functions for arrays and vectors. Originally from Plump.

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.

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.

QMyND, the QITAB MySQL Native Driver, is a MySQL client library that directly talks to a MySQL server in its native network protocol.

It's a part of QITAB umbrella project.

High performance JSON encoder and decoder. Currently support: SBCL, CCL.

This is a Common Lisp version of UglifyJS, a JavaScript compressor. It works on data produced by parse-js to generate a minified version of the code. Currently it can:

• reduce variable names (usually to single letters)

• join consecutive var statements

• resolve simple binary expressions

• group most consecutive statements using the sequence operator (comma)

• remove unnecessary blocks

• convert IF expressions in various ways that result in smaller code

• remove some unreachable code

40ants-asdf-system provides a class for being used instead of asdf:package-inferred-system in 40ANT systems.

Fast-io is about improving performance to octet-vectors and octet streams (though primarily the former, while wrapping the latter).

CHRONICITY is Common Lisp natural language date and time parser inspired by Ruby's Chronic.

Linedit is a readline-style library written in Common Lisp that provides customizable line-editing for Common Lisp programs.

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

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.

This package provides a Common Lisp library to work with the JSON file format.

A collection of Common Lisp utility functions and macros mostly not found in other utility packages.