A Common Lisp editor
beirc is a CLIM IRC client Application using the cl-irc library as a backend, initially written by Gilbert Baumann, now maintained by Dave Murray and others.Source code and screen shots are available at common-lisp.net/project/beirc.Beirc requires the newest CVS version of cl-irc and McCLIM, as well as Max-Gerd Retzlaff's tab-layout-pane . Note also that beirc currently requires a lisp that supports multiple processes. The developers are using multithreaded SBCL on x86/linux and OpenMCL on ppc/darwin. CMUCL on x86 could work, as well. (More details are available in the table below. If you get beirc running on a system not noted there, please add it.)Warning: The sound support in beirc is currently very experimental. It works on ACL, probably works on SBCL, and almost certainly only on Unix variants. FeaturesCustomizable variablesThese can be set in the .beirc.lisp file in your home directory (although this too can be changed in variables.lisp):
Set to url (as a string) of your local copy of the Hyperspec and specbot's clhs query answers will be rewritten appropriately.
The maximum width in characters of the message column (as distinct from the name column and the timestamp column). Defaults to 80.
The position of the timestamp column on the screen. Either :right (the default) or :left.
Your nick, as a string.
The command (as a string) to run your web browser. Should work out-of-the-box.
An alist mapping an irc server name (as a string) to a list of channels (each a string) to automatically join on connecting.
An alist mapping an irc server name (as a string) to the password (as a string) to send to the NickServ authentication bot.
A string naming a program (or a program and command-line arguments) that will read sound files from standard input and play them. Used for rudimentary sound support.
A filename (string) that specifies a file to be played (by *default-sound-player*), when your nick is mentioned. Could be NIL instead.
/Connect server nick
Identify yourself to the NickServ service.
Display messages from nick in bold.
Stop displaying messages from nick in bold.
Don't display any messages from nick, past or future.
Display messages from nick again.
Change nick to string.
/Msg nick message
Send message to nick.
Reload the user init file.
Leave the channel with message.
Close the list of windows. If any of these windows refers to a channel, leave each channel.
Perform a WHOIS query on nick.
/Topic [:Topic new topic]
If executed without keyword arguments, shows the current channel topic. If passed the :Topic keyword argument, sets the current channel topic to new topic.
Give channel operator status to nick.
Remove channel operator status from nick..
/Ban Nick nick
Set channel mode +b (ban) to nick!*@*.
/Ban Hostmask hostmask
Set channel mode +b (ban) to hostmask.
Kick nick from the current channel.
Display the list of users on the current channel.
Set away status to message.
Disconnect from the server with message and terminate beirc.
Disconnect from the server with message.
/Switch Timestamp Orientation
Sets orientation of timestamps to the left column if they are in the right column and vice versa.
Mouse InteractionThere's an awful lot of it. Many items are displayed as clickable CLIM presentations, including nicks, URLs, tabs for servers and channels, etc., allowing easy access to basic commands. Documentation for whatever you're about to do by clicking is provided, as in other CLIM apps, in the lowest, black pane; this gives you an idea of what, if anything, will happen when your Left, Middle or Right click occurs.Working SystemsThe following Hardware/OS/Lisp Implementation combinations are known to run beirc (somewhere, at least):
3.1, kernel 2.6.13
Multithread SBCL 0.9.5
3.1, kernel 2.6.12
Allegro CL 8.0
/list command, or users pane a la XChat.
Some hints about keystrokes (this is really at least partly a McCLIM issue).
The moon. On a stick.
"IRC clients should show a diff on topic change."OdditiesThings that should probably be fixed, once we know what causes them.
URL handling for URLs that appear in the chat as () does not work. AFAICT, the url is forwarded to the browser together with the opening paren, causing failure.
Would be nice to have auto-identify, the same way we have auto-join.
Use of help command causes error.
Error: attempt to call `#:STREAM44679' which is an undefined function.
List of commands that you get on right click should be listed alphabetically (or possibly even in nested menus, since the list is so long).
There are many ways to cause the system to fail with completion errors. These should be trapped. Some of this is more McCLIM problems than BEIRC proper, I figure.Old bugs:
The box-adjuster-gadget does not work for me (rpg). It comes active, but is unable to adjust the size of the windows. Seems not to happen for others (antifuchs) with different setups (possibly more up-to-date CLX than the version included with ACL?). This seems to be a problem with the setting of
min-height in the space-requirement for the tab-layout-pane. I have not yet been able to track down where this is set. fixed: There were exact pixel sizes coded in as :height and :width. By default, any window settings are copied into :min-height and :min-width. Being a little more careful about the difference between :height (resp. width) and :min-height, seems to have fixed things up.
Common Lisp Typesetting system
Climacs is an Emacs-like text editor written in Common Lisp.It is a CLIM application. Its development resources are summarized at
its project page on common-lisp.net. As of July 2006, Climacs is a useful tool for writing Common Lisp code, but it does not have close integration with a REPL, debugger or inspector like SLIME. The CLIM-desktop project provides additional integration with Climacs into other applications (most notably the McCLIM Listener), but does not greatly enhance Climacs' capabilities for editing Common Lisp. Climacs can presently do parameter hinting, code evaluation, symbol completion, displaying of compiler notes and definition-editing.
Climc is the Common Lisp Instant Messaging Client. It is a CLIM application. The project page : Climc
A Syntax highlighting library
An image viewer using Qtools
RFC2229 client REPL-a-like for Common Lisp.
The Snark Theorem Prover
A tiling, keyboard driven window manager
Torta shows you where your disk space is going. It uses the graphical format used by the the awesome program filelight to represent disk usage. Unlike filelight, Torta can be run on a computer with no graphical environment: it generates a flash file that can be consulted, locally or remotelly, using any browser that has the flash plugin installed.Torta has been tested on SBCL, CMUCL and Clisp.Homepage: TortaUpdate2, February 2008 - Fixed the link to the new homepage
Bordeaux Threads makes writing portable multi-threaded apps simple.
CL-DBI is intended to provide the same SQL interface for each database.Not only, you don't have to learn each API of databases anymore, but this layer is especially convenient when you want to use the different database by environment.For example, your application had better to use efficient database such as MySQL on the production environment, but you may want to use SQLite3 on your machine. In that case, all what you have to do is only to rewrite calling "dbi:connect".Homepage: fukamachi.github.com/cl-dbiLicense: LLGPL
Mustache Template Renderer
Password management for Common Lisp (web) applications. cl-password-store provides a light-weight and extendible solution to
safe password storage:
cleartext-free, using your choice of hash algorithm through
storage in an SQL database through
clsql, in a database your application
already uses anyway, or in a separate one, and using any backend
supported by clsql,
password reset mechanism with one-time tokens (suitable for mailing
to users for confirmation),
user creation optionally with confirmation tokens (suitable for
mailing to users),
(obviously) user authentication.
Users can be identified by strings or by subclassing
user-token-mixin. The code is available under LLGPL at github. For documentation check out the
Common Lisp bindings to GNU Readline library
Common Lisp bindings for libtcod, a truecolour
terminal-emulation library written in C.
CLFSWM: Fullscreen Window Manager
There are three packages by the name of "CLON", although the third one doesn't actually introduce any conflict because the package is named com.dvlsoft.clon.ClonClon is a task scheduler library much like cron for lisp that is implemented as a shallow layer on top of SBCL timers.It's written by Gabor Melis and can be found at http://quotenil.com/git/?p=clon.git;a=summary.
CLON (Common Lisp Object Network) is a prototype-based object system for Common Lisp written by David O'Toole. The details of inheritance, message passing, and field lookup are inspired by the Io language and the Garnet UI toolkit (KR in particular).Release tarball: clon-1.0.tar.gzHomepage: http://github.com/dto/clonCLON is used in RLX, a game engine for rogue-like games.
Clon - the Command-Line Options Nuker
Clon is a library for managing command-line options in standalone Common Lisp applications. It provides a unified option syntax with both short and long names, automatic completion of partial names and automatic retrieval/conversion of option arguments from the command-line, associated environment variables, fallback or default values. Clon comes with a set of extensible option types (switches, paths, strings etc.). Clon also provides automatic generation and formatting of help strings, with support for highlighting on tty's through ISO/IEC 6429 SGR. This formatting is customizable through "themes".Clon currently works on Unix (including MacOS X) and Windows (Cygwin, MinGW/MSYS) with SBCL, CMUCL, CCL, ECL, CLISP, ABCL, Allegro (both standard and modern) and Lispworks.Clon is written by Didier Verna.
Clon's homepage is here.
language extension system programming command-line options parser
Common Lisp SQL Fluid Connection Pools
An implementation of the X Window System protocol in Lisp.
Cobol Storage library
Isolated, reproducible virtual development environments.
WILBUR2: Nokia's Semantic Web Toolkit for CLOS
Robust CSV parser and printer
FirePHP debug utility
Flexichain is an API for editable sequences. Its primary use is in end-user applications that edit sequences of objects such as text editors (characters), word processors (characters, paragraphs, sections, etc), score editors (notes, clusters, measures, etc), though it can also be used as a stack and a double-ended queue. Project page
Topics: data structure
Simon Funk's quasi SVD
Gordon is a Common Lisp library that can be used to generate Adobe Flash files and thus useful in web applications. Found here. You might be interested in this rough "tutorial" on gordon.
Torta is an application using this library.
The GNU Scientific Library for Lisp (GSLL) allows you to use
the GNU Scientific
Library (GSL) from Common Lisp. This library provides a
full range of common mathematics operations useful to
scientific and engineering applications. The design of the GSLL
interface is such that access to most of the GSL library is
possible in a Lisp-natural way; the intent is that the user not
be hampered by the restrictions of the C language in which GSL
has been written. GSLL thus provides interactive use of GSL for
getting quick answers, even for someone not intending
to program in Lisp.
roots of polynomials, special functions, vector and matrix operations,
permutations, sorting, BLAS support, linear algebra,
eigensystems, fast Fourier transforms,
quadrature, random numbers, quasi-random sequences,
random distributions, statistics, histograms, N-tuples,
Monte Carlo integration, simulated annealing, differential
equations, interpolation, numerical differentiation,
chebyshev approximation, series acceleration,
discrete Hankel transforms, root-finding, minimization
least-squares fitting, IEEE floating-point,
discrete wavelet transforms.For more information see the project website.Available with Quicklisp.Page on GitLab
HH-Web is a library of Common Lisp code intended to simplify development of modern web applications.Features:
Content templates for consistent site structure (HTML and image)
Site customizations for specific user agents
Regex-based URL routing
Source repository: HH-WEB on Github.comLicense: MIT
Topics: web framework
HTML-TEMPLATE is an HTML template library to use templates much like Perl's HTML::Template. Despite of its name, HTML-TEMPLATE is HTML-agnostic and could be used for templating other documents.It was written by Edi Weitz and can be found at http://weitz.de/html-template/.Jörg Höhle also liked the idea of a clear and complete
separation between HTML (written by designers) and code. He
came up with a variant of Edi's approach to HTML template. It uses
Edi's parsing code (thanks!), no more, but the programmer view on it
feels very different.Consider Edi's 7x7 chess board example on his documentation page and
how my code would look like:(setq my-template
;; load and check against specification
(tmpl-load "file.html" '((LOOP rows (LOOP cols colorful-style content)))))
(let ((counter 0))
(loop repeat 7 do
(loop repeat 7 do
(funcall cellprinter (oddp counter) (format nil "~R" counter))
Jörg Höhle's design goals:
Separate HTML design from code as much as possible, the key
idea in the template approach.
Verifiable specification of the interface between
both, never see "$foo" in a user's browser as an indication that
some variable was not substituted.
Designer and programmer work concurrently early
on. The programmer may use a default template automatically derived
from the specification, the web-designer a random-content template
delivering web-server based on this specification.
Efficiently deliver data, which should be no
slower than frameworks based on direct embedding of code in HTML or
vice-versa. That's why I rejected intermediate structures (Edi's template
structure) and produce compilable code. A parsed template
becomes Lisp code, which can be either compiled and loaded as such
from the file system, or compiled on the fly at load-time.
Incrementally deliver results as produced (useful
for huge data or HTTP 1.1 chunked encoding) which is incompatible
with non-lazy intermediate structures.
Provide for lexical scoping in templates,
unlike Perl's HTML::Template. That is, a TMPL_VAR occuring
inside TMPL_LOOP may refererence variables defined in an
outer (e.g. global) level. There's no need to repeat definitions at
Deliver data in pieces as large as posible: i.e. no individual
calls to PRINC or FORMAT for each HTML tag, coalesce these
Early HTML validation of the templates
some more I forgot...
[This next section confuses me a bit. I think a list entry refers to Edi's version, but I can't really tell.[
Some differences between Edi and Jörg's work include:
No facility for caching or automated reloading, which I feel
orthogonal to templates, interferes with
TMPL_INCLUDE and is left to the application.
An attempt to load templates validates them, so the running
web-server application will choose to reject template updates (and
log the error) until they are corrected instead of displaying
garbage to the user.
TMPL_VAR may have content, which is valuable for
the web designer's GUI: s/he sees this content up to a closing
Variable subtitution on the code side is based on ordering
in the specification, not on names or symbols, so there are no
surprises with packages and symbol-names across files.
The template substituting code is trivially small and was
ported to Scheme. In fact, there's almost no such code since it's
in part in the programmer calling sequence (witness the above
example) and part in the Lisp code representing the template.
Edi's got a package ready to go for you. [So is there code somewhere interested people could hack on, or something?]
The above specification is not all about the interface between
programmer and designer. URL structure, form names etc. need also
be agreed upon.
The template approach is very useable for
applications with small or medium demand for variable
appearance. Or you'd need too many templates.
I generated pages using templates featuring highly
dynamic content (e.g. variable numbers of both rows and
colums of a table, selectable and variable order) which some people
initially thought not usable with a strict templates approach. It
was, in fact, clean and easy.
TMPL_LOOP and TMPL_VAR are really
general and could even emulate TMPL_IF.
I generated my templates from Lisp code via SXML, instead of
having a designer. This aids consistency among templates. For a
all-by-one-person job, the separation is clear overhead, even if
there's potential for code reuse. You'd probably prefer a
HTML-from-sexpr approach in such a case and bypass templates.
HTML validation of the templates is hindered by
TMPL_IF with an ELSE part, substitutions
inside attributes and obviously only possible when the
substitutions done by TMPL_VAR affect the HTML
structure. The most dynamic template is TMPL_VAR
As an enhancement, there could be a mechanism for global
substitutions which would remain outside of the specification.
E.g. some pages like to display calendars, the current date or use
a mapping from month names to numbers etc. Such substitutions could
always be present, across all pages of the application.
A few different kinds of queues, with optional
A simple math library focused on linear algebra.
The Lisa expert system shell
Unix command line flag parsing.
mel-base is a library for handling email with support for Maildir, POP3, IMAP and SMTP folders.It makes no difference from the programmer's side if an E-Mail gets copied from a Maildir folder to an IMAP folder or from POP3 to Maildir. Sending E-Mails through SMTP is simply done through the same mechanism. One just copies an E-Mail from a folder supporting the "receiver" protocol like IMAP, Maildir or POP3 to the SMTP folder which supports the "sender" protocol.E-Mails are first-class objects and on-demand fetching of parts of an e-mail
like the header or a particular part is supported.Mel-base got used to implement a POP3 server, a Spam-Filter and a CLIM Mail-Reader/Composer (http://codeartist.org/mel/) and many small scripts to process, filter and deliver E-Mails. Mel-Base itself is Open Source and licensed under a license similar to the BSD License. The mentioned applications, while not Open Source, are available on request.Author: Jochen SchmidtIt works in SBCL , CMUCL, OpenMCL and LispWorks with partial support for
CLISP and ABCL. Porting it should be straightforward because implementation dependent parts are encapsulated in a thin compatibility layer.My fork policy:
I open sourced mel-base as a generic library for handling e-mails (and not just as base-library for mel) and I'm interested in getting feedback on how to enhance it further. I know that in the code-base of mel-base might be parts which may be useful for other purposes, but please think twice about it before creating unnecessary forks.If you have ideas, drop me an e-mail. If this really cannot hold you off; please use darcs to create a proper branch of the code-base so your work can get reused by users of mel-base. The darcs repository is at http://www.crispylogics.com/opensource/repos/mel-base/. Please don't just rip it off.To kire (Erik Enge): In #lisp you stated your intend to split mel-base into parts. Mel-Base already is quite modular in that each folder backend got implemented in its own ASDF module. I plan to go further on that road by factoring the backends out to different ASDF systems depending on mel-base as a core. If you still have those splitting plans - please contact me first.
-- Neonsquare (Jochen Schmidt), author of mel-base
A modularization framework
Programmatical interfaces extension for Modularize
Super micro framework for Common Lisp.
A collection of tools to aid in development with CommonQt.
A collection of components and utilities for use in Qt applications.
A collection of utilities to ratify, validate and parse inputs.
RESTAS is a Common Lisp web application framework, based
on the Hunchentoot HTTP server. It was developed to simplify development of
web applications following the REST architectural style.
A library to support change ringing applications, including methods library support
Syntax extensions akin to Racket's Scribble and Bigloo's Skribe
A tool to generate documentation about Lisp projects through an HTML template.Staple is yet another Common Lisp documentation generation application. It uses Clip and lQuery to do most of the work. The main features include automatic package symbol index processing, documentation gathering from related files and generation through expressive templates.The project can be found on github including a fully documented symbol index and a getting started tutorial.
As of August 2014, Staple is available on Quicklisp.Staple is licensed under the Artistic License 2.0.
hu.dwim.stefil is an abandoned test framework with a living fork at fiasco, and its philosophy is to stay as transparent as possible, disrupting the normal Lisp application development process as little as possible.License: Public Domain / BSDWhat Stefil basically adds is that it quietly gathers extra runtime information and statistics (like a test backtraces, assertions, failures and/or errors), and introduces a wider range of ASSERT-like primitives to express the expected behavior of a program. It also integrates well with the Slime inspector, and provides useful restarts to achieve that goal.Unique Selling Points:
Non-intrusive to the normal development process (debugging a failed test is exactly the same experience as debugging your application)
Integrates well with Slime
Lets you run tests both in non-interactive and in interactive mode with useful restarts
Makes it trivial to invoke even only parts of the test suite: just call the DEFTEST (DEFUN) of your choice
Allows you to interactively skip parts of the test suite (e.g. to skip a long test (and remember that suite are also tests) you can abort with C-c C-c and select a restart)
Its fixture implementation allows invoking specific parts of the test suite without sacrificing performance
Homepage: http://dwim.hu/project/hu.dwim.stefilMaintainers: Levente Mészáros, Tamás Borbély and Attila Lendvai.Current darcs repository is available at:
http://dwim.hu/darcs/hu.dwim.stefil/Notable packages using stefil for testing include:
All forks of UCW use the older stefil system.
Old version called stefilHomepage, including some documentation: http://common-lisp.net/project/stefil/index-old.shtmlOlder version of stefil is hosted by Luís Oliveira and can be found at: http://common-lisp.net/~loliveira/tarballs/inofficial/stefil-2008-08-19.tar.gzBoth new and old versions are Quicklisp installable using package names hu.dwim.stefil and stefil.
teepeedee2 is a fast HTTP server and web framework.It is competitive in performance or faster than most C webservers, while being written entirely in Common Lisp. It includes a simple blog application with instant comments (itself a fairly unique feature) and ATOM feeds, and an unfinished card game.
Web LLGPL networking
Compatibility library to run things in the main thread.
UnCommon Web is a web framework.License: ?Homepage: http://common-lisp.net/project/ucw
UCW documentation is available in the source repo.The documentation page on the UCW website has some background material.[2009-09-19] Blog post on preparing for UCW development
[2007-11-24] Blog post on trying out UCWUCW TricksUCW Tricks and CookbookEvaluation, 20100901A very brief assessment of all web frameworks listed in cliki was carried out in September 2010. This assessment comprised: check websites, download source if available, attempt to compile, review documentation. The review found that UncommonWeb was well established. However, much of the documentation was stated to be out of date, which is off-putting but at least implies an evolving system. Some copyright dates as recent as 2009 indicate that it is still being developed.There were no obvious links to example live applications built with this kit.Where to find something new with UCW
If anyone is interested there is but one page about UCW which currently seems to be "supported" head over to:
Currently running UCW stuff