GENERIC-COMPARABILITY is an implementation of CDR-8 (Generic Equality and Comparison for Common Lisp). CDR-8 provides an interface for the EQUALS function, which is defined as a general equality predicate, as well as a set of ordering (COMPARE) functions for comparison. The semantics are described in the CDR-8 standard.

This package provides GNU gettext completely implemented in Common Lisp without any C library bindings.

This library provides an OS and implementation independent access to timeouts.

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 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 tools for manipulating data in files using data frames.

This Common Lisp package offers an implementation of the 32-bit variant of MurmurHash3 (https://github.com/aappleby/smhasher), a fast non-crytographic hashing algorithm.

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

definitions-systems provides a simple unified extensible way of processing named definitions.

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

This package provides an ASN.1 encoder/decoder for Common Lisp.

Quickproject provides a quick way to make a Common Lisp project. After creating a project, it extends the ASDF registry so the project may be immediately loaded.

ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode text for inclusion into a larger document.

STMX is a high-performance implementation of composable Transactional Memory, which is a concurrency control mechanism aimed at making concurrent programming easier to write and understand. Instead of traditional lock-based programming, one programs with atomic memory transactions, which can be composed together to make larger atomic memory transactions.

A memory transaction gets committed if it returns normally, while it gets rolled back if it signals an error (and the error is propagated to the caller).

Finally, memory transactions can safely run in parallel in different threads, are re-executed from the beginning in case of conflicts or if consistent reads cannot be guaranteed, and their effects are not visible from other threads until they commit.

Memory transactions give freedom from deadlocks, are immune to thread-safety bugs and race conditions, provide automatic roll-back on failure, and aim at resolving the tension between granularity and concurrency.

Trivial Monitored Thread offers a very simple (aka trivial) way of spawning threads and being informed when one any of them crash and die.

This system is an implementation of the Common Lisp type system; particularly cl:typep and cl:subtypep.

This package provides a CONSPACK implementation for Common Lisp.

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 is a Common Lisp library providing a unified way to work with package locks across supported Common Lisp implementations.

This Common Lisp library provides macros to access foreign memory.

cl-num-utils implements simple numerical functions for Common Lisp, including:

• num=, a comparison operator for floats

• simple arithmeric functions, like sum and l2norm

• elementwise operations for arrays

• intervals

• special matrices and shorthand for their input

• sample statistics

• Chebyshev polynomials

• univariate rootfinding

This package provides Doug Hoyte's "Production" version of macros from the Let Over Lambda book, including community updates.

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.

NFiles is a Common Lisp library to help manage file persistence and loading, in particular user-centric files like configuration files. It boasts the following features:

• Dynamic and customizable path expansion.

• Extensible serialization and deserialization.

• Cached reads and writes. When a file object expands to the same path as another one, a read or write on it won’t do anything in case there was no change since last write.

• (Experimental!) On-the-fly PGP encryption.

• Profile support.

• On read error, existing files are backed up.

• On write error, no file is written to disk, the existing file is preserved.