This is a Common Lisp library to calculate std140 or std430 layouts for a glsl UBO/SSBO.

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.

This Common Lisp library provides macros to access foreign memory.

NJSON aims to make it convenient for one to decode, encode, and process JSON data, in the minimum keystrokes/minutes possible.

NJSON is parser-independent, with existing Common Lisp JSON parsers being loadable as additional system. jzon is included by default, though. Conveniences that NJSON provides are:

• encode and decode as single entry points for JSON reading and writing, be it from streams/string/files, or from those.

• jget, jcopy, jkeys, and their aliases to manipulate the decoded objects' properties without the need to worry about the low-level details of how these values are decoded.

• jif, jwhen, jor, jand, and other macros mimicking Lisp ones, while using truth values of JSON-decoded data.

• jbind and jmatch macros to destructure and validate parsed JSON.

• njson/aliases package to nickname to j for all the forms conveniently accessible as j:get, j:copy, j:if etc.

RESTAS is a Common Lisp web application framework.

This package parses and prints dates in RFC-1123 format.

Pileup is a portable, performant, and thread-safe binary heap for Common Lisp.

GARBAGE-POOLS is Common Lisp re-implementation of the APR Pools for resource management.

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.

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

My Way is a Sinatra-compatible URL routing library.

This library extracts the TLD (Top Level Domain) from domains. The information is taken from https://publicsuffix.org.

This package contains a support library for other hu.dwim systems.

A client for the Stripe payment API.

Simple color library for 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.

FLOW is a flowchart graph library. Unlike other graphing libraries, this one focuses on nodes in a graph having distinct ports through which connections to other nodes are formed. This helps in many concrete scenarios where it is important to distinguish not only which nodes are connected, but also how they are connected to each other.

Particularly, a lot of data flow and exchange problems can be reduced to such a flowchart. For example, an audio processing library may present its pipeline as a flowchart of segments that communicate with each other through audio sample buffers. Flow gives a convenient view onto this kind of problem, and even allows the generic visualisation of graphs in this format.

A heap-based priority queue whose first and foremost priority is speed.

Markup allows the use of HTML syntax with in Common Lisp code. This has the advantage of being able to copy HTML snippets and have them instantly be functional, less double quotes than a s-expression approach, and designers will be able to understand the embedded HTML.

This library lets you build a metaclass which in turn lets you specify extra slot options in its classes. Options may be easily inspected and custom inheritance may be set up. The Meta-Object Protocol (MOP) is used for the implementation - through closer-mop. Some convenience function for processing slot options are also available.

Possible use case: you want to automatically set up some definitions based on some slots, but you want to have control over it right in the class definition.

This package provides a Language Server Protocol implementation for use with the Alive Visual Studio Code extension.

It can be used in Emacs like this:

(require 'lsp)
(defun lsp-lisp-alive-start-ls ()
 "Start the alive-lsp."
 (interactive)
 (when-let (((lsp--port-available "localhost" lsp-lisp-alive-port)))
  (lsp-async-start-process #'ignore #'ignore
   "sbcl"
   "--eval"
   "(require :asdf)"
   "--eval"
   "(asdf:load-system :alive-lsp)"
   "--eval"
   (format "(alive/server::start :port %s)"
    lsp-lisp-alive-port))))

Provides a simple way of directing output to a stream according to the concise and intuitive semantics of FORMAT's stream argument.

colorize is a Lisp library for syntax highlighting supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure, C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.

This package provides a framework to unify arbitrary Common Lisp objects while constructing bindings for placeholders (unification variables) in a template sublanguage.