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

This library defines most Common Lisp standard macros that can be defined in a portable way and that can generate portable code. Some of these macros may not be good enough as the final version for a typical implementation, but they will work.

This library is part of NUMCL. It provides a macro SPECIALIZED that performs a Julia-like dispatch on the arguments, lazily compiling a type-specific version of the function from the same code. The main target of this macro is speed.

This is a terminfo database front end in Common Lisp. The package provides a method for determining which capabilities a terminal (e.g. "xterm") has and methods to compile or put commands to a stream.

This package provides a generic cache management facility with configurable and extensible cache replacement policies. The actual cached data can be stored anywhere, with cacle taking charge of keeping track of which entry is to be discarded next when more space is needed for a new entry.

The GTWIWTG library (Generators The Way I Want Them Generated -- technically not generators, but iterators) is meant to be small, explorable, and understandable.

This is an implementation of the "Markless standard" (https://github.com/shirakumo/markless) at version 1.0. It handles the parsing of plaintext from a stream into an abstract syntax tree composed out of strings and component objects. From there the AST can be easily compiled into a target markup language like HTML.

Hunchenissr works together with issr.js for the development of interactive (changing without page refreshes) websites making use of websocket and Common Lisp server HTML generation instead of mountains of convoluted Javascript.

The Distributions package provides a collection of probabilistic distributions and related functions

This package provides a way of extracting and replicating the compile-time side-effects of forms.

Periods is a Common Lisp library providing a set of utilities for manipulating times, distances between times, and both contiguous and discontiguous ranges of time.

This is a a Common Lisp re-implementation of the Rails routes system for mapping URLs.

In Common Lisp, a special variable that is never dynamically bound typically serves as a stand-in for a global variable. The global-vars library provides true global variables that are implemented by some compilers. An attempt to rebind a global variable properly results in a compiler error. That is, a global variable cannot be dynamically bound.

Global variables therefore allow us to communicate an intended usage that differs from special variables. Global variables are also more efficient than special variables, especially in the presence of threads.

CMN provides a package of functions to hierarchically describe a musical score. When evaluated, the musical score is rendered to an image.

hdf5-cffi is a CFFI wrapper for the HDF5 library.

FLARE is a library designed to allow quick and precise particle effect creations. It does not concern itself with displaying and only with the management and movement of particles. As such, it can easily be integrated into any existing or future application.

This package provides a pure-lisp implementation of a DNS client. It can be used to resolve hostnames, reverse-lookup IP addresses, and fetch other kinds of DNS records.

This package provides Common Lisp bindings to GSSAPI, which is designed to provide a standard API to authentication services. The API itself is generic, and the system can provide different underlying implementations. The most common one is Kerberos, which has several implementations, the most common of which is probably Active Directory.

This is a dead-simple, non validating, inline CSS generator for Common Lisp. Its goals are axiomatic syntax, simple implementation to support portability, and boilerplate reduction in CSS.

This data structure can be used to store the history of visited paths or URLs with a file or web browser, in a way that no “forward” element is ever forgotten.

The history tree is “global” in the sense that multiple owners (e.g. tabs) can have overlapping histories. On top of that, an owner can spawn another one, starting from one of its nodes (typically when you open a URL in a new tab).

Ningle is a lightweight web application framework for Common Lisp.

This is a Common Lisp library consisting of a collection of useful GPU shader functions, written with Shadow.

bt-semaphore is a semaphore implementation for use with bordeaux-threads.

This package is a Python Numpy clone implemented in pure Common Lisp.