This package provides a Common Lisp library to work with the JSON file format.

High performance JSON encoder and decoder. Currently support: SBCL, CCL.

This package provides a utility library intended at providing configurable reader macros for common tasks such as accessors, hash-tables, sets, uiop:run-program, arrays and a few others.

This library is a little experiment in reducing verbosity in Common Lisp, inspired by BODOL (https://github.com/bodil/BODOL).

cl-strings is a small, portable, dependency-free set of utilities that make it even easier to manipulate text in Common Lisp. It has 100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.

This is a task scheduling framework for Common Lisp.

This is a Common Lisp library for processing data found in dBase III database files (dbf and db3 files).

This package provides Common Lisp support for reading the Terragen .TER format. The format specification can be found at https://planetside.co.uk/wiki/index.php?title=Terragen_.TER_Format

This library implements the -> and ->> macros from Clojure, as well as several expansions on the idea.

Dexador is yet another HTTP client for Common Lisp with neat APIs and connection-pooling. It is meant to supersede Drakma.

MODULARIZE is an attempt at providing a common interface to segregate major application components. This is achieved by adding special treatment to packages. Each module is a package that is specially registered, which allows it to interact and co-exist with other modules in better ways. For instance, by adding module definition options you can introduce mechanisms to tie modules together in functionality, hook into each other and so on.

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.

This library provides a modern project skeleton generator. In contract with other generators, CL-Project generates one package per file and encourages unit testing by generating a system for unit testing, so you can begin writing unit tests as soon as the project is generated.

This library provides an asynchronous process execution mechanism for Common Lisp.

This is a keymap facility for Common Lisp inspired by Emacsy (keymap.scm) which is inspired by Emacs.

• Support prefix keys to other keymaps. For instance, if you prefix my-mode-map with C-c, then all bindings for my-mode will be accessible after pressing C-c.

• List all bindings matching a given prefix. (Also known as which-key in Emacs.)

• List the bindings associated to a command.

• Support multiple inheritance.

• Support keycode.

• Validate keyspec at compile time.

• define-key can set multiple bindings in a single call.

• Support multiple scheme to make it easy to switch between, say, Emacs-style and VI-style bindings. This orthogonality to keymaps composes better than having multiple keymaps: changing scheme applies to the entire program, which is easier than looping through all keymaps to change them.

• Translate keyspecs as a fallback. For instance if shift-a is not bound, check A.

• Behaviour can be customized with global parameters such as *print-shortcut*.

• The compose function can merge multiple keymaps together.

• Support multiple arguments when that makes sense (e.g. multiple keymaps for lookup-key).

• Key remapping à-la Emacs.

• Typed keymaps, i.e. keymaps where bound values can only be of a given type. This is convenient to catch typos, for instance when binding 'FOO instead of #'FOO.

clsql is a Common Lisp interface to SQL RDBMS based on the Xanalys CommonSQL interface for Lispworks. It provides low-level database interfaces as well as a functional and an object oriented interface.

This is a Common Lisp library providing a set of macros for generating lexical analyzers automatically. The lexers generated using cl-lex can be used with cl-yacc.

The LOCAL-TIME library is a Common Lisp library for the manipulation of dates and times. It is based almost entirely upon Erik Naggum's paper "The Long Painful History of Time".

This library generates sdf (https://steamcdn-a.akamaihd.net/apps/valve/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf), psdf and msdf (https://github.com/Chlumsky/msdfgen/files/3050967/thesis.pdf) atlases.

Just wrap your Common Lisp function in this macro call and it will be optimized for tail recursion. You will be warned if the function is not tail recursive.

Trivial-Benchmark runs a block of code many times and outputs some statistical data for it. On SBCL this includes the data from time, for all other implementations just the real-time and run-time data. However, you can extend the system by adding your own metrics to it, or even by adding additional statistical computeations.

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

fare-utils is a small collection of utilities. It contains a lot of basic everyday functions and macros.

cl-cron is a simple tool that provides cron like facilities directly inside of Common Lisp.