This package provides an enhanced version of typep that is exactly like the one in the Lisp spec, except it can also accept a single type argument, in which case it returns the appropriate closure.

This package provides an enhanced version of typep that is exactly like the one in the Lisp spec, except it can also accept a single type argument, in which case it returns the appropriate closure.

NJSON aims to make it convenient for one to decode, encode, and process JSON data, in the minimum keystrokes/minutes possible.

NJSON is parser-independent, with existing Common Lisp JSON parsers being loadable as additional system. jzon is included by default, though. Conveniences that NJSON provides are:

• encode and decode as single entry points for JSON reading and writing, be it from streams/string/files, or from those.

• jget, jcopy, jkeys, and their aliases to manipulate the decoded objects' properties without the need to worry about the low-level details of how these values are decoded.

• jif, jwhen, jor, jand, and other macros mimicking Lisp ones, while using truth values of JSON-decoded data.

• jbind and jmatch macros to destructure and validate parsed JSON.

• njson/aliases package to nickname to j for all the forms conveniently accessible as j:get, j:copy, j:if etc.

Simple scheme to classify file types in a hierarchical fashion.

This package contains a few utility functions from the LispWorks library that are used in software such as ContextL.

This is a Common Lisp autowrapping facility for quickly creating clean and lean bindings to C libraries.

A dataflow extension to Common Lisp that maintains a consistent state of cells according to functions specifying their relation.

NFiles is a Common Lisp library to help manage file persistence and loading, in particular user-centric files like configuration files. It boasts the following features:

• Dynamic and customizable path expansion.

• Extensible serialization and deserialization.

• Cached reads and writes. When a file object expands to the same path as another one, a read or write on it won’t do anything in case there was no change since last write.

• (Experimental!) On-the-fly PGP encryption.

• Profile support.

• On read error, existing files are backed up.

• On write error, no file is written to disk, the existing file is preserved.

Radiance is a web application environment, which is sort of like a web framework, but more general, more flexible. It should let you write personal websites and generally deployable applications easily and in such a way that they can be used on practically any setup without having to undergo special adaptations.

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

This is a simple queue library for Common Lisp with features such as non-consing thread safe queues and fibonacci priority queues.

This is a system implementing an advanced dialogue system that is capable of complex dialogue flow including choice trees and conditional branching. Speechless was first developed for the "Kandria" (https://kandria.com) game, and has since been separated and made public in the hopes that it may find use elsewhere or inspire other developers to build similar systems.

Speechless is based on the "Markless" (https://shirakumo.github.io/markless) document standard for its syntax and makes use of Markless' ability to be extended to add additional constructs useful for dialogue systems.

Speechless can compile dialogue from its base textual form into an efficient instruction set, which is then executed when the game is run. Execution of the dialogue is completely engine-agnostic, and only requires some simple integration with a client protocol to run.

Thanks to Markless' extensibility, Speechless can also be further extended to include additional syntax and constructs that may be useful for your particular game.

Unifies a parametrized type specifier against an actual type specifier. Importantly, it handles complicated array-subtypes and number-related types correctly.

HTML parser/emitter for CommonDoc.

This package provides first-class global environments for Common Lisp.

Calispel is a Common Lisp library for thread-safe message-passing channels, in the style of the occam programming language, also known as communicating sequential processes (CSP). See https://en.wikipedia.org/wiki/Communicating_sequential_processes.

Calispel channels let one thread communicate with another, facilitating unidirectional communication of any Lisp object. Channels may be unbuffered, where a sender waits for a receiver (or vice versa) before either operation can continue, or channels may be buffered with flexible policy options.

Because sending and receiving on a channel may block, either operation can time out after a specified amount of time.

A syntax for alternation is provided (like ALT in occam, or Unix select()): given a sequence of operations, any or all of which may block, alternation selects the first operation that doesn't block and executes associated code. Alternation can also time out, executing an "otherwise" clause if no operation becomes available within a set amount of time.

Calispel is a message-passing library, and as such leaves the role of threading abstractions and utilities left to be filled by complementary libraries such as Bordeaux-Threads and Eager Future.

This package provides a small utility library to open a thing (usually a file or URL) in an appropriate handler (usually an external file manager or browser).

Retrospectiff is a common lisp library for reading and writing images in the TIFF (Tagged Image File Format) format.

This package provides a recursive-descent parser DSL for Common Lisp. It's intended as a simpler alternative to parser generators.

This package provides a BNF parser in Common Lisp.

This is a library to allow easy handling of external processes, and primarily to get their output. It handles proper copying of the standard and error outputs of the process simultaneously, both in a sequential and parallel fashion. It also features a lazy directory switching mechanism, to avoid running into parallelism problems when having to change directory.

This package defines a simple extensible protocol for computing a guess using advisors.

HTML-TEMPLATE is a Common Lisp library which can be used to fill templates with arbitrary (string) values at runtime. The result does not have to be HTML.

It is loosely modeled after the Perl module HTML::Template and partially compatible with a its syntax, though both libraries contain some extensions that the other does not support.

HTML-TEMPLATE translates templates into efficient closures which can be re-used as often as needed. It uses a cache mechanism so you can update templates while your program is running and have the changes take effect immediately.

This is a small OS portability library to retrieve and set file attributes not supported by the Common Lisp standard functions.