postmodern is a Common Lisp library for interacting with PostgreSQL databases. It provides the following features:

• Efficient communication with the database server without need for foreign libraries.

• Support for UTF-8 on Unicode-aware Lisp implementations.

• A syntax for mixing SQL and Lisp code.

• Convenient support for prepared statements and stored procedures.

• A metaclass for simple database-access objects.

This package produces 4 systems: postmodern, cl-postgres, s-sql, simple-date

SIMPLE-DATE is a very basic implementation of date and time objects, used to support storing and retrieving time-related SQL types. It is not loaded by default and you can use local-time (which has support for timezones) instead.

S-SQL is used to compile s-expressions to strings of SQL code, escaping any Lisp values inside, and doing as much as possible of the work at compile time.

CL-POSTGRES is the low-level library used for interfacing with a PostgreSQL server over a socket.

POSTMODERN itself is a wrapper around these packages and provides higher level functions, a very simple data access object that can be mapped directly to database tables and some convenient utilities. It then tries to put all these things together into a convenient programming interface

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

This package contains a Gemini client library for Common Lisp. A subsystem offers an experimental GUI Gemini client.

This package provides audio input and output functions to Common Lisp using bindings to the portaudio library.

This package provides a set of bindings and utilities for accessing the OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.

UCONS is a Common Lisp library providing unique conses. Unique conses are different from regular conses in that, in addition to their car and cdr, they maintain a table of past users. Also, the cdr of each ucons is restricted to other uconses or nil. Uconses are meant for those situations where even reusing regular conses (to avoid consing) is too computationally expensive.

This library enables path variables in networking routes when using Hunchenissr for Common Lisp. If a part of the path (between two slashes) starts with a question mark (?), that symbol (without question mark) will be bound to whatever value was in the same place in the URL (as a string).

Wu-Decimal enables convenient, arbitrary-precision decimal arithmetic through a reader macro, #$, and an update to the pprint dispatch table. Wu-Decimal uses the CL rational type to store decimals, which enables numeric functions such as +, -, etc., to operate on decimal numbers in a natural way.

The LOCAL-TIME library is a Common Lisp library for the manipulation of dates and times. It is based almost entirely upon Erik Naggum's paper "The Long Painful History of Time".

Helps writing concise CFFI-related code.

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

HTML parser/emitter for CommonDoc.

This package provides a priority queue implemented with an array-based heap.

This package provides the terminal-size:size function to get the size of the terminal from Common Lisp.

cl-inotify uses cl-cffi to provide a Common Lisp interface to the Linux inotify API.

This system implements binding threading macros -- a kind of threading macros with different semantics than classical, Clojure core threading macros or their extension, swiss-arrows. Two Common Lisp implementations of those are arrows and arrow-macros.

This system is a fork of arrows with changes in semantics that make it impossible to merge back upstream.

Trivia is a pattern matching compiler that is compatible with Optima, another pattern matching library for Common Lisp. It is meant to be faster and more extensible than Optima.

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

Tripod is a Common Lisp web server aiming to ease plain text, HTML, and Gopher website hosting.

This package holds an enhanced implementation of hooks (extension points). It works similarly to Emacs hooks with crucial improvements:

• If the compiler allows it (such as SBCL), type-checking is performed at compile-time and at run-time when adding handlers to a hook.

• On failure, multiple restarts are offered, such as disabling the offending handler or simply continuing to the next function.

• The hook handler execution order and combination can be customized.

• Anonymous functions (lambdas) can be added to hooks as handler objects. When inspecting hooks, readable names are thus exposed instead of lambda blackboxes. Handlers are compared through their names (through the mandatory name slot). A hook can not contain multiple handlers with the same name.

• A special provision is taken for “setters”, handlers that are meant to set a given place to a given values. Such handler objects can be compared and identified uniquely.

This library allows macro writers to provide better feedback to macro users when errors are signaled during macroexpansion. It uses the compiler's concept of a source-form to report where the error or warning is located.

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.

This package provides a Common Lisp library for dice rolling and working with dice-roll statistics.

CL(x) xembed protocol implementation