This is a Common Lisp bindings library to libfond, a simple OpenGL text rendering engine.

with-user-abort is a Common Lisp portability library providing a like-named macro that catches the SIGINT signal.

This library contains utilities for parsing Common Lisp code.

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

System-Load is a Common Lisp library for accessing the system's CPU and memory usage.

This package provides support routines for the claw Common Lisp package.

This library features a rectangle packer for sprite and texture atlases.

This library allows you to open native file dialogs to open and save files. This is useful if you have an application that's primarily text based and would like a more convenient file selection utility, or if you are working with a UI toolkit that does not offer a way to access the native file dialogs directly.

This is a library to abstract away the parsing of Unix-style command-line arguments. Use it in conjunction with asdf:program-op or cl-launch for portable processing of command-line arguments.

cl-quicklisp-stats is a system that fetches and performs basic operations on the Quicklisp download statistics.

Named readtables is a library that creates a namespace for named readtables, which is akin to package namespacing in Common Lisp.

cl-irc is a Common Lisp IRC client library that features (partial) DCC, CTCP and all relevant commands from the IRC RFCs (RFC2810, RFC2811 and RFC2812).

Features:

• implements all commands in the RFCs

• extra convenience commands such as op/deop, ban, ignore, etc.

• partial DCC SEND/CHAT support

• event driven model with hooks makes interfacing easy

• the user can keep multiple connections

• all CTCP commands

Anaphora is the anaphoric macro collection from Hell: it includes many new fiends in addition to old friends like aif and awhen.

40ants-plantuml provides a wrapper around the PlantUML jar library.

This is a simple extension to MODULARIZE that allows modules to define and trigger hooks, which other modules can hook on to.

This an implementation of CDR 2: generic hash tables for Common Lisp

This package provides a Common Lisp library for defining OpenGL shader programs. There are also functions for referencing shader programs by name, querying for basic information about them, modifying uniform variables throughout the lifecycle of an OpenGL application, and managing certain OpenGL buffer object types (UBO, SSBO currently).

This package implements binary trees of various kinds, presenting a uniform interface to them all.

This Common Lisp library provides an implementation of in-memory input streams, output streams and io streams for any type of elements.

ZPB-TTF is a TrueType font file parser that provides an interface for reading typographic metrics, glyph outlines, and other information from the file.

An implementation of the exponential backoff algorithm in Common Lisp. Inspired by the implementation found in Chromium. Read the header file to learn about each of the parameters.

Ironclad is a cryptography library written entirely in Common Lisp. It includes support for several popular ciphers, digests, MACs and public key cryptography algorithms. For several implementations that support Gray streams, support is included for convenient stream wrappers.

This package provides a canonical stand-in for NIL for contexts where NIL means no value.

Parenscript is a translator from an extended subset of Common Lisp to JavaScript. Parenscript code can run almost identically on both the browser (as JavaScript) and server (as Common Lisp).

Parenscript code is treated the same way as Common Lisp code, making the full power of Lisp macros available for JavaScript. This provides a web development environment that is unmatched in its ability to reduce code duplication and provide advanced meta-programming facilities to web developers.

At the same time, Parenscript is different from almost all other "language X" to JavaScript translators in that it imposes almost no overhead:

• No run-time dependencies: Any piece of Parenscript code is runnable as-is. There are no JavaScript files to include.

• Native types: Parenscript works entirely with native JavaScript data types. There are no new types introduced, and object prototypes are not touched.

• Native calling convention: Any JavaScript code can be called without the need for bindings. Likewise, Parenscript can be used to make efficient, self-contained JavaScript libraries.

• Readable code: Parenscript generates concise, formatted, idiomatic JavaScript code. Identifier names are preserved. This enables seamless debugging in tools like Firebug.

• Efficiency: Parenscript introduces minimal overhead for advanced Common Lisp features. The generated code is almost as fast as hand-written JavaScript.