repl-utilities is a set of utilities which ease life at the REPL. It includes three sorts of features: introspective procedures, miscellaneous utility functions, and, pulling them together, methods to conveniently keep these symbols and optionally additional symbols available in whichever package you switch to.

This library tries to provide a way to detect what kind of type the given predicate is trying to check. This is different from inferring the return type of a function.

This is a system for two dimensional computational geometry for Common Lisp.

Note: the system assumes exact rational arithmetic, so no floating point coordinates are allowed. This is not checked when creating geometric objects.

Feeder is a syndication feed library. It presents a general protocol for representation of feed items, as well as a framework to translate these objects from and to external formats. It also implements the RSS 2.0 and Atom formats within this framework.

core-gp is a Common Lisp library for genetic programming (GP) algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as well as standard genetic algorithms.

This library extends LOG4CL system in a few ways:

* It helps with configuration of multiple appenders and layouts. * Has a facility to catch context fields and to log them. * Has a macro to log unhandled errors. * Adds a layout to write messages as JSON, which is useful for production as makes easier to parse and process such logs. * Uses the appenders which are not disabled in case of some error which again, should be useful for production.

A miniature toolkit that contains some useful shifting/popping/pushing functions for arrays and vectors. Originally from Plump.

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.

CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.

CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).

This a Common Lisp library for reading and writing binary data. It is based on code from chapter 24 of the book Practical Common Lisp.

This library provides low-level libuv bindings for Common Lisp.

Generic documentation builder for Common Lisp projects.

OpenAPI client system generator.

This package provides prototype Common Lisp implementations of TLS, RFC5246, ASN.1, x501,509, and PKCS1,3,5,8.

This Common Lisp library converts strings, symbols and keywords between any of the following typographical cases: PascalCase, camelCase, snake_case, kebab-case (lisp-case).

nontrivial-gray-streams is a compatibility system for Gray streams, which is an extension to Common Lisp that makes it possible to implement Common Lisp streams using generic functions.

With static-vectors, you can create vectors allocated in static memory.

GECO (Genetic Evolution through Combination of Objects) is an extensible, object-oriented framework for prototyping genetic algorithms in Common Lisp.

A hook, in the present context, is a certain kind of extension point in a program that allows interleaving the execution of arbitrary code with the execution of a the program without introducing any coupling between the two. Hooks are used extensively in the extensible editor Emacs.

In the Common LISP Object System (CLOS), a similar kind of extensibility is possible using the flexible multi-method dispatch mechanism. It may even seem that the concept of hooks does not provide any benefits over the possibilities of CLOS. However, there are some differences:

• There can be only one method for each combination of specializers and qualifiers. As a result this kind of extension point cannot be used by multiple extensions independently.

• Removing code previously attached via a :before, :after or :around method can be cumbersome.

• There could be other or even multiple extension points besides :before and :after in a single method.

• Attaching codes to individual objects using eql specializers can be cumbersome.

• Introspection of code attached a particular extension point is cumbersome since this requires enumerating and inspecting the methods of a generic function.

This library tries to complement some of these weaknesses of method-based extension-points via the concept of hooks.

LLA is a high-level Common Lisp library built on BLAS and LAPACK, but providing a much more abstract interface with the purpose of freeing the user from low-level concerns and reducing the number of bugs in numerical code.

This package allows flexible specification of package-local preferences.

RUTILS is a syntactic utilities package for Common Lisp.

This is only useful if you want to start a Swank server in a Lisp processes that doesn't run under Emacs. Lisp processes created by M-x slime automatically start the server.

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