awesome-guile/list.md

Table of Contents

1. Manuals
2. Tutorials / Guides / Books
   1. General GNU Guile / Scheme
   2. Macros
      1. CK macros
   3. Monads
   4. FFI - Foreign Function Interface
   5. GUI development
3. Libraries
   1. Async
   2. Audio
   3. Browser
   4. Bots
   5. Chat
      1. Chat clients
      2. Chat bots
      3. Protocols
   6. Compression
   7. Computer vision
   8. Configuration
   9. Cryptography
   10. Databases
       1. Generic
       2. Postgres
       3. Sqlite
       4. MySQL
       5. Redis
       6. CouchDB
       7. Other
   11. Data structures
       1. Purely functional data structures (PFDs)
       2. RDF
       3. Lenses
       4. Trees
       5. Other
   12. Debugging
   13. Decentralization
   14. Development environments
   15. Device management
   16. Distributed computing
   17. E-Mail
   18. Encodings
   19. Event loop
   20. FFI - Foreign Function Interface
   21. File formats
       1. JSON
       2. YAML
       3. CSV
       4. XML
       5. Markdown
       6. Texinfo
       7. JPEG
       8. PNG
       9. ICS
       10. torrent
       11. Shapefile
       12. CBOR
       13. TAR
       14. INI
       15. Other
   22. File system
   23. Game development
   24. Games
   25. Generators
   26. Genomics
   27. Graphics
       1. Image processing
       2. Design and CAD
   28. GUI development
   29. Language
   30. Logging
   31. Machine Learning
   32. Macros
   33. Message Queues
   34. Network programming
   35. Parallelism
   36. Parsing
       1. Parser Combinators
       2. Parser Generator
       3. Other
       4. XML parser
   37. Plotting
   38. Protocols
   39. Serialization
   40. SRFI (Scheme Request For Implementation) implementations
   41. Strings
   42. Syntax
   43. Regular expressions
   44. REPL (Read Eval Print Loop)
   45. RPC (Remote Procedure Call)
   46. Scientific computing and mathematics
       1. Interaction with the Jupyter ecosystem
   47. Search engine
   48. Shell
   49. TUI development
   50. Testing
       1. Integration testing
       2. Unit testing
       3. Other
   51. Types
       1. Static typing
   52. Version control systems
   53. Web Development
       1. Web servers
       2. Web clients
       3. Web frameworks
       4. Protocols
       5. Tooling / Additional libraries
       6. Static website generators
       7. Template engine
       8. Interaction with services
       9. Web application examples
       10. Web drivers / Selenium
   54. Window manager
   55. Working with code
   56. Other
   57. Unsorted
4. Projects
5. Programming paradigm
   1. "Object-oriented programming"
      1. Prototype based
   2. Relational programming
   3. Functional programming
6. Programming language concepts
   1. Pipeline / pipe / chain / threading
   2. State Machines
7. Programs
   1. Finances
   2. Window manager
   3. Other
8. Tools
   1. Notes
   2. Editor support
   3. Project management
      1. Package managers
      2. Time tracking
   4. Build tools
9. Blogs
10. Other
11. Other lists of Guile software
12. Videos / Talks / Presentations

Manuals

• There is a huge reference manual for GNU Guile on the GNU website: https://www.gnu.org/software/guile/manual/.

Tutorials / Guides / Books

General GNU Guile / Scheme

• Guile reference manual

  • website: https://www.gnu.org/software/guile/manual/

• official Guile tutorial

  • website: https://www.gnu.org/software/guile/docs/guile-tut/tutorial.html

• Structure and Interpretation of Computer Programs (SICP)

  • website: https://mitpress.mit.edu/sites/default/files/sicp/index.html
  • PDF version: https://github.com/sarabander/sicp-pdf

• The Little Schemer

  • website: https://mitpress.mit.edu/books/little-schemer-fourth-edition

• "Learn Scheme in 15 minutes"

  • website: https://web-artanis.com/scheme.html

• guile-tutorial

  • git repo: https://notabug.org/cwebber/guile-tutorial

• Guile Hacker Handbook

  • website: https://jeko.frama.io/en/index.html
  • git repo: https://framagit.org/Jeko/jeko.frama.io

• The Scheme Programming Language

  • web version: https://scheme.com/tspl4/

• A Pamphlet Against R

  • PDF version: https://github.com/panicz/pamphlet/raw/master/pamphlet.pdf
  • source codes: https://github.com/panicz/pamphlet

• Concrete Abstractions - An Introduction to Computer Science Using Scheme

  • web: https://gustavus.edu/mcs/max/concrete-abstractions-pdfs/index.html

Macros

• Macros in the GNU Guile reference manual

  • website: https://www.gnu.org/software/guile/manual/html_node/Macros.html

• Writing Hygienic Macros in Scheme with Syntax-Case

  • article: https://doc.lagout.org/programmation/Lisp/Scheme/Programming%20With%20Hygienic%20Macros%20-%20R%20K%20Dybvig.pdf

• Community Scheme Wiki about macros

  • scheme-faq-macros
    • website: http://community.schemewiki.org/?scheme-faq-macros
  • syntax-case
    • website: http://community.schemewiki.org/?syntax-case

• A Scheme Syntax-Rules Primer

  • website: http://www.willdonnelly.net/blog/scheme-syntax-rules/

• Macro-by-Example: Deriving Syntactic Transformations from their Specifications

  • paper: https://legacy.cs.indiana.edu/ftp/techreports/TR206.pdf

• wikibooks.org about macros

  • website: https://en.wikibooks.org/wiki/Scheme_Programming/Macros

• Advanced Scheme Techniques - Some Naughty Bits

  • slides: http://people.csail.mit.edu/jhbrown/scheme/macroslides04.pdf

• C2 Wiki Scheme Macro Examples

  • website: http://wiki.c2.com/?SchemeMacroExamples

• JRM's Syntax-rules Primer for the Merely Eccentric

  • website: https://hipster.home.xs4all.nl/lib/scheme/gauche/define-syntax-primer.txt
    • another location: http://www.phyast.pitt.edu/~micheles/syntax-rules.pdf

• Scheme Macros I: Modules

  • website: https://blog.veitheller.de/Scheme_Macros_I:_Modules.html

• Writing Macros in Continuation-Passing Style

  • paper: https://www.semanticscholar.org/paper/Writing-Macros-in-Continuation-Passing-Style-Hilsdale-Friedman/752575dc24b2bb6e74ee6146df71860e10e3aee9#citing-papers (TODO: find a more permanent looking link)

• Low- and high-level macro programming in Scheme

  • website: http://okmij.org/ftp/Scheme/macros.html

CK macros

• Applicative syntax-rules: macros that compose better

  • website: http://okmij.org/ftp/Scheme/macros.html#ck-macros

• Chicken Scheme Wiki about ck-macros

  • website: http://wiki.call-cc.org/eggref/5/ck-macros

Monads

• A Schemer's Introduction to Monads

  • website: http://www.ccs.neu.edu/home/dherman/research/tutorials/monads-for-schemers.txt

• A Schemer’s View of Monads - Partial Draft

  • website: https://cgi.sice.indiana.edu/~c311/lib/exe/fetch.php?media=manymonads.pdf

• Monadic Programming in Scheme

  • website: http://okmij.org/ftp/Scheme/monad-in-Scheme.html

• Panicz Godek's answer to How would you explain a concept of monads to a non-CS person?

  • website https://www.quora.com/How-would-you-explain-a-concept-of-monads-to-a-non-CS-person/answer/Panicz-Godek

