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

This is a system presenting a protocol for "file systems": things that present a collection of "files," which are things that have several attributes, and a central data payload. Most notably this includes the OS filesystem, but can also be used to address other filesystem-like things like archives, object stores, etc. in the same manner.

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

fast-websocket is an optimized low-level WebSocket protocol parser/composer.

This library implements the -> and ->> macros from Clojure, as well as several expansions on the idea.

This library contains an implementation of interfaces and implementations. They're sometimes called protocols in other languages. Broadly speaking, an interface is some collection of function prototypes that a valid implementation must implement.

This library can be used to print the licenses used by a Common Lisp project and its dependencies.

This package is a geospatial library, based on cl-wkb, that implements the OGC Well-Known Binary geographic geometry data model with PostGIS 3d, 4d extensions, and provides WKB and EWKB encoding and decoding functionality.

This package is a simple date and time library.

Very basic library for dealing with CL's hash tables. The idea was spawned through working with enough JSON APIs and config files, causing a lot of headaches in the process.

This library is a collection of functions and macros for manipulating Common Lisp arrays and performing numerical calculations with them.

Coleslaw is a static site generator written in Common Lisp.

Inquisitor is a cross-implementation library providing encoding/end-of-line detection and external-format abstraction 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.

SLY is a fork of SLIME, an IDE backend for Common Lisp. It also features a completely redesigned REPL based on Emacs's own full-featured comint-mode, live code annotations, and a consistent interactive button interface. Everything can be copied to the REPL. One can create multiple inspectors with independent history.

CL-SXML implements Oleg Kiselyov’s SXML, an S-expression-based rendering of the XML Infoset.

cl-jpl-util is a collection of Common Lisp utility functions and macros, primarily for software projects written in CL by the author.

This library implements a basic promise datastructure, which is useful for dealing with asynchronous behaviours. Importantly, this library does not use any other libraries or frameworks, and instead leaves the execution and state transition of promise objects in your control, making it easy to integrate.

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

This is a utility library providing access to the mmap family of functions in a portable way. It allows you to directly map a file into the address space of your process without having to manually read it into memory sequentially. Typically this is much more efficient for files that are larger than a few Kb.

Coleslaw is a static site generator written in Common Lisp.

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

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.

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.