STMX is a high-performance implementation of composable Transactional Memory, which is a concurrency control mechanism aimed at making concurrent programming easier to write and understand. Instead of traditional lock-based programming, one programs with atomic memory transactions, which can be composed together to make larger atomic memory transactions.

A memory transaction gets committed if it returns normally, while it gets rolled back if it signals an error (and the error is propagated to the caller).

Finally, memory transactions can safely run in parallel in different threads, are re-executed from the beginning in case of conflicts or if consistent reads cannot be guaranteed, and their effects are not visible from other threads until they commit.

Memory transactions give freedom from deadlocks, are immune to thread-safety bugs and race conditions, provide automatic roll-back on failure, and aim at resolving the tension between granularity and concurrency.

This a Common Lisp library to convert geographic coordinates between latitude/longitude and UTM (Universal Transverse Mercator) or UPS (Universal Polar Stereographic).

Small library aiming to cut down time spent moving data between CLOS and JSON objects. It depends on YASON and it should be possible to use it alongside straight calls to functions from YASON.

Optima is a fast pattern matching library which uses optimizing techniques widely used in the functional programming world.

CL-FastCGI is a generic version of SB-FastCGI, targeting to run on mostly Common Lisp implementation.

CL-octet-streams is a library implementing in-memory octet streams for Common Lisp. It was inspired by the trivial-octet-streams and cl-plumbing libraries.

Aims to be fast, modular, cachable and concise. It does so by defining each tag as a macro which expands to code printing the respective HTML source. Also employs a DSL for element attributes.

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.

This collection of utilities is useful in contexts where you want a macro that uses lambda-lists in some fashion but need more precise processing.

EXTERNAL-PROGRAM enables running programs outside the Lisp process. It is an attempt to make the RUN-PROGRAM functionality in implementations like SBCL and CCL as portable as possible without sacrificing much in the way of power.

cl-tar-file is a Common Lisp library that allows reading from and writing to various tar archive formats. Currently supported are the POSIX ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats.

This library is rather low level and is focused exclusively on reading and writing physical tar file entries using streams. Therefore, it contains no functionality for automatically building archives from a set of files on the filesystem or writing the contents of a file to the filesystem. Additionally, there are no smarts that read multiple physical entries and combine them into a single logical entry (e.g., with PAX extended headers or GNU long link/path name support). For a higher-level library that reads and writes logical entries, and also includes filesystem integration, see cl-tar.

TRIVIAL-TYPES provides missing but important type definitions such as PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.

This is a very short and simple program, written in Common Lisp, that extends Common Lisp to embed shell code in a manner similar to Perl's backtick. It has been forked from SHELISP.

MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type determination library using magic numbers.

This is a utility kit for cl-sdl2 that provides something similar to GLUT. However, it's also geared at being useful for "real" applications or games.

CL(x) xembed protocol implementation

This package implements a simple interface for using WebSockets via Common Lisp.

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.

Dufy is a library for exact color manipulation and conversion in various color spaces, which supports many color models.

This package provides a collection of types, functions and macros. Some of the functionality is implemented from Graham's On Lisp and Seibel's Practical Common Lisp.

This Common Lisp library provides string encoding and decoding routines for IDNA, the International Domain Names in Applications.

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.

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.

This library provides purely functional dictionaries and sets in Common Lisp based on the hash array-mapped trie data structure.