The Concise Binary Object Representation (CBOR), as specified by RFC 8949, is a binary data serialization format. CBOR is similar to JSON but serializes to binary which is smaller and faster to generate and parse. This package provides a Guile implementation of CBOR.

Procedures in this SRFI are drawn primarily from SRFI 69 and R6RS. In addition, the following sources are acknowledged:

• hash-table-mutable? procedure and the second argument of hash-table-copy (which allows the creation of immutable hash tables) are from R6RS, renamed in the style of this SRFI.

• hash-table-intern! procedure is from Racket, renamed in the style of this SRFI.

• hash-table-find procedure is a modified version of table-search in Gambit.

• procedures hash-table-unfold and hash-table-count were suggested by SRFI 1.

• procedures hash-table=? and hash-table-map were suggested by Haskell's Data.Map.Strict module.

• procedure hash-table-map->list is from Guile.

The procedures hash-table-empty?, hash-table-empty-copy, hash-table-pop!, hash-table-map!, hash-table-intersection!, hash-table-difference!, and hash-table-xor! were added for convenience and completeness.

Guile-colorized provides you with a colorized REPL for GNU Guile.

Fibers is a Guile library that implements a a lightweight concurrency facility, inspired by systems like Concurrent ML, Go, and Erlang. A fiber is like a "goroutine" from the Go language: a lightweight thread-like abstraction. Systems built with Fibers can scale up to millions of concurrent fibers, tens of thousands of concurrent socket connections, and many parallel cores. The Fibers library also provides Concurrent ML-like channels for communication between fibers.

Note that Fibers makes use of some Guile 2.1/2.2-specific features and is not available for Guile 2.0.

Guile-Reader is a simple framework for building readers for GNU Guile.

The idea is to make it easy to build procedures that extend Guile’s read procedure. Readers supporting various syntax variants can easily be written, possibly by re-using existing “token readers” of a standard Scheme readers. For example, it is used to implement Skribilo’s R5RS-derived document syntax.

Guile-Reader’s approach is similar to Common Lisp’s “read table”, but hopefully more powerful and flexible (for instance, one may instantiate as many readers as needed).

Fibers is a Guile library that implements a a lightweight concurrency facility, inspired by systems like Concurrent ML, Go, and Erlang. A fiber is like a "goroutine" from the Go language: a lightweight thread-like abstraction. Systems built with Fibers can scale up to millions of concurrent fibers, tens of thousands of concurrent socket connections, and many parallel cores. The Fibers library also provides Concurrent ML-like channels for communication between fibers.

Note that Fibers makes use of some Guile 2.1/2.2-specific features and is not available for Guile 2.0.

Guile Gemini is an implementation of the Gemini protocol in Guile Scheme, providing both client and server functionality. It uses GnuTLS to meet Gemini's TLS requirements, and Guile Fibers for concurrency.

Guile-SMC is a state machine compiler that allows users to describe finite state machines (FSMs) in Scheme in terms of transition tables. It is capable to generate such transition tables from a PlantUML state diagrams.

A transition table can be verified and checked for dead-ends and infinite loops. Also Guile-SMC FSMs gather statistics when they run.

Guile-SMC comes with a Scheme program called smc -- a state machine compiler itself. It produces a Scheme code for an FSM from the PlantUML format. This tool is meant to be called on a PlantUML file when a program with a FSM is being built (for example, from a Makefile.)

Guile-Lib is intended as an accumulation place for pure-scheme Guile modules, allowing for people to cooperate integrating their generic Guile modules into a coherent library. Think "a down-scaled, limited-scope CPAN for Guile". It provides the following modules:

• (apicheck) Describe and verify library programming interfaces.

• (config load) Loading configuration files.

• (container async-queue) A thread-safe message queue.

• (container nodal-tree) A tree consisting of nodes with attributes.

• (container delay-tree) A nodal tree with lazily evaluated fields.

• (debugging assert) Helpful assert macro.

• (debugging time) A simple macro to time the execution of an expression.

• (graph topological-sort) Routines to perform topological sorts.

• (htmlprag) Neil Van Dyke's permissive ("pragmatic") HTML parser.

• (io string) SLIB's IO routines dealing with strings.

• (logging logger) A flexible logging system.

• (logging port-log) A logger that outputs to a port.

• (logging rotating-log) A logger that rotates its output files.

• (match-bind) Nifty and concise regular expression routines.

• (math minima) A golden-section minimum finder.

• (math primes) Functions related to prime numbers and factorization.

• (os process) Spawning processes and capturing their output.

• (scheme documentation) Macros to define different kinds of variables with documentation.

• (scheme kwargs) Defining functions with flexible keyword arguments.

• (search basic) Classic search functions.

• (string completion) Building blocks for tab completion.

• (string soundex) The SOUNDEX string categorization algorithm.

• (string transform) Beyond SRFI-13.

• (string wrap) A versatile string formatter.

• (term ansi-color) Generate ANSI color escape sequences.

• (unit-test) A JUnit-style unit testing framework.

guile-filesystem provides a set of utility functions, that augment Guile's support for handling files and their names.

Hoot is a WebAssembly compiler backend for Guile Scheme and a standalone WebAssembly toolchain.

This package provides a Guile library for Internet Relay Chat (IRC).

This package provides a simple Guile interface to .env (or dotenv) files. It implements parsing of files and setting environment variables from them.

Additionally, this package provides a dotenv command, exposes part of the guile-dotenv Guile API as command lines invocations.

Guile-XOSD provides Guile bindings for libxosd, the X On Screen Display library.

This package provides bindings for Avahi. It allows programmers to use functionalities of the Avahi client library from Guile Scheme programs. Avahi itself is an implementation of multicast DNS (mDNS) and DNS Service Discovery (DNS-SD).

This package provides a library (lsp-server) and an executable guile-lsp-server that can be used by LSP clients in order to provide IDE functionality for Guile Scheme.

This package provides a Guile programming interface to the ZeroMQ messaging library.

Guile Config is a library providing a declarative approach to application configuration specification. The library provides clean configuration declaration forms, and processors that take care of: configuration file creation; configuration file parsing; command-line parameter parsing using getopt-long; basic GNU command-line parameter generation (--help, --usage, --version); automatic output generation for the above command-line parameters.

Emacsy is an embeddable Emacs-like library that uses GNU Guile as extension language. Emacsy can give a C program an Emacsy feel with keymaps, minibuffer, recordable macros, history, tab completion, major and minor modes, etc., and can also be used as a pure Guile library. It comes with a simple counter example using FreeGLUT and browser examples in C using Gtk+-3 and WebKitGtk.

This SRFI contains various procedures that accept and return procedures, as well as a few others, drawn from an earlier version of Chicken. Common Lisp has a few of them too, and more come from the Standard Prelude from Programming Praxis. Using these procedures helps to keep code terse and reduce the need for ad hoc lambdas.

guile-sjson is a json reader/writer for Guile. It has a nice, simple s-expression based syntax.

guile-pnm is a GNU Guile library for working with the NetPBM format (also known as PNM), including portable bitmap (PBM), portable graymap (PGM) and portable pixel (PPM) variants.

G-Wrap is a tool and Guile library for generating function wrappers for inter-language calls. It currently only supports generating Guile wrappers for C functions. Given a definition of the types and prototypes for a given C interface, G-Wrap will automatically generate the C code that provides access to that interface and its types from the Scheme level.

This package provides a simple SVG-based picture language for Guile. The picture values can directly be displayed in Geiser.