• Panicz Godek's answer to https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek

  • website https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek

FFI - Foreign Function Interface

• GNU Guile standard library FFI
  • GNU software reference manual: https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html

GUI development

• gtk-tutorial-using-guile-gnome
  • git repo: https://github.com/yang-qu/gtk-tutorial-using-guile-gnome
  • description: "This project converts C code in gtk tutorial http://www.zetcode.com/tutorials/gtktutorial to scheme code using guile-gnome."/ (https://github.com/yang-qu/gtk-tutorial-using-guile-gnome/blob/ec4e9ce9c670b923fc3cc973c1e85fc7934ff4d8/README)

Libraries

Async

• 8sync
  • git repository at Savannah: https://savannah.gnu.org/projects/8sync
  • manual / GNU software manual: https://www.gnu.org/software/8sync/manual/html_node/index.html#Top
  • website / GNU software page: https://www.gnu.org/software/8sync/
  • tutorial: https://www.gnu.org/software/8sync/manual/html_node/Tutorial.html#Tutorial

Audio

• gapd

  • git repo: https://github.com/rashack/gapd
  • description: "Guile Audio Player Daemon" (https://github.com/rashack/gapd)

• xmms2-guile

  • git repository: https://gitlab.com/ft/xmms2-guile
  • description: "Native XMMS2 client library for GNU Guile." – https://gitlab.com/ft/xmms2-guile @ b26d67cd2cb8100c17244c7bcf50b496e90c98ae

Browser

• Nomad
  • git repository at non-GNU Savannah: https://savannah.nongnu.org/projects/nomad/
  • website: https://www.nongnu.org/nomad/

Bots

• chatter
  • git repo: https://github.com/apg/chatter
  • description: "Chatter Bot framework, inspired by Elizabot, for Guile" (https://github.com/apg/chatter/blob/e407b09e9aedb214e75ffaecbcc86ed105f154aa/README)

Chat

Chat clients

1. IRC

   • guile-irc
     • git repository at GitHub: https://github.com/rekado/guile-irc
     • description: "An irc library for GNU guile." (https://github.com/rekado/guile-irc/blob/master/README)
     • API reference manual: http://fbs.github.io/guile-irc/

Chat bots

1. IRC

   • Cunning Bot

     • git repo: https://github.com/cadrspace/cunning-bot

     • description:

       Cunning Bot is a command-oriented IRC bot written in Guile Scheme.

       (https://github.com/cadrspace/cunning-bot/blob/cadrobot/README)

   • eliug

     • git repo: https://github.com/szdiy/eliug
     • description: "the smart irc bot written with GNU Guile-scheme" (https://github.com/szdiy/eliug/blob/030bf891a4007e9c40f8fdacd306c77e71146334/README.md)

Protocols

1. Matrix

   • guile-deck
     • repository: https://github.com/artyom-poptsov/guile-deck
     • description: "GNU Guile SDK for the Matrix network (https://matrix.org)" – README file

Compression

• guile-zlib

  • git repository at GitHub: https://github.com/davexunit/guile-zlib

• guile-zstd

  • git repository at notabug.org: https://notabug.org/guile-zstd/guile-zstd
  • description: "GNU Guile bindings to the zstd compression library." (https://notabug.org/guile-zstd/guile-zstd)

Computer vision

• GNU Guile-CV

  • website: https://www.gnu.org/software/guile-cv/
  • GNU software reference manual: https://www.gnu.org/software/guile-cv/manual/html_node/index.html

  • description:

    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.

    (https://www.gnu.org/software/guile-cv/index.html)

Configuration

• guile-config
  • git repository at GitLab: https://gitlab.com/a-sassmannshausen/guile-config

Cryptography

• guile-gcrypt

  • git repo: https://notabug.org/cwebber/guile-gcrypt

  • description:

    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.

• gcrypt-guile

  • git repo: https://github.com/fbs/gcrypt-guile (archived, read only)
  • description: "Wrappers to get some libgcrypt functionality into guile." (https://github.com/fbs/gcrypt-guile/blob/0add93e2486044ca48f3de130a070fba21bf0b2d/README)

Databases

Generic

• Generic
  • guile-dbi
    • git repository at GitHub: https://github.com/opencog/guile-dbi
    • documentation: https://htmlpreview.github.io/?https://github.com/opencog/guile-dbi/blob/master/website/guile-dbi.html
    • offers MySQL, Postgresql and SQLite3 interfaces

Postgres

• guile-squee

  • git repository at notabug.org: https://notabug.org/cwebber/guile-squee
  • documentation at: ???

• guile-dbd-postgresql

  • git repository: https://github.com/opencog/guile-dbi/tree/master/guile-dbd-postgresql
  • documentation: https://github.com/opencog/guile-dbi/blob/master/guile-dbd-postgresql/README
  • description: This is a sub-repository of guile-dbi which is used for dealing with the Postgres side of things.

• Guile-PG

  • git repository: https://git.savannah.nongnu.org/cgit/guile-pg.git
  • documentation: ???
  • project page: https://www.nongnu.org/guile-pg/
  • description: "Guile-PG is a collection of modules for Guile allowing access to the PostgreSQL RDBMS from Scheme programs." (https://www.nongnu.org/guile-pg/)

Sqlite

• guile-sqlite3

  • git repository at notabug.org: https://notabug.org/guile-sqlite3/guile-sqlite3.git
  • documentation at: ???

• guile-dbd-sqlite3

  • git repository at GitHub: https://github.com/opencog/guile-dbi/tree/master/guile-dbd-sqlite3
  • documentation: https://github.com/opencog/guile-dbi/blob/master/guile-dbd-sqlite3/README
  • description: This is a sub-repository of guile-dbi which is used for dealing with the Sqlite3 side of things.

MySQL

• guile-dbd-mysql
  • git repository at GitHub: https://github.com/opencog/guile-dbi/tree/master/guile-dbd-mysql
  • documentation: https://github.com/opencog/guile-dbi/blob/master/guile-dbd-mysql/README
  • description: This is a sub-repository of guile-dbi which is used for dealing with the MySQL side of things.

Redis

• guile-redis
  • git repository at GitHub: https://github.com/aconchillo/guile-redis

CouchDB

• CouchDB
  • guile-couchdb
  • git repo: https://github.com/ukulanne/guile-couchdb
  • description: CouchDB bindings for Guile

Other

• WiredTiger (http://www.wiredtiger.com/

  • guile-wiredtiger
    • blog post: https://hyper.dev/blog/getting-started-with-guile-wiredtiger.html
    • git repository at: ??? (framagit requires login?)

• guile-sparql: https://github.com/roelj/guile-sparql

• sparqling-genomics: https://github.com/UMCUGenetics/sparqling-genomics

• nomunofu

  • mentioned on: https://hyper.dev/blog/nomunofu.html
  • git repo: ???

• gsparql

  • git repo: https://github.com/cordawyn/gsparql
  • description: "SPARQL client written in Guile" (https://github.com/cordawyn/gsparql/blob/4076e435cc852a5c91922be5ffc7e201bb35d935/README.md)

Data structures

Purely functional data structures (PFDs)

• pfds

  • git repository at GitHub: https://github.com/ijp/pfds
  • description: "pfds is a set of purely functional data structures written in R6RS Scheme. It has been tested with Racket, Guile 2, Vicare Scheme and IronScheme." (https://github.com/ijp/pfds/blob/454033f82dac7c0b0ea9e84eed1e8ed316487c78/README.org)
  • documentation: https://github.com/ijp/pfds/blob/master/README.org

• fectors

  • git repository at GitHub: https://github.com/ijp/fectors
    • perhaps fork or original or another library: https://hg.sr.ht/~bjoli/guile-fector

• guile-fash

  • mercurial repo: https://hg.sr.ht/~bjoli/guile-fash
  • description: "guile-fash implements functional hashes using Hash array mapped tries (HAMTs)." (https://hg.sr.ht/~bjoli/guile-fash/browse/readme.md?rev=tip)
  • guix package: none

RDF

• guile-rdf
  • git repository at framagit: https://framagit.org/tyreunom/guile-rdf

Lenses

• guile-lens
  • git repository at GitLab: https://gitlab.com/a-sassmannshausen/guile-lens

Trees

• Guile AA Tree
  • project page: https://savannah.nongnu.org/projects/guile-aa-tree
  • git repo: https://git.savannah.nongnu.org/cgit/guile-aa-tree.git
  • description: "An AA tree implementation for scheme. AA trees are self-balancing binary trees, which ensure O(log n) worst case performance for core operations. The module provides non-mutating insert, delete, and search operations, with support for convenient nested tree operations." (https://savannah.nongnu.org/projects/guile-aa-tree)

Other

• copernic

  • git repository at GitHub: https://github.com/amirouche/copernic

• scheme-bytestructures

  • git repo: https://github.com/TaylanUB/scheme-bytestructures

  • description:

    […] 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.

• guile-newra

  • git repo: https://github.com/lloda/guile-newra
  • description: "A Scheme replacement for Guile's array system" (https://github.com/lloda/guile-newra)

• Treaps

  • website: http://okmij.org/ftp/Scheme/#treaps

  • description:

    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.

    (http://okmij.org/ftp/Scheme/#treaps)

• array-list

  • repository: https://git.dthompson.us/chickadee.git/tree/chickadee/array-list.scm
  • description: an implementation of a dynamic array (https://en.wikipedia.org/wiki/Dynamic_array)

Debugging

• guile-jtd

  • repository: https://github.com/mwette/guile-jtd

  • description:

    jump-to-debugger: like Python's pdb.set_trace(), 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.

    – https://raw.githubusercontent.com/mwette/guile-jtd/cb40b0e0f2fa2a1825a5f1f273b6970be2fe1401/README.md

  • documentation: https://github.com/mwette/guile-jtd/blob/main/README.md

Decentralization

• wispwot

  • repository: https://hg.sr.ht/~arnebab/wispwot/browse

  • description:

    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.

    – https://hg.sr.ht/~arnebab/wispwot

Development environments

• guile-studio

  • git repo: https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=tree

  • description:

    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. […]

    (https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=blob;f=README.org;hb=HEAD)

Device management

• guile-udev:
  • description: "Guile-Udev is a GNU Guile bindings to libudev." (https://github.com/artyom-poptsov/guile-udev/blob/master/README)
  • git repo: https://github.com/artyom-poptsov/guile-udev
  • documentation: (inside the git repo: https://github.com/artyom-poptsov/guile-udev/blob/master/doc/guile-udev.texi)
  • examples: (inside the git repo: https://github.com/artyom-poptsov/guile-udev/tree/master/examples)

Distributed computing

• metabash
  • git repository: https://github.com/artyom-poptsov/metabash
  • description: "GNU Guile module for running distributed shell pipelines." – https://github.com/artyom-poptsov/metabash/blob/master/README.org

E-Mail

• GNU Mailutils ??? (https://mailutils.org/)

• guile-email: https://guile-email.systemreboot.net/

Encodings

• ERIS - Encoding for Robust Immutable Storage
  • website: http://purl.org/eris
  • git repository: https://gitlab.com/openengiadina/eris/-/tree/main
  • description: "ERIS is an encoding for arbitrary content into uniformly sized encrypted blocks that can be reassembled only in possession of a short read capability." – https://gitlab.com/openengiadina/eris/-/blob/88c54329c1f7357941ae3a4bac49847c022c9803/README.org

Event loop

• guile-a-sync
  • git repository at GitHub: https://github.com/ChrisVine/guile-a-sync
  • documentation: ?

FFI - Foreign Function Interface

• GNU Guile standard library FFI

  • GNU software reference manual: https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html

• ffi-helper from NYACC

  • documentation: https://www.nongnu.org/nyacc/ffi-help.html

File formats

JSON

• guile-json

  • on GitHub: https://github.com/aconchillo/guile-json
  • on savannah: http://savannah.nongnu.org/projects/guile-json/

• guile-json (another one)

  • git repo: https://github.com/cthom06/guile-json
  • description: "A basic JSON parser for Guile" (https://github.com/cthom06/guile-json/blob/1b2f77c4242fa52d6f8624806ec0c47e0d2ca08a/README)

YAML

• guile-libyaml
  • git repo: https://github.com/mwette/guile-libyaml
  • description: "simple yaml module using ffi-helper from www.nongnu.org/nyacc" (https://github.com/mwette/guile-libyaml/blob/f5d33a6880e96571d3cb079ed7755ffc156cac46/README.md)

CSV

• guile-csv

  • git repository at GitLab: https://gitlab.com/NalaGinrut/guile-csv

• guile-dsv

  • This is more general, but can work with CSV as well.
  • git repository at GitHub: https://github.com/artyom-poptsov/guile-dsv

XML

• Guile's standard library SXML implementation
  • GNU software manual: https://www.gnu.org/software/guile/manual/html_node/SXML.html
  • Basically your templates become functions or macros.
  • The structure of your document is kept as Scheme data structures.
    • This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
    • It enables pattern matching without resorting to things like regular expressions and similar shenanigans.

Markdown

• guile-commonmark
  • git repository at GitHub: https://github.com/OrangeShark/guile-commonmark
  • documentation: ???

Texinfo

• Guile standard library texinfo functionality
  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/texinfo.html

JPEG

• guile-jpeg: a library for parsing JPEG files
  • git repo: https://github.com/guildhall/guile-jpeg (archived)

PNG

• guile-PNG
  • git repo: https://github.com/artyom-poptsov/guile-png
  • description: "Portable Network Graphics (PNG, RFC 2083) library for GNU Guile." – https://github.com/artyom-poptsov/guile-png/blob/06bb2c734c3007346f970be6f6a00407ac5d76f0/README.org

ICS

• guile-ics
  • git repository at GitHub: https://github.com/artyom-poptsov/guile-ics

torrent

• torrent
  • git repository at GitHub: https://github.com/o-nly/torrent
  • documentation at: ???

Shapefile

• guile-shapefile
  • git repository: https://github.com/HugoNikanor/guile-shapefile
  • description: "Guile Shapefile is a Guile library for reading shapefiles." (https://github.com/HugoNikanor/guile-shapefile/blob/37fd219d3dc3d944e8f29b1bad6baf9e59372275/README.md)
  • documentation: https://hugonikanor.github.io/guile-shapefile/

CBOR

• guile-cbor

  • git repo: https://inqlab.net/git/guile-cbor.git/

  • description:

    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.

TAR

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:

• Implementation of Ustar in Gash:
  • https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/commands/tar.scm
  • https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/ustar.scm
• GNU Tar stuff:
  • https://git.savannah.gnu.org/cgit/tar.git/tree/src/tar.h
  • https://savannah.gnu.org/git/?group=tar
  • https://www.gnu.org/software/tar/

INI

• Guile-INI
  • git repository: https://github.com/artyom-poptsov/guile-ini
  • description: "A GNU Guile library for working with INI format." (https://github.com/artyom-poptsov/guile-ini/blob/6764a8a23d8d5911c08ee2bc996cb776e6b0ae5e/README.org)
  • documentation: https://github.com/artyom-poptsov/guile-ini/tree/master/doc

Other

• guile-mime

  • git repo: https://mikegerwitz.com/projects/guile-mime/tree/
  • description: A library, that helps figuring out the MIME type of a file.

• 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.

File system

• sdupes

  • description: duplicate file detection
  • git repository at GitHub: https://github.com/sph-mn/sdupes

• duplicates

  • git repo: https://github.com/rashack/duplicates
  • description: "Find duplicate files - in Guile Scheme" (https://github.com/rashack/duplicates)

• guile-filesystem

  • git repo: https://gitlab.com/lilyp/guile-filesystem
  • description: "[…] provides a set of utilities to deal with the filesystem beyond what POSIX mandates, from manipulating file names to actually creating files and directories." – https://gitlab.com/lilyp/guile-filesystem/-/blob/f1f7f45c23a8662abdecc4b054b4da64f3cc868f/README.org

• guile-fslib

  • git repo: https://notabug.org/ZelphirKaltstahl/guile-fslib
  • description: "guile-fslib is a library, which contains procedures for working with filenames. It simplifies common tasks like splitting, joining and getting the file extension of a filename." – https://notabug.org/ZelphirKaltstahl/guile-fslib/src/67266331dc9be54cc4c7bf2a6b814815c21e44e1/README.org

Game development

• Chickadee

  • describes itself as "game development toolkit"
  • OpenGL based
  • website: https://dthompson.us/projects/chickadee.html
  • manual: https://dthompson.us/manuals/chickadee/index.html

• guile-allegro5

  • git repo: https://github.com/davexunit/guile-allegro5
  • description: "Allegro 5 is a cross-platform, open source, game programming library written in C. Guile-allegro5 is a collection of modules that provides bindings for Guile." (https://github.com/davexunit/guile-allegro5/blob/614ecc978e034f7b7ba5bd23e27111c8fef81b56/README.md)

• gzochi

  • git repo: https://git.savannah.gnu.org/cgit/gzochi.git
  • project page: https://www.nongnu.org/gzochi/
  • documentation: https://www.nongnu.org/gzochi/gzochid.html

  • description:

    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!

    (https://www.nongnu.org/gzochi/)

Games

• StayAlive

  • git repo: https://github.com/mwitmer/StayAlive

• dryads-wake

  • git repo: https://hg.sr.ht/~arnebab/dryads-wake

  • description:

    Dryads Wake is a game of dialogue and choices. (https://hg.sr.ht/~arnebab/dryads-wake)

• guile-mud

  • git repo: https://github.com/NalaGinrut/guile-mud
  • description: ???

• game_of_life

  • git repo: https://github.com/deathgrindfreak/game_of_life
  • description: "An implementation of Conway's Game of Life in Guile Scheme." (https://github.com/deathgrindfreak/game_of_life/blob/501f7d3c0dc50a3cbac8df3620f8e507f32d5aa5/README.md)

Generators

• C-Ast
  • git repo: https://github.com/zenhack/c-ast
  • description: "C-Ast is a GNU Guile library for generating C code." (https://github.com/zenhack/c-ast/blob/5af5758ccae5e468587cda837e1fd9e685205bef/README.md)

Genomics

• sparqling-genomics

  • git repo: https://github.com/UMCUGenetics/sparqling-genomics

  • description:

    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.

    (https://github.com/UMCUGenetics/sparqling-genomics)

  • usage example: https://github.com/UMCUGenetics/sparqling-genomics/blob/dc5fea515c30aa26ff60b77911438689473d125b/web/ldap/authenticate.scm.in#L148

Graphics

• guile-sdl

  • GNU software page: https://www.gnu.org/software/guile-sdl/
  • gnuvola page of examples: http://www.gnuvola.org/software/guile-sdl-demos/
  • gnuvola software page: http://www.gnuvola.org/software/guile-sdl-demos/

• guile-sdl2

  • project website: https://dthompson.us/projects/guile-sdl2.html

• guile-opengl

  • GNU software page: https://www.gnu.org/software/guile-opengl/
  • GNU software manual page: https://www.gnu.org/software/guile-opengl/manual/guile-opengl.html
  • git repository at Savannah: http://savannah.gnu.org/projects/guile-opengl

• guile-cairo

  • git repository at Savannah: http://savannah.nongnu.org/projects/guile-cairo

• guile-jpeg: a library for parsing JPEG files

  • git repository at GitHub: https://github.com/guildhall/guile-jpeg

Image processing

• guile-cv

  • GNU software page: https://www.gnu.org/software/guile-cv/
  • git repository at Savannah: http://git.savannah.gnu.org/cgit/guile-cv.git

• guile-picture-language

  • website: https://elephly.net/guile-picture-language/
  • repository: https://git.elephly.net/gitweb.cgi?p=software/guile-picture-language.git
  • manual: https://elephly.net/guile-picture-language/manual.html

Design and CAD

• libfive

  • website: https://libfive.com/
  • git repository: https://github.com/libfive/libfive

  • description:

    "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.

GUI development

• guile-gi

  • git repository at GitHub: https://github.com/spk121/guile-gi
  • documentation at: https://spk121.github.io/guile-gi/

  • description:

    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.

    […]

    – https://raw.githubusercontent.com/spk121/guile-gi/c4a9b8d11debe9a633a4be936f1bbf4b7098fe66/README.md

• guile-gnome

  • GNU software page: https://www.gnu.org/software/guile-gnome/
  • git repository at Savannah: http://git.savannah.gnu.org/cgit/guile-gnome.git

• guile-gtk

  • website: https://www.gnu.org/software/guile-gtk/
  • CVS repository at non-GNU Savannah: http://savannah.nongnu.org/projects/guile-gtk/

• g-golf: https://www.gnu.org/software/g-golf/

• guile-webview

  • git repository: https://github.com/KikyTokamuro/guile-webview
  • description: "Wrapper for using libwebview from GNU Guile" – https://github.com/KikyTokamuro/guile-webview/blob/a2af7bc339e777b05e304158bcfae23815d8bcef/README.md
  • documentation: https://github.com/KikyTokamuro/guile-webview/tree/main/examples

Language

• guile-aspell
  • git repository at GitHub: https://github.com/spk121/guile-aspell
  • website: http://lonelycactus.com/guile-aspell.html

Logging

• guile-logging

  • git repository at GitHub: https://github.com/shanecelis/guile-logging

• SysLog proposal

  • git repo: https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/SyslogCowan.md
  • description: This is a specification for an implementation of syslog.

• logging module of sparqling-genomics

  • git repo: https://github.com/UMCUGenetics/sparqling-genomics/blob/master/web/logger.scm
  • description: This is what sparqling-genomics uses internally.

Machine Learning

• decision tree

  • guile-ml
    • repository at notabug.org: https://notabug.org/ZelphirKaltstahl/guile-ml

• guile-snowball-stemmer

  • mentioned on: https://snowballstem.org/projects.html
  • mentioned on: https://github.com/snowballstem/snowball/issues/34#issuecomment-491056371
  • git repo: unfortunately the link to the repository is broken

• AIscm

  • website: http://wedesoft.github.io/aiscm/

  • description:

    AIscm is a Guile extension for numerical arrays and tensors. Performance is achieved by using the LLVM JIT compiler.

    (http://wedesoft.github.io/aiscm/)

Macros

• guile-for-loops

  • mercurial repo: https://hg.sr.ht/~bjoli/guile-for-loops

  • description:

    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.

    […]

    (https://hg.sr.ht/~bjoli/guile-for-loops/browse/README.md?rev=580d3fb365ea2734b037ad3ca7f2ab1e4aa5116d)

• goof-loop

  • repository: https://git.sr.ht/~bjoli/goof-loop/

  • description:

    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 […]

    – https://git.sr.ht/~bjoli/goof-loop/tree/cccc324ecd14325d9f2fe4c7eabd8bc217823d32/item/README.md

• megacut macro:

  • mercurial repo: https://hg.sr.ht/~bjoli/megacut

  • description:

    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).

    (https://hg.sr.ht/~bjoli/megacut/browse/readme.txt?rev=75caf96aa4a9282d489230fe56fff4f1aa5e2564)

• GNU Thales

  • project page: https://savannah.gnu.org/projects/thales
  • git repo: https://git.savannah.gnu.org/cgit/thales.git
  • description: "GNU Thales is set of GNU Guile macroses to perform doctests." (https://savannah.gnu.org/projects/thales)

• Documentation for Scheme Syntax Extension Packages in SLIB

  • website: https://people.csail.mit.edu/jaffer/slib/Scheme-Syntax-Extension-Packages.html#Scheme-Syntax-Extension-Packages

• Implementation of function contracts: https://notabug.org/ZelphirKaltstahl/guile-examples/src/master/macros/contract.scm

Message Queues

• Zero MQ
  • guile-zmq
    • git repository at GitLab: https://gitlab.com/NalaGinrut/guile-zmq
  • guile-simple-zmq
    • git repository at GitHub: https://github.com/jerry40/guile-simple-zmq

Network programming

• Guile's standard library networking module

  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/Networking.html

• guile-curl

  • git repository at GitHub: https://github.com/spk121/guile-curl

• guile-ssh

  • git repository at GitHub: https://github.com/artyom-poptsov/guile-ssh

• GNU Serveez

  • GNU software page: https://www.gnu.org/software/serveez/
  • manual: https://www.gnu.org/software/serveez/manual/
  • git repository at Savannah: http://savannah.gnu.org/projects/serveez/

• serveez-mg

  • git repository at GitHub https://github.com/spk121/serveez-mg
  • based on GNU Serveez

• stis-engine

  • git repository at: https://gitlab.com/tampe/stis-engine
  • description: "Communication layer ontop of guile fibers" – https://gitlab.com/tampe/stis-engine

• Scheme-GNUnet

  • git repository: https://git.gnunet.org/gnunet-scheme.git/

  • description:

    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

  • documentation: https://git.gnunet.org/gnunet-scheme.git/tree/doc

Parallelism

• standard library futures

  • GNU software manual page: https://www.gnu.org/software/guile/docs/docs-2.2/guile-ref/Futures.html (link to Guile 2.2 docs – Where are the 3.x docs?)

  • description:

    […] 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 […]

• guile-fibers

  • git repo: https://github.com/wingo/fibers

  • description:

    Concurrent ML-like concurrency for Guile

• standard library parallel forms

  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/Parallel-Forms.html
  • note: Sometimes the parallel forms might cause errors, see https://lists.gnu.org/archive/html/guile-user/2020-01/msg00092.html, I recommend to use futures or if suitable guile-fibers instead.

• guile-parallel

  • git repo: https://git.sr.ht/~old/guile-parallel
  • description: "High level structures and procedures for parallelism." – https://git.sr.ht/~old/guile-parallel/tree/dc1a55ea2499b6ca4355e9aae1d7256effd14355/item/README.md

Parsing

Parser Combinators

• stis-parser
  • git repository at GitLab: https://gitlab.com/tampe/stis-parser

Parser Generator

• nyacc: Not Yet Another Compiler Compiler
  • git repository at Savannah: https://savannah.nongnu.org/projects/nyacc
  • documentation: https://www.nongnu.org/nyacc/nyacc-ug.html

Other

• standard library PEG parsing

  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html

  • description:

    Parsing Expression Grammars (PEGs) are a way of specifying formal languages for text processing.

    (https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html)

XML parser

• Mixp:
  • git repository: https://git.savannah.nongnu.org/cgit/mixp.git
  • website: https://www.nongnu.org/mixp/
  • description: "Mixp is a set of modules for Guile that wrap libexpat and provide higher-level utilities. […]" (https://savannah.nongnu.org/projects/mixp)
  • documentation: ???

Plotting

• guile-plotutils
  • git repository at GitHub: https://github.com/spk121/guile-plotutils
  • website: https://www.gnu.org/software/plotutils/plotutils.html

Protocols

• X protocol
  • guile-xcb
    • git repo: https://github.com/mwitmer/guile-xcb

Serialization

• guile-msgpack

  • git repo: https://gitlab.com/HiPhish/guile-msgpack

  • description:

    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.

    (https://gitlab.com/HiPhish/guile-msgpack/-/blob/master/README.rst)

• stis-data

  • git repo: https://gitlab.com/tampe/stis-data
  • description: "Serializing guile datastructures into binary format" – https://gitlab.com/tampe/stis-data/-/blob/08d2de0ceef22f87083221b1b59c91de76836bd9/README.md

SRFI (Scheme Request For Implementation) implementations

• TaylanUB/scheme-srfis

  • git repo: https://github.com/TaylanUB/scheme-srfis
  • description: This repository contains implementations for some SRFIs.

• srfi-78-guile

  • git repo: https://github.com/sunjoong/srfi-78-guile
  • description: "SRFI 78: Lightweight testing by Sebastian Egner" (https://github.com/sunjoong/srfi-78-guile)

• guile-srfi89

  • git repo: https://gitlab.com/mjbecze/guile-srfi-89
  • description: "This is a hygienic implemention of SRFI 89 (Optional positional and named parameters) for Guile Scheme." (https://gitlab.com/mjbecze/guile-srfi-89/-/blob/0c907086e809c69faaac75ce2feeb3ba1694f037/README.md)

• srfi-151

  • git repo: https://github.com/ft/srfi-151
  • description: "SRFI-151 — Bitwise Operations — Implementation for GNU Guile" (https://github.com/ft/srfi-151/blob/486ee152c826ad07eaf4e8765e8c20842dba0915/README)
  • license: https://github.com/ft/srfi-151/blob/486ee152c826ad07eaf4e8765e8c20842dba0915/LICENCE
  • documentation: https://srfi.schemers.org/srfi-151/srfi-151.html

• scheme-libraries

  • repository: https://launchpad.net/scheme-libraries

• wisp

  • mercurial repo: https://hg.sr.ht/~arnebab/wisp
  • website: http://draketo.de/english/wisp, https://srfi.schemers.org/srfi-119/srfi-119.html
  • GNU Guix package: guile-wisp
  • description: "wisp: simpler indentation-sensitive scheme" (https://srfi.schemers.org/srfi-119/srfi-119.html)

• awesome-coroutine-generators

  • git repository: https://git.sr.ht/~bjoli/awesome-coroutine-generators/tree
  • description: an implementation of SRFI-158

• double ended queue

  • website: https://srfi.schemers.org/srfi-134/srfi-134.html
  • repository: https://github.com/scheme-requests-for-implementation/srfi-134/

Strings

• guile-raw-strings
  • git repo: https://github.com/lloda/guile-raw-strings

Syntax

• (grand scheme) glossary
  • git repo: https://github.com/plande/grand-scheme

Regular expressions

• IrRegular Expressions (Scheme, R[4567]RS)
  • website: http://synthcode.com/scheme/irregex

REPL (Read Eval Print Loop)

• guile-colorized
  • git repository at GitLab: https://gitlab.com/NalaGinrut/guile-colorized

RPC (Remote Procedure Call)

• GNU Guile-RPC

  • website: https://www.gnu.org/software/guile-rpc/
  • documentation: https://www.gnu.org/software/guile-rpc/manual/
  • git repo: http://git.savannah.gnu.org/gitweb/?p=guile-rpc.git

• guile-xmlrpc:

  • description:

    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.

    (https://github.com/aconchillo/guile-xmlrpc/blob/master/README.org)

  • git repo: https://github.com/aconchillo/guile-xmlrpc

  • manual: (readme file in git repo)

Scientific computing and mathematics

• GNU Scientific Library (GSL)

  • GNU software page https://www.gnu.org/software/gsl/
  • git repository at Savannah: http://savannah.gnu.org/projects/gsl/
  • wikipedia page: https://en.wikipedia.org/wiki/GNU_Scientific_Library
  • Guile bindings: http://community.schemewiki.org/?gee-guile-gsl

• Matrix multiplication

  • guile-ffi-cblas
    • git repository at GitHub: https://github.com/lloda/guile-ffi-cblas

• Fast Fourier Transformation

  • guile-ffi-fftw by lloda
    • git repo: https://github.com/lloda/guile-ffi-fftw
    • description: "A simple wrapper for FFTW, using Guile's FFI" (https://github.com/lloda/guile-ffi-fftw)
  • guile-ffi-fftw by Mikael Djurfeldt
    • git repo at Savannah: https://savannah.nongnu.org/projects/guile-fftw
    • description:

• Symbolic mathematics

  • guile-scmutils

    • website: https://www.cs.rochester.edu/~gildea/guile-scmutils/
    • download: https://www.cs.rochester.edu/~gildea/guile-scmutils/guile-scmutils-v1.0.tgz

    • description:

      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.

      (https://www.cs.rochester.edu/~gildea/guile-scmutils/)

• Guile implementation of symbolic mathematics shown in SICP

  • Does this exist?

Interaction with the Jupyter ecosystem

• guix-kernel

  • git repository at gitlab.inria.fr: https://gitlab.inria.fr/guix-hpc/guix-kernel
  • blog post: https://hpc.guix.info/blog/2019/10/towards-reproducible-jupyter-notebooks/

• guile-kernel

  • git repository at GitHub: https://github.com/jerry40/guile-kernel

Search engine

• babelia

  • git repo: https://github.com/amirouche/babelia

  • description:

    Wanna be search engine with federation support

    (https://github.com/amirouche/babelia)

Shell

• gash

  • git repo: https://git.savannah.nongnu.org/cgit/gash.git

  • description:

    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.

    (https://git.savannah.nongnu.org/cgit/gash.git/tree/README?id=8f9b973264cc799df27795df6230839e96dc00eb)

TUI development

• guile-ncurses

  • GNU software page: https://www.gnu.org/software/guile-ncurses/
  • git repository at GitHub: https://github.com/guildhall/guile-ncurses

• guile-termios

  • git repository: https://gitlab.com/ft/guile-termios

  • description:

    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.

    […]

    – https://gitlab.com/ft/guile-termios/-/blob/29dfd68bdc64d6cea0cd4a50757439b77523e9f5/README

  • license: https://gitlab.com/ft/guile-termios/-/blob/29dfd68bdc64d6cea0cd4a50757439b77523e9f5/LICENCE

Testing

Integration testing

• guix-cuirass
  • git repo: https://gitlab.com/mothacehe/guix-cuirass
  • website: ???

Unit testing

• srfi-64 (https://srfi.schemers.org/srfi-64/srfi-64.html)

  • GNU software Guile manual page: https://www.gnu.org/software/guile/manual/html_node/SRFI_002d64.html

• srfi-64-driver

  • git repository at: ???
  • website: https://ngyro.com/software/srfi-64-driver.html

• guile-testing

  • git repository at: https://github.com/wedesoft/guile-testing
  • description: "This is an example on how to do unit-testing using GNU Guile, Automake Test Anything Protocol (TAP), and SRFI-64." (https://github.com/wedesoft/guile-testing/blob/598768b04fe9ef13e07401f1bd715f5fb3bb964e/README.md)

• guile-unit

  • git repository: ??? (was at https://github.com/sirius94/guile-unit)
  • description: ???

• ggspec

  • git repo: https://github.com/yawaramin/ggspec
  • description: "lightweight unit testing library for Guile" (https://github.com/yawaramin/ggspec/blob/97dab55962f63d9692475b171fd6fbd76ac64731/README.md)

1. TAP output

   • guile-tap

     • git repo: https://github.com/xevz/guile-tap
     • description: "Simple Guile module which provides TAP compilant output." (https://github.com/xevz/guile-tap)
       

   • guile-tap

     • Yes there are 2!
     • git repo: https://gitlab.com/ft/guile-tap
     • description: "This is a library for GNU Guile that implements a framework for specifying test cases that emit output that adheres to the Test Anything Protocol (TAP)¹." (https://gitlab.com/ft/guile-tap/-/blob/87edc4b74bfe0774af0211c06a30366a44c1371a/README)

     • license: https://gitlab.com/ft/guile-tap/-/blob/87edc4b74bfe0774af0211c06a30366a44c1371a/LICENCE

     • scm-test-tap

       • git repo: https://github.com/ft/scm-test-tap
       • description: "TAP emitting test-framework for GNU Guile" (https://github.com/ft/scm-test-tap)

Other

• guile-quickcheck

  • git repo: https://git.ngyro.com/guile-quickcheck
  • website: https://ngyro.com/software/guile-quickcheck.html

  • description:

    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.

    – https://ngyro.com/software/guile-quickcheck.html

• guile-proba

  • git repo: https://codeberg.org/luis-felipe/guile-proba

  • description:

    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.

    – https://codeberg.org/luis-felipe/guile-proba/src/commit/f6b235072ec0f41dcdee8631d454c517e5637dbd/README.org

Types

Static typing

• Theme-D

  • source code: on website at: https://www.tohoyn.fi/theme-d/download.html

  • description:

    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.

    – https://www.tohoyn.fi/theme-d/index.html

  • license: parts as: LGPL-3, GFDL-1.3, GPL-3

  • documentation:

    • examples: https://www.tohoyn.fi/theme-d/examples.html
    • docs: https://www.tohoyn.fi/theme-d/documentation.html

Version control systems

• guile-git

  • git repository at GitLab: https://gitlab.com/guile-git/guile-git

• guile-semver

  • git repository at ngyro: https://git.ngyro.com/guile-semver
  • website at: https://ngyro.com/software/guile-semver.html

Web Development

Web servers

• Guile's standard library's web server:

  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/Web-Server.html
  • blog post about the performance of Guile's web server: http://wingolog.org/archives/2012/03/08/an-in-depth-look-at-the-performance-of-guiles-web-server
  • documentation as generic interface for web server implementations: https://www.gnu.org/software/guile/manual/html_node/Web-Server.html
  • examples for usage for creating a web app: https://www.gnu.org/software/guile/manual/html_node/Web-Examples.html#Web-Examples

• gappserver

  • git repo: https://github.com/uberblah/gappserver
  • description: "a really tiny guile webserver" (https://github.com/uberblah/gappserver)

Web clients

• web-client-with-cache
  • repository: https://labo.planete-kraus.eu/web-client-with-cache.git/
  • manual: https://web-client-with-cache.planete-kraus.eu/index.html
  • description: a caching web client

Web frameworks

• guile's-standard-library's web module for dealing with web stuff:

  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/Web.html

• GNU Artanis web application frameweork

  • GNU software page: https://www.gnu.org/software/artanis/
  • git repository at GitLab: https://gitlab.com/NalaGinrut/artanis
  • official website of the GNU Artanis project: https://web-artanis.com/
  • blog post about GNU Artanis: https://dev.to/heroku/an-ode-to-gnu-artanis-2gn3
  • manual:
    • https://www.gnu.org/software/artanis/manual/manual.html
    • https://www.gnu.org/software/artanis/manual/html_node/
  • blog post about using GNU Artanis in a docker container: https://nalaginrut.com/archives/2019/09/18/install%20gnu%20artanis%20with%20docker

• SPH web app

  • git repository at GitHub: https://github.com/sph-mn/sph-web-app

• Tekuti

  • git repository at GutHub: https://github.com/wingo/tekuti
  • blog post about tekuti: https://wingolog.org/projects/tekuti/
  • description: "Server-side blog engine written in Scheme" (see repository), web blog using Git as its persistent store

Protocols

1. Web sockets

   • guile-websocket
     • git repo: https://git.dthompson.us/guile-websocket.git
     • description: "Guile-WebSocket is an implementation of the WebSocket protocol as defined by RFC 6455." (https://git.dthompson.us/guile-websocket.git/tree/README?id=c854e0f84a40d972cbd532bbb89c97ca0126a7cf)

Tooling / Additional libraries

• JSON

  • guile-json
    • on GitHub: https://github.com/aconchillo/guile-json
    • on savannah: http://savannah.nongnu.org/projects/guile-json/

• guile-www

  • git repository at savannah non-gnu: http://savannah.nongnu.org/projects/guile-www/
  • git repository at: https://github.com/guildhall/guile-www
  • description: "This is the Guile WWW library, a set of Guile Scheme modules to facilitate HTTP, URL and CGI programming." (https://github.com/guildhall/guile-www/tree/263e9632bab062f0ec360c2d54b3bf7d1a4e9ba7)

• guile-webutils

  • git repository at notabug.org: https://notabug.org/cwebber/guile-webutils

• guile-html

  • git repo: https://github.com/TaylanUB/guile-html

  • description:

    A tiny module to make it less annoying to make and write HTML files using SXML. Read the code!

1. Authorization and authentication

   • guile-oauth

     • git repository at GitHub: https://github.com/aconchillo/guile-oauth
       

   • guile-jwt

     • git repository on GitHub: https://github.com/aconchillo/guile-jwt

Static website generators

• guile-haunt

  • git repository at GitHub: https://github.com/guildhall/guile-haunt

• SPH static website generator

  • git repository at GitHub: https://github.com/sph-mn/sph-web-publish

Template engine

• Guile's standard library SXML implementation
  • GNU software manual: https://www.gnu.org/software/guile/manual/html_node/SXML.html
  • Basically your templates become functions or macros.
  • The structure of your document is kept as Scheme data structures.
    • This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
    • It enables pattern matching without resorting to things like regular expressions and similar shenanigans.

Interaction with services

• guile-mastodon
  • git repository at framagit: https://framagit.org/prouby/guile-mastodon
  • documentation at: https://framagit.org/prouby/guile-mastodon/-/blob/master/doc/guile-mastodon.org

Web application examples

• scheme-todomvc:
  • git repo: https://github.com/amirouche/scheme-todomvc
  • demo: https://amirouche.github.io/scheme-todomvc/

Web drivers / Selenium

• guile-web-driver
  • git repo: https://github.com/her01n/guile-web-driver
  • description: "web driver (selenium) client for guile" (https://github.com/her01n/guile-web-driver)

Window manager

• guile-wm
  • git repo: https://github.com/mwitmer/guile-wm

Working with code

• guile-syntax-highlight

  • website: https://dthompson.us/projects/guile-syntax-highlight.html
  • git repository: https://git.dthompson.us/guile-syntax-highlight.git

• guile-syntax-parse

  • git repo: https://gitlab.com/guile-syntax-parse/guile-syntax-parse
  • description: port of Racket's syntax parse to GNU Guile
  • documentation: see https://docs.racket-lang.org/syntax-parse-example/index.html?q=syntax%20parse#%28part._.A_syntax-parse_.Crash_.Course%29

• scheme-lsp-server

  • git repository: https://codeberg.org/rgherdt/scheme-lsp-server

  • description:

    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.

    – https://codeberg.org/rgherdt/scheme-lsp-server/src/commit/f9492cdf89c0680aeddb58478c0371d7d738d1b1/README.md

  • documentation: https://codeberg.org/rgherdt/scheme-lsp-server/src/branch/master/README.md

Other

• guile-lib

  • git repository at non-GNU Savannah: http://git.savannah.nongnu.org/cgit/guile-lib.git
  • website at: https://www.nongnu.org/guile-lib/

  • description:

    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". […]

    (https://www.nongnu.org/guile-lib/)

• Spells

  • git repo: https://github.com/rotty/spells

  • description:

    Spells is a collection of R6RS libraries providing features beyond R6RS in a uniform way across supported implementations.

    (https://github.com/rotty/spells/blob/master/README)

  • documentation: http://rotty.xx.vu/software/spells/ (unfortunately 404 currently)

• SPH website:

  • It has some Guile library and project descriptions and links.
  • http://sph.mn/

• Grip

  • website: http://www.nongnu.org/grip/index.html
  • project page: https://savannah.nongnu.org/projects/grip
  • git repo: https://git.savannah.nongnu.org/cgit/grip.git

  • description:

    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.

    (https://www.nongnu.org/grip/index.html)

Unsorted

• CMOD-PLAY:

  • website: https://www.gnuvola.org/software/cmod-play/
  • description: ???

• guile-mpd: https://github.com/steveerhart/guile-mpd

• alias-generator: https://gitlab.com/Formbi/alias-generator

• bloom-filter: https://github.com/ijp/bloom-filter

• codejam practices: https://github.com/jcca/codejam_practices

• guile-agentx: https://github.com/securactive/guile-agentx

• guile-lfsr:

  • git repo: https://gitlab.com/ft/guile-lfsr

  • description:

    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.

    – https://gitlab.com/ft/guile-lfsr/-/blob/47724179fc3c0f6f4dddd20d189422b1ac9d3cdd/README

  • license: https://gitlab.com/ft/guile-lfsr/-/blob/47724179fc3c0f6f4dddd20d189422b1ac9d3cdd/LICENCE

• guile-e-series

  • git repository: https://gitlab.com/ft/guile-e-series

  • description:

    ---

    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.

    […]

    – https://gitlab.com/ft/guile-e-series/-/blob/7244035d25fc85898bacb76deacc89568aeff44f/README

  • license: https://gitlab.com/ft/guile-e-series/-/blob/7244035d25fc85898bacb76deacc89568aeff44f/LICENCE

Projects

• Guile 100

  • description:

    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.

    (https://github.com/spk121/guile100/blob/master/README.md)

  • git repo: https://github.com/spk121/guile100/

  • website: http://www.lonelycactus.com/guile100/html/index.html

Programming paradigm

"Object-oriented programming"

• GOOPS
  • GNU software manual page: https://www.gnu.org/software/guile/manual/html_node/GOOPS.html

Prototype based

• Shelf
  • git repo: https://github.com/mwitmer/Shelf

Relational programming

• minikanren
  • git repository at GitHub: https://github.com/ijp/minikanren
  • miniKanren uncourse by William Byrd: https://duckduckgo.com/?q=minikanren+uncourse&t=h_&iax=videos&ia=videos&iai=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DiCuVTGWNU3s

Functional programming

• Monad implementations

  • git repository at GitHub: https://github.com/ijp/monad

• Genshou: Extensible effects

  • website: https://git.sr.ht/~wklew/genshou
  • description: Implementation of a way to encapsulate side effects based on http://okmij.org/ftp/Haskell/extensible/. It helps dealing with side effects in a functional way.

Programming language concepts

Pipeline / pipe / chain / threading

• SRFI-197:
  • website: https://srfi.schemers.org/srfi-197/srfi-197.html
  • git repository: https://github.com/ar-nelson/srfi-197
• macro examples:
  • git repository: https://notabug.org/ZelphirKaltstahl/guile-macros/src/master/threading-pipe-macro/macro-hygienic-syntax-rules.scm
  • description: simple pipeline macro implementation
• guile-threading-macro.scm
  • gist: https://gist.github.com/emanon-was/ed12f6023e2d6328334a
  • description: simple pipeline macro implementation
• guile-threading-macros
  • repository: https://hg.sr.ht/~bjoli/guile-threading-macros
  • description: Implements threading macros, which let you choose the position of the threaded argument at each step in the pipeline. Using SRFI-197 is recommended, once it is available in GNU Guile.

State Machines

• Guile-SMC
  • git repository: https://github.com/artyom-poptsov/guile-smc
  • description: "GNU Guile state machine compiler." – https://github.com/artyom-poptsov/guile-smc/blob/d3a1dda50a64f1ac293d02ece1258006a0219e78/README.org
  • documentation: https://github.com/artyom-poptsov/guile-smc/tree/master/doc

Programs

Finances

• ETRACK
  • git repository: https://gitlab.com/restio-al-restio/etrack/
  • description: "[…] a simple package to track expenses: query, add, delete, update. You can use ETRACK from Emacs or from the command-line." (https://gitlab.com/restio-al-restio/etrack/-/blob/fe360a7f6acdb855046c99b888c9f8a11084051c/README)

Window manager

• RPX
  • repository: https://www.gnuvola.org/software/rpx/
  • description: "This is rpx, a port of ratpoison to Guile Scheme. […]" (https://www.gnuvola.org/software/rpx/)
  • on nongnu: https://www.nongnu.org/ratpoison/

Other

• Starlet

  • repository: https://github.com/taw10/starlet

  • description:

    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.

    – https://github.com/taw10/starlet/blob/79df0f8c3289189387a4e07e24e507445ab85a4d/README.md

Tools

Notes

• guile-notes
  • git repo: https://github.com/Halfwake/guile-notes
  • description: "A tool for saving a list of notes." (https://github.com/Halfwake/guile-notes)

Editor support

• guile.vim

  • git repo: https://gitlab.com/HiPhish/guile.vim

  • description:

    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.

    (https://gitlab.com/HiPhish/guile.vim/-/blob/master/README.rst)

• repl.nvim

  • git repo: https://gitlab.com/HiPhish/repl.nvim/

  • description:

    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.

    (https://gitlab.com/HiPhish/repl.nvim/-/blob/master/README.rst)

• conjure

  • git repo: https://github.com/Olical/conjure
  • description: "Conjure is an interactive environment for evaluating code within your running program. […]" (https://github.com/Olical/conjure/blob/4dc7c745618a24799af44797c51af7cc308e42a4/README.adoc)

• Emacs Guile support

  • guile-ide
    • repository: https://framagit.org/Jeko/guile-ide
    • description: Emacs configuration file focusing on Guile development
  • flycheck-guile
  • geiser-guile

• TODO: other editors support

Project management

• guile-hall

  • git repository at GitLab: https://gitlab.com/a-sassmannshausen/guile-hall

• homebrew-guile: https://github.com/aconchillo/

• guile-debbugs

  • git repo: http://savannah.gnu.org/git/?group=guile-debbugs
  • description: see http://git.savannah.nongnu.org/cgit/guile-debbugs.git/tree/README.org

Package managers

• GUIX package search

  • website: https://hpc.guix.info/browse
  • Search for example for ^guile- to find many Guile libraries and projects.

• guildhall

  • git repository at GitHub: https://github.com/ijp/guildhall

• Akku

  • website: https://akkuscm.org/

  • description:

    Akku.scm is a language package manager for Scheme. It grabs hold of code and vigorously shakes it until it behaves properly.

    (https://akkuscm.org/)

Time tracking

• GNU Foliot

  • website: https://www.gnu.org/software/foliot/index.html
  • git repo: https://git.savannah.gnu.org/cgit/foliot.git

  • description:

    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.

    (https://www.gnu.org/software/foliot/index.html)

Build tools

• potato-make

  • repository: https://github.com/spk121/potato-make

  • description:

    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.

    – https://github.com/spk121/potato-make/blob/5e823c5f5a9a51f9f89681684e77636b32cb5669/README.md

Blogs

• https://hyper.dev/
• http://wingolog.org/
• http://okmij.org/ftp/Scheme/
• blog post about singletons in GNU Guile
  • website: http://hiphish.github.io/blog/2019/05/24/singleton-objects-in-guile-scheme/

Other

• SPH lib, collection of Guile libraries

  • website: http://sph.mn/computer/software/sph-lib.html

• C2 Wiki Category Scheme

  • website: https://proxy.c2.com/cgi/wiki?CategoryScheme

• C2 Wiki Guile Scheme

  • website: https://proxy.c2.com/cgi/wiki?GuileScheme

• C2 Wiki Scheme Language

  • website: https://proxy.c2.com/cgi/wiki?SchemeLanguage

• Community Scheme Wiki

  • general
    • website: http://community.schemewiki.org
  • Scheme FAQ
    • website: http://community.schemewiki.org/?scheme-faq-standards

• SICP solutions

  • git repo: https://github.com/alpardal/SICP-guile

  • description:

    A SICP Study Guide With Exercise Solutions in Guile & Emacs Lisp

    (https://github.com/alpardal/SICP-guile)

• Guile-BAUX

  • git repo: https://git.savannah.nongnu.org/cgit/guile-baux.git

  • 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 AC_CONFIGAUXDIR 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

    […]

    – https://www.gnuvola.org/software/guile-baux/guile-baux.pdf

• gclip-select

  • git repo: https://git.savannah.nongnu.org/cgit/gclip-select.git

  • description:

    This is gclip_select, 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 gclip_select 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.

    – https://git.savannah.nongnu.org/cgit/gclip-select.git/tree/README?id=b78bc3cd2d46bba590bddbbe0a7d43823635c249

Other lists of Guile software

• official GNU Guile website library list: https://www.gnu.org/software/guile/libraries/
• SPH list: http://sph.mn/foreign/guile-software.html

Videos / Talks / Presentations

• The GNU Guy:
  • Sending an Email via GNU Guile
  • A tiny and incomplete intro to Scheme Macros
  • Reporting A Guile Bug
  • Guile Web Development (playlist)

This category is still fairly empty. Help filling it with interesting GNU Guile related videos, talks or presentations!