cl-charms is an interface to libcurses in Common Lisp. It provides both a raw, low-level interface to libcurses via CFFI, and a more higher-level lispier interface.

Utility for creating, accessing, and managing custom namespaces in Common Lisp. Originally started as a fork of LISP-NAMESPACE, it became its own piece of software that is somewhat backwards compatible with it.

Authentic provides a light-weight and extendible solution to user/password management for Common Lisp applications. It has features such as safe password storage in a database, password reset, user confirmation tokens, and user authentication.

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.

cl-openal is a series of semi-lispy public domain bindings to the OpenAL API. It includes direct CFFI bindings, as well as varying levels of lispy wrappings around AL, ALC, and ALUT.

cl-webkit is a binding to WebKitGTK+ for Common Lisp, currently targeting WebKit version 2. The WebKitGTK+ library adds web browsing capabilities to an application, leveraging the full power of the WebKit browsing engine.

Parachute is a simple-to-use and extensible testing framework. In Parachute, things are organised as a bunch of named tests within a package. Each test can contain a bunch of test forms that make up its body.

This package provides highly optimized base64 encoding and decoding. Besides conversion to and from strings, integer conversions are supported. Encoding with Uniform Resource Identifiers is supported by using a modified encoding table that uses only URI-compatible characters.

A modern markup generation library for Common Lisp that features:

• Fast (even faster through compiling the code)

• Safety

• Support for multiple document types (markup, xml, html, html5, xhtml)

• Output with doctype

• Direct output to stream

ISSR core provides functions and variables for ISSR server modules so that different servers can behave similarly. The most important features are Document Object Model differencing to generate instructions to update a DOM, and DOM cleaning, to ensure that all remote DOMs are the same.

This library implements the base58 encoding algorithm. It's basically base64 but with a smaller alphabet (58, as in the name) that doesn't include similar looking characters, among other things. See https://github.com/bitcoin/bitcoin/blob/master/src/base58.h for a full reference.

s-sysdeps is an abstraction layer over platform dependent functionality. This simple package is used as a building block in a number of other projects.

s-sysdeps abstracts:

• managing processes,

• implementing a standard TCP/IP server,

• opening a client TCP/IP socket stream,

• working with process locks.

This package lets GLOP act as a host for CEPL What?

CEPL (like GL) relies on other libraries for managing the creation of a GL context, interaction with the Window manager and handling of input sources. The libraries that provide this functionality for CEPL are called hosts.

This is a host for CEPL which uses the GLOP library for creating the context etc.

This is a very simple color library for Common Lisp, providing

• Types for representing colors in HSV and RGB spaces.

• Simple conversion functions between the above types (and also hexadecimal representation for RGB).

• Some predefined colors (currently X11 color names – of course the library does not depend on X11).Because color in your terminal is nice.

This library is no longer supported by its author.

This is a minimalistic parser of command line options. The main advantage of the library is the ability to concisely define command line options once and then use this definition for parsing and extraction of command line arguments, as well as printing description of command line options (you get --help for free). This way you don't need to repeat yourself. Also, unix-opts doesn't depend on anything and precisely controls the behavior of the parser via Common Lisp restarts.

lparallel is a library for parallel programming in Common Lisp, featuring:

• a simple model of task submission with receiving queue,

• constructs for expressing fine-grained parallelism,

• asynchronous condition handling across thread boundaries,

• parallel versions of map, reduce, sort, remove, and many others,

• promises, futures, and delayed evaluation constructs,

• computation trees for parallelizing interconnected tasks,

• bounded and unbounded FIFO queues,

• high and low priority tasks,

• task killing by category,

• integrated timeouts.

This package provides a Language Server Protocol implementation for use with the Alive Visual Studio Code extension.

It can be used in Emacs like this:

(require 'lsp)
(defun lsp-lisp-alive-start-ls ()
 "Start the alive-lsp."
 (interactive)
 (when-let (((lsp--port-available "localhost" lsp-lisp-alive-port)))
  (lsp-async-start-process #'ignore #'ignore
   "sbcl"
   "--eval"
   "(require :asdf)"
   "--eval"
   "(asdf:load-system :alive-lsp)"
   "--eval"
   (format "(alive/server::start :port %s)"
    lsp-lisp-alive-port))))

This library provides two strata to access the POSIX shm API:

• the package posix-shm/ffi, a collection of slim bindings to the POSIX API

• the package posix-shm, a lispy wrapper around the FFI that integrates more closely to the features of Common Lisp, and provides a handful of utilities and macros

Features include:

• open, close, create, resize, change ownership of, change permissions of, and memory map to shared memory objects

• open-shm appears more like open from the standard library

• open-shm*, for creating anonymous shm objects

• with-open-shm, with-mmap and similar with- macros for safely accessing resources with dynamic extent

In the crowded space of Common Lisp HTML generators, Spinneret occupies the following coordinates:

• Modern. Targets HTML5. Does not treat XML and HTML as the same problem. Assumes you will be serving your documents as UTF-8.

• Composable. Makes it easy to refactor HTML generation into separate functions and macros.

• Pretty. Treats HTML as a document format, not a serialization. Output is idiomatic and readable, following the coding style of the HTML5 specification.

• Aggressive. If something can be interpreted as HTML, then it will be, meaning that some Lisp forms can't be mixed with HTML syntax. In the trade-off between 90% convenience and 10% correctness Spinneret is on the side of convenience.

• Bilingual. Spinneret (after loading spinneret/ps) has the same semantics in Lisp and Parenscript.

Utilities for Lisp

Prometheus.io Common Lisp client.

CL(x) xembed protocol implementation

Framework for representing and manipulating documents.