Guile reference manual
official Guile tutorial
Structure and Interpretation of Computer Programs (SICP)
The Little Schemer
"Learn Scheme in 15 minutes"
Guile Hacker Handbook
The Scheme Programming Language
A Pamphlet Against R
Concrete Abstractions - An Introduction to Computer Science Using Scheme
Macros in the GNU Guile reference manual
Writing Hygienic Macros in Scheme with Syntax-Case
Community Scheme Wiki about macros
A Scheme Syntax-Rules Primer
Macro-by-Example: Deriving Syntactic Transformations from their Specifications
wikibooks.org about macros
Advanced Scheme Techniques - Some Naughty Bits
C2 Wiki Scheme Macro Examples
JRM's Syntax-rules Primer for the Merely Eccentric
Scheme Macros I: Modules
Writing Macros in Continuation-Passing Style
Low- and high-level macro programming in Scheme
Applicative syntax-rules: macros that compose better
Chicken Scheme Wiki about ck-macros
A Schemer's Introduction to Monads
A Schemer’s View of Monads - Partial Draft
Monadic Programming in Scheme
Panicz Godek's answer to How would you explain a concept of monads to a non-CS person?
Panicz Godek's answer to https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek
Cunning Bot is a command-oriented IRC bot written in Guile Scheme.
Guile-CV - Image Processing and Analysis in Guile - is a Computer Vision functional programming library for the Guile Scheme language.
Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API.
Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.
Guile-Gcrypt provides a Guile 3.x/2.x interface to a subset of the GNU
Libgcrypt crytographic library, which is itself used by the GNU Privacy Guard (GPG).
Guile-Gcrypt provides modules for cryptographic hash functions, message
authentication codes (MAC), public-key cryptography, strong randomness, and more. It is implemented using the foreign function interface (FFI) of Guile.
guile-dbiwhich is used for dealing with the Postgres side of things.
guile-dbiwhich is used for dealing with the Sqlite3 side of things.
guile-dbiwhich is used for dealing with the MySQL side of things.
[…] offers a system imitating the type system of the C programming language, to be used on bytevectors. C's type system works on raw memory, and ours works on bytevectors which are an abstraction over raw memory in Scheme. The system is in fact more powerful than the C type system, elevating types to first-class status.
An ordered dictionary data structure, based on randomized search trees (treaps) by Seidel and Aragon. Compared to red-black trees, treap is simpler and more elegant, and can get by without sentinels.
jump-to-debugger: like Python's pdb.settrace(), but for Guile
The `(jtd)` module for Guile provides a procedure (jump-to-debugger) for escaping to the Guile REPL for the purpose of debugging code. It should be considered beta code, still under development.
This implements the defense from the Freenet project against disruption of communication. It is created to experiment with ways to improve the scaling and performance.
Racket has Dr Racket. Guile has … Emacs? This is Emacs with a few settings that make working with Guile easier for people new to Emacs. Features include: CUA mode, Geiser, tool bar icons to evaluate Guile buffers, support for Guile's very own picture language, code completion, a simple mode line, etc. […]
GNU Mailutils ??? (https://mailutils.org/)
GNU Guile standard library FFI
ffi-helper from NYACC
guile-json (another one)
guile-jpeg: a library for parsing JPEG files
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.
There is no standalone library for TAR files yet (2021-11-15), but there is code dealing with TAR files, which might be separatable into its own library:
If the input is not input from users and is trustworthy, one might be able to leverage read/write of s-expressions instead of using other formats.
gzochi (zoʊ-tʃiː) is a programming framework for developing online games in GNU Guile, and a distributed middleware container that hosts your games for thousands of connected players. gzochi takes care of the hard parts of online game development - concurrency, data persistence, and network communications - so you can focus on the stuff that matters!
Dryads Wake is a game of dialogue and choices. (https://hg.sr.ht/~arnebab/dryads-wake)
This project provides programs to extract RDF triplets from commonly used file formats in genomics. It also provides a web-based environment to explore the RDF triplets once inserted in a triple store.
usage example: https://github.com/UMCUGenetics/sparqling-genomics/blob/dc5fea515c30aa26ff60b77911438689473d125b/web/ldap/authenticate.scm.in#L148
guile-jpeg: a library for parsing JPEG files
"libfive is a software library and set of tools for solid modeling, especially suited for parametric and procedural design. It is infrastructure for generative design, mass customization, and domain-specific CAD tools."
– https://libfive.com/ (2021-05-13)
libfive itself is not written in GNU Guile, but interaction with it include using GNU Guile as a modelling language.
This is a library for GNU Guile to create language bindings via GObject Introspection.
GNU Guile is an implementation of Scheme, which is a Lisp-like language. This library allows Guile to use GObject-based libraries – such as GTK+3, GLib, and WebKit2 – by generating a Scheme API from the GObject Introspection information provided by those libraries.
logging module of
AIscm is a Guile extension for numerical arrays and tensors. Performance is achieved by using the LLVM JIT compiler.
A re-implementation of a large-ish chunk of rackets for-macros. It is mostly compatible with racket's macros, with the largest omission being the body-or-break clause and some of the sequence iterators (like in-cycle, which can be covered by circular lists). There are other differences of course, like for/foldr not being on par feature-wise, and all the nicities you get by having a generic sequence interfce.
goof-loop - a scheme looping facility
goof-loops aims to be an amalgamation of the racket for loops and Alex Shinn's (chibi-loop). We are many that found racket's for loops a breeze of fresh air, but in the end their most general forms (for/fold and for/foldr) are kinda odd to work with. If you choose not to use those general for loops, you cannot express arbitrary transformations, like say a fibonacci sequence, since for clauses cannot reference eachother. goof-loop tries to fix this […]
This is a clojure-like lambda shorthand for guile. The macro is called megacut (which is a bad name, since it is not much like cut).
Documentation for Scheme Syntax Extension Packages in SLIB
Implementation of function contracts: https://notabug.org/ZelphirKaltstahl/guile-examples/src/master/macros/contract.scm
Guile's standard library networking module
Scheme-GNUnet is a WIP (Guile) Scheme port of the GNUnet client libraries. Unlike gnunet-guile, it is not a binding for the C libraries. It can be used in multi-threaded applications, e.g. with guile-fibers.
It is not to be confused with https://git.gnunet.org/gnunet-guile2.git and https://git.savannah.gnu.org/cgit/guix/gnunet.git, which implement bindings for the C libraries and support a different set of services.
– Guile user mailing list
standard library futures
[…] a construct for fine-grain parallelism. A future is a wrapper around an expression whose computation may occur in parallel with the code of the calling thread, and possibly in parallel with other futures. Like promises, futures are essentially proxies that can be queried to obtain the value of the enclosed expression […]
Concurrent ML-like concurrency for Guile
standard library parallel forms
nyacc: Not Yet Another Compiler Compiler
standard library PEG parsing
Parsing Expression Grammars (PEGs) are a way of specifying formal languages for text processing.
This is a GNU Guile library implementing the MessagePack data serialisation format. It allows you to serialise (pack) and de-serialise (unpack) Scheme objects to and from binary data according to the MessagePack format.
double ended queue
guile-xmlrpc is an XMLRPC module for Guile. Guile already has the wonderful sxml module that allows XML document creation and parsing. guile-xmlrpc goes one step further and combines sxml with some macros and procedures that simplifies even more the creation and parsing of XMLRPC documents.
manual: (readme file in git repo)
GNU Scientific Library (GSL)
Fast Fourier Transformation
guile-ffi-fftwby Mikael Djurfeldt
A port of the scmutils package for symbolic mathematics from mit scheme to guile, in an effort to make scmutils and the examples from the Structure and Interpretation of Classical Mechanics available on a wider variety of architectures/operating systems.
Guile implementation of symbolic mathematics shown in SICP
Wanna be search engine with federation support
Gash is a POSIX-compatible shell written in Guile Scheme. It provides both the shell interface, as well as a Guile library for parsing shell scripts. Gash is designed to bootstrap Bash as part of the Guix bootstrap process. We are planning to develop Gash into a general-purpose shell and tool for building interfaces between Scheme and the shell.
POSIX termios interface for GNU Guile
To query and change settings of serial devices on POSIX systems, the termios API is used. GNU Guile doesn't have an interface for that built in. This module implements this interface by use of Guile's dynamic FFI.
This Guile library provides tools for randomized, property-based testing. It follows closely the QuickCheck library written in Haskell, with inspiration from the Racket version. You can use it to define a property (a predicate with specifications for its inputs) and test it by generating many random inputs and seeing if it holds.
Guile Probá is a set of testing tools for GNU Guile projects with SRFI 64-based test suites. It comes with a command-line interface that allows you to autodiscover tests and run them, and a library that includes a test runner and helpers for writing tests.
Programming language Theme-D extends Scheme with static typing. The current Scheme platform is guile 3.0 but the software works for guile 2.2, too. Theme-D resembles Jaap Weel's Theme but Theme-D is more dynamic and the objects in Theme-D need to have type tags. See Theme-D-Golf for GNOME bindings to Theme-D.
license: parts as: LGPL-3, GFDL-1.3, GPL-3
Guile's standard library's web server:
guile's-standard-library's web module for dealing with web stuff:
GNU Artanis web application frameweork
SPH web app
A tiny module to make it less annoying to make and write HTML files using SXML. Read the code!
Authorization and authentication
SPH static website generator
A LSP (Language Server Protocol) server for Scheme.
This software aims to support several Scheme implementations. To achieve this, the code is designed to contain as much logic as possible in R7RS Scheme, separating implementation-specific code in different directories.
Note: this code is still in an early development stage and the API may change. Change suggestions are welcome.
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". […]
Spells is a collection of R6RS libraries providing features beyond R6RS in a uniform way across supported implementations.
documentation: http://rotty.xx.vu/software/spells/ (unfortunately 404 currently)
The idea is similar to the one expressed in Guile-Lib, that is, a place for people to collaborate to the development of a common library, though less intimidating maybe and, unlike Guile-Lib, Grip will tolerate, under strict conditions, some C code: this is notably to support and boost Guile-CV floating point operations, at least till Guile has an AOT compiler, able to offer similar performance results for fixed size floating points and integer operations.
codejam practices: https://github.com/jcca/codejam_practices
This library contains three scheme modules targetted at GNU Guile. The
(communication lfsr) module implements linear feedback shift registers as infinite streams of bits. LFSRs are used, for example, to generate chip sequences in CDMA systems, for synchronising preambles or as pseudo random number generators. The module implements LFSRs in both Fibonacci and Galois configurations.
E-Series Tools for GNU Guile
The E-Series are series of preferred numbers, commonly used to specify electro- nic parts; mostly resistors, inductors and capacitors. This library implements two kinds of lookups: a) Given a value, look up that value in all E-series and return the values surrounding the desired value; and b) Given an integer that identifies an E-Series and a desired value, return combinations of two parts, that approximate the desired value as closely as possible.
This is the repository for the Guile 100 Programs project. This is a collaborative effort to create a set of examples on how Guile might be used for real-world problems.
git repo: https://github.com/spk121/guile100/
Genshou: Extensible effects
Starlet is an experimental Lisp-based domain-specific language (DSL) for theatrical lighting control. It's based on Guile and sends its DMX output via OLA to almost any type of lighting control interface - DMX, sACN, Art-Net etc.
This plugin extends Vim's Scheme support to include the additions to the language provided by the GNU Guile implementation. The plugin automatically detects whether a Scheme file is a Guile file and adds syntax highlighting for Guile's special forms.
REPL.nvim bring REPL support to Nvim! Use the built-in REPLs, add your own, or change the existing ones. Change settings in your init.vim or on the fly, make them global or local, use the existing ones or make your own.
Emacs Guile support
TODO: other editors support
GUIX package search
^guile-to find many Guile libraries and projects.
Akku.scm is a language package manager for Scheme. It grabs hold of code and vigorously shakes it until it behaves properly.
GNU Foliot is a small and easy to use time keeping application.
It can be used in a single user mode or by small organizations. Starting with version 0.9.4, it can import other user's database, an essential feature for remote collaborators.
The fields it handles are: a date, who, for whom, what, a duration, whether or not to be charged and a description.
It includes, on the main application screen, a powerful dynamic filters criteria mechanism, which lets you visualize, work on and print a subset of your time keeping entries.
A printing templates system allows you to (pre)define, reuse and hence quickly generate the pdf files and/or printed reports of your needs.
A version which will let users export an active filter based subset of their time keeping entries is under work.
Potato Make is a scheme library that aims to simplify the task of maintaining, updating, and regenerating programs. It is inspired by the make utility in POSIX. With this library, you can write a build script in Guile Scheme.
SPH lib, collection of Guile libraries
C2 Wiki Category Scheme
C2 Wiki Guile Scheme
C2 Wiki Scheme Language
Community Scheme Wiki
A SICP Study Guide With Exercise Solutions in Guile & Emacs Lisp
description: A loose collection Guile modules:
Guile-BAUX is a collection of scripts and modules intended to be installed in your project’s aux dir (i.e., build-aux/, or equivalent dir specified by ACCONFIGAUXDIR in configure.ac). There are modules for:
- extracting documentation / generating texinfo
- doing (Scheme) source-source scanning / transforming
- constructing / displaying modules’ dependency graph
- generating C boilerplate
This is gclipselect, a small program that allows you to re-select from the text lines that were selected at one time or another as the X Primary Selection. This is useful when, in X Windows, if you have selected something using the left mouse button (as in the convention of the X Windows System) and you later select something else but want to get back to the earlier selection.
Thus this program allows you to quickly switch between frequently copied texts for pasting. When you select some text you will notice gclipselect window adds the newly selected text to the list. And you can choose any earlier selection in the list window to make it the X11 primary selection again; you can then paste it using the middle mouse button.
This category is still fairly empty. Help filling it with interesting GNU Guile related videos, talks or presentations!