This is a trivial utility for distinguishing between a process running in a real terminal window and a process running in a dumb one, e.g. emacs-slime.

This package provides a UTF-8 string input stream over a binary stream for Common Lisp.

This package provides a robust CSV parser and printer that tries to follow the fine print of de facto standards. It can be configured to choose which standard exactly.

Triads is a simple command line tool that reads roman numeral notation from standard input (or a file) and an musical key and outputs the roman numeral in addition to the notes of the triad associated with that roman numeral given in the key.

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.

doplus is an iteration macro for Common Lisp.

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.

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

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

Serapeum is a conservative library of Common Lisp utilities. It is a supplement, not a competitor, to Alexandria.

lparallel is a library for parallel programming in Common Lisp, featuring:

• a simple model of task submission with receiving queue,

• constructs for expressing fine-grained parallelism,

• asynchronous condition handling across thread boundaries,

• parallel versions of map, reduce, sort, remove, and many others,

• promises, futures, and delayed evaluation constructs,

• computation trees for parallelizing interconnected tasks,

• bounded and unbounded FIFO queues,

• high and low priority tasks,

• task killing by category,

• integrated timeouts.

This is an extension to MODULARIZE that allows your application to define interfaces in-code that serve both as a primary documentation and as compliance control.

This library is a path strings manipulation library inspired by Python's os.path. All functionality from os.path is supported on major operation systems.

The philosophy behind is to use simple strings and "dumb" string manipulation functions to handle paths and filenames. Where possible the corresponding OS system functions are called.

Plump is a parser for HTML/XML-like documents, focusing on being lenient towards invalid markup. It can handle things like invalid attributes, bad closing tag order, unencoded entities, inexistent tag types, self-closing tags and so on. It parses documents to a class representation and offers a small set of DOM functions to manipulate it. It can be extended to parse to your own classes.

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 is a standalone promise implementation for Common Lisp. It is the successor to the now-deprecated cl-async-future project.

CL-TYPESETTING is a cross-platform Common Lisp typesetting library for all kind of typesetting applications.

cl-alexandria-plus is a conservative set of extensions to cl-alexandria utilities.

Duologue is high-level interaction library for Common Lisp. It features coloured printing via cl-ansi-text and readline completion.

Collections of accessor functions and patterns to access the elements in compound type specifier, e.g. dimensions in (array element-type dimensions)

This is a bare-bones Permuted Congruential Generator implementation in pure Common Lisp.

Dissect is a small Common Lisp library for introspecting the call stack and active restarts.

Very basic library for dealing with CL's hash tables. The idea was spawned through working with enough JSON APIs and config files, causing a lot of headaches in the process.

MAP-BIND is a macro that allows visual grouping of variables with their corresponding values in calls to mapping operators when using an inline LAMBDA.