EASY-ROUTES is yet another routes handling system on top of Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES).

It supports:

• dispatch based on HTTP method

• arguments extraction from the url path

• decorators

• URL generation from route names

This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS systems.

This is a c2ffi-based wrapper generator for Common Lisp.

Vernacular is a build and module system for languages that compile to Common Lisp. It allows languages to compile to Lisp while remaining part of the Common Lisp ecosystem. Vernacular languages interoperate with Common Lisp and one another.

Vernacular handles locating files, compiling files into FASLs, tracking dependencies and rebuilding, and export and import between your new language, Lisp, and any other language Vernacular supports.

Vernacular builds on Overlord and is inspired by Racket.

This is a portability library that allows one to fully override the standard debugger provided by their Common Lisp system for situations where binding *debugger-hook* is not enough -- most notably, for break.

cl-all is a library and script for evaluating Common Lisp expressions in multiple implementations.

CL-random-forest is an implementation of Random Forest for multiclass classification and univariate regression written in Common Lisp. It also includes an implementation of Global Refinement of Random Forest.

Infix-Math is a library that provides a special-purpose syntax for transcribing mathematical formulas into Lisp.

This a Common Lisp library to convert geographic coordinates between latitude/longitude and MGRS.

Clop is a Common Lisp library for parsing strings in the TOML configuration file format.

This package provides an enhanced EVAL-WHEN macro that supports a shorthand for (eval-when (:compile-toplevel :load-toplevel :execute) ...), addressing concerns about verbosity.

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 is a Common Lisp wrapper for interacting with the Redis data structure store.

Simple and fast marshalling of Lisp datastructures. Convert any object into a string representation, put it on a stream an revive it from there. Only minimal changes required to make your CLOS objects serializable.

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 package provides a canonical stand-in for NIL for contexts where NIL means no value.

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.

Common Lisp comes with quite some functions to compare objects for equality, yet none is applicable in every situation and in general this is hard, as equality of objects depends on the semantics of operations on them. As consequence, users find themselves regularly in a situation where they have to roll their own specialized equality test.

This module provides one of many possible equivalence relations between standard Common Lisp objects. However, it can be extended for new objects through a simple CLOS protocol. The rules when two objects are considered equivalent distinguish between mutating and frozen objects. A frozen object is promised not to be mutated in the future in a way that operations on it can notice the difference.

We have chosen to compare mutating objects only for identity (pointer equality), to avoid various problems. Equivalence for frozen objects on the other hand is established by recursing on the objects' constituent parts and checking their equivalence. Hence, two objects are equivalent under the OBJECT= relation, if they are either identical, or if they are frozen and structurally equivalent, i.e. their constituents are point-wise equivalent.

Since many objects are potentially mutable, but are not necessarily mutated from a certain point in their life time on, it is possible to promise to the equivalence relation that they remain frozen for the rest of their life time, thus enabling coarser equivalence than the often too fine-grained pointer equality.

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.

A Common Lisp client library for Apache Kafka.

This package provides an implementation of the flexichain protocol, allowing client code to dynamically add elements to, and delete elements from a sequence (or chain) of such elements.

This library is a portable compatibility layer around package local nicknames (PLN). This was done so there is a portability library for the PLN API not included in DEFPACKAGE.

Implementation of a set-like data structure with constant time addition, removal, and random selection.

Cl-async is a library for general purpose, non-blocking programming in Common Lisp. It uses the libuv library as backend.

SB-CGA is a computer graphics algebra library for Common Lisp.

Despite the prefix it is actually portable - but optimizations that make it fast (using SIMD instructions) are currently implemented for SBCL/x86-64 only.