1 History and versions
1.1 Origins and early releases
Allegro Common Lisp traces its origins to the late 1980s, when Franz Inc. was founded by John K. Foderaro and others. The first versions, released in the early 1990s, aimed to provide a robust, commercially supported implementation of Common Lisp for workstation environments. Early releases were noted for their emphasis on native code compilation and efficient memory management, setting the stage for Allegro CL's reputation in demanding enterprise applications.
1.2 Major version milestones
1.2.1 Allegro CL 6.x series
Released in the early 2000s, the 6.x series introduced a redesigned foreign function interface (FFI), improved garbage collection (including generational and ephemeral garbage collection), and enhanced support for multithreading. This series also saw the first version of the graphical IDE (CLIDE) and the AllegroServe web server, which became widely used in Lisp-based web applications.
1.2.2 Allegro CL 8.x series
The 8.x series (mid-2000s) brought major performance improvements, especially in native code compilation with the introduction of the Lisp-to-C translator and better integration with 64-bit architectures. It also added support for Unicode, the Unicode external format, and advanced debugging features like the interactive debugger with stack inspection. This series marked a shift toward broader platform support, including early versions for Linux on x86-64.
1.2.3 Allegro CL 10.x and later
Starting with version 10.0 (circa 2015), Allegro CL adopted a new versioning scheme and focused on modernizing the development environment. Key features include a revamped IDE with better project management, compatibility with Quicklisp, and improved performance via just-in-time (JIT) compilation techniques. Later releases (11.x, 12.x) continued to refine concurrency support, added partial support for the Common Lisp Interface Manager (CLIM), and enhanced interoperability with .NET and Java through updated JLinker and .NET integration.
1.3 Licensing and commercial model
Allegro CL is a commercial product offered under various licenses: a full commercial license for enterprise use, a trial/evaluation license (time-limited but feature-complete), and historically an educational license. Franz Inc. also offers an "Express" edition (free of charge for non-commercial development) with limited deployment options. The commercial model includes annual maintenance and support subscriptions, providing access to updates, priority bug fixes, and technical assistance. Licensing is per-developer seat, and runtime distribution requires a separate runtime license for deployed applications.
2 Core features
2.1 Language conformance
2.1.1 ANSI Common Lisp compliance
Allegro CL aims to be fully compliant with the ANSI Common Lisp standard (ANSI X3.226-1994). It passes the official test suite (the “ANSI CL test suite”) with only minor deviations documented in its release notes. The implementation also supports the common practice of adding standard extensions (e.g., loop macro, format directives) that are now de facto standard but were optional in the original specification.
2.1.2 Extensions beyond the standard
Allegro CL provides numerous extensions, including advanced threading primitives (e.g., mp package for multiprocessing), atomic operations, a flexible condition system beyond ANSI’s, and a rich set of data types like simple-vector and hash-table with custom test functions. It also includes specialized libraries for sockets, streams, and filesystem operations that go beyond the minimal standard.
2.2 Performance and optimization
2.2.1 Native code compilation
Allegro CL compiles Common Lisp code to native machine code via its compiler (the :cl compiler). The compiler uses a combination of interpretation for fast startup and compilation on demand. For production, the full native compiler generates highly optimized code, with support for type declarations, inline expansion, and block compilation. The compiler also integrates with the foreign function interface to optimize calls to C and C++ libraries.
2.2.2 Garbage collection strategies
The garbage collector in Allegro CL is a generational, copying collector with optional stop-and-copy and concurrent modes. It supports ephemeral (nursery) collection for short-lived objects and full heap cycles for long-lived data. For real-time applications, Allegro CL offers a “preemptive” GC mode that minimizes pause times by interleaving collection with execution. Users can also manually trigger GC and adjust parameters like heap size and generation thresholds.
2.3 Foreign function interface (FFI)
2.3.1 Calling C and C++ libraries
Allegro CL’s FFI (eval-based and declarative via def-foreign-function and def-foreign-variable) allows seamless calling of C functions and C++ (with caveats for name mangling and object layout). It supports passing and returning complex types, callbacks from C into Lisp, and integration with C++ objects through a “C++ FFI” layer. The FFI is widely used to access system libraries (e.g., OpenGL, POSIX, Win32 API) and third-party middleware.
2.3.2 Dynamic library loading
The system can load and unload shared libraries at runtime using the load-foreign-library function. This enables dynamic linking to platform-specific dynamic-link libraries (DLLs on Windows, .so on Unix, .dylib on macOS). The FFI also supports lazy binding and automatic symbol resolution across multiple libraries.
3 Development environment
3.1 Integrated Development Environment (IDE)
3.1.1 Allegro CL’s graphical IDE (Common Lisp Interactive Development Environment)
The graphical IDE, often called CLIDE, provides a multi-pane environment with an editor, REPL, inspector, debugger, and project browser. It includes syntax highlighting, code completion, and a “listener” for interactive development. The IDE integrates with the Allegro CL debugger, allowing users to step through code, inspect stack frames, and modify variables during debugging. It also offers a graphical profiler and a system browser for navigating the Lisp image.
3.1.2 Editor integration (Emacs, Visual Studio Code)
Allegro CL supports integration with external editors. For Emacs, it provides fi::inferior-lisp mode (part of the ilisp package) that allows connecting to a running Lisp image, evaluating forms, and editing source code with SLIME-like functionality (though SLIME itself can also be used if configured). For Visual Studio Code, Franz Inc. has developed an official extension that provides syntax highlighting, REPL integration, and interactive debugging using the Language Server Protocol (LSP) and the Allegro CL LSP server.
3.2 Debugging and profiling tools
3.2.1 Interactive debugger and stack inspector
Allegro CL’s debugger is fully interactive: on encountering an error, it enters the debug loop, allowing inspection of the call stack, variable bindings, and the ability to restart from arbitrary frames (using :r to invoke restarts). The stack inspector provides a graphical tree view in the IDE. It supports stepping, breakpoints (via the break function), and conditional breakpoints using advise-based instrumentation.
3.2.2 Profiler and performance analysis
The built-in profiler (profiler package) instruments function calls and reports inclusive and exclusive execution times, call counts, and memory allocation. It can be used interactively or programmatically, and results can be exported as text, HTML, or flame graphs. Allegro CL also offers a “sampling profiler” that records stack snapshots at intervals, useful for identifying hotspots in long-running applications.
3.3 Build system and deployment
3.3.1 Generating standalone executables
Allegro CL can produce standalone executables via its “delivery” feature. The developer specifies an entry point and a set of modules to include; the system then links a minimal runtime (the “kernel”) with the compiled application code. The resulting executable does not require a full Allegro CL installation to run, though it may depend on runtime DLLs (on Windows) or shared libraries (on Unix). The build process supports tree shaking to exclude unused code.
3.3.2 Application delivery and licensing
Deployed applications are subject to runtime licensing. Franz Inc. offers a “runtime license” that allows distribution of the generated executable to end users without per-seat costs for the developer. The licensing model is based on the number of deployed instances or an annual site license. Allegro CL also supports generating “protected” executables that check for a valid license file at startup.
4 Libraries and frameworks
4.1 Standard libraries
Allegro CL includes a comprehensive set of standard libraries beyond the ANSI Common Lisp specification. These cover network programming (sockets, HTTP server), file I/O (streams, pathnames), process management (multiprocessing, semaphores), regular expressions, XML/HTML parsing, and a SQL interface (via the sql package). Many of these libraries are documented in the official Manual.
4.2 Third-party library support
4.2.1 Quicklisp compatibility
Allegro CL is compatible with Quicklisp, the popular Common Lisp library manager. Users can install Quicklisp and load packages directly. However, because Allegro CL uses its own package system and some incompatible extensions, not all Quicklisp libraries work out of the box. Franz Inc. maintains a list of known incompatible libraries and provides patches for many.
4.2.2 ASDF (Another System Definition Facility)
Allegro CL includes built-in support for ASDF (version 3.x and later). It can load systems defined by .asd files, and the Allegro CL IDE integrates with ASDF through a system browser. The ASDF support is fully functional for most standard libraries, though some ASDF operations (like perform with custom actions) may require minor adjustments.
4.3 Domain-specific packages
4.3.1 Web and networking (e.g., AllegroServe)
AllegroServe is a popular web server and framework included with Allegro CL. It provides an HTTP/1.1 server, a template engine (for generating HTML), session management, and support for cookies, SSL (via OpenSSL), and WebSocket (via websocket package). AllegroServe can be used for both static and dynamic web applications and supports CGI-style and handler-based invocation.
4.3.2 Database connectivity
Allegro CL includes a SQL interface (the sql package) that provides a portable, high-level API for relational databases. It supports ODBC and native drivers for Oracle, PostgreSQL, MySQL, and Microsoft SQL Server. The interface allows querying via strings or an S-expression based DSL, and can fetch results as Lisp lists or hash tables. For Object-Relational Mapping, third-party libraries like clsql are also compatible.
4.3.3 Natural language processing and AI
Franz Inc. has historically offered a Natural Language Processing (NLP) toolkit called “AllegroGraph” (a graph database with RDF support) and a Common Lisp version of the commercial “PowerLoom” knowledge representation system. Additionally, Allegro CL is widely used in AI research and application development, often with packages like cl-nlp, cl-pattern-matcher, and integration with machine learning libraries (e.g., cl-libsvm, cl-random-forest). The platform’s performance makes it suitable for real-time AI inference.
5 Platform and interoperability
5.1 Supported operating systems
5.1.1 Windows
Allegro CL supports Windows 10 and 11 (both 32-bit and 64-bit). The Windows version integrates with the Win32 API via its FFI, and the IDE is natively implemented using the CLIDE toolkit. It supports multi-threading and can be used to develop GUI applications using third-party libraries like cl-cffi-gtk or directly with Win32 windows.
5.1.2 macOS
On macOS, Allegro CL runs on Intel and Apple Silicon (via Rosetta 2 emulation for 64-bit x86 images). The system uses the macOS native threading model and provides access to Cocoa/Objective-C via the FFI. The IDE is available as a Cocoa application. Native Apple Silicon support is provided in the latest versions (12.x).
5.1.3 Linux and Unix variants
Allegro CL supports a variety of Linux distributions (Red Hat, Ubuntu, Debian, CentOS) on both x86-64 and AArch64. For other Unix-like systems (FreeBSD, Solaris, AIX), support is available on a best-effort basis. The system uses POSIX threads and can be used in headless server environments. The IDE is not available on non-GUI systems, but the REPL and all development tools work via terminal.
5.2 Cross-platform development considerations
Allegro CL code is generally portable across supported platforms, but platform-specific differences exist in FFI (for system calls), file path conventions, and GUI toolkit availability. The IDE’s project system abstracts away many differences, and the platform detection functions ((software-type) and (machine-type)) allow conditional code. Developers targeting multiple platforms are advised to test on each target OS individually.
5.3 Integration with other languages
5.3.1 Java interop (JLinker)
JLinker is a bridge that allows Allegro CL to call Java methods and access Java objects, as well as expose Lisp functions to Java. It uses the Java Native Interface (JNI) and can embed a JVM within the Lisp image. The bridge supports instantiating Java classes, calling static and instance methods, passing complex types (including strings, arrays, and collections), and handling Java exceptions.
5.3.2 .NET integration
For .NET interoperability, Allegro CL provides the “Allegro CL .NET” interface, which uses the Common Language Infrastructure (CLI) under Mono or the .NET Framework. It allows calling .NET methods, accessing properties, and subscribing to events. The interface is bidirectional: Lisp functions can be exposed as .NET delegates. This integration is primarily used on Windows, but works with Mono on Linux as well.
6 Community and support
6.1 Documentation and tutorials
6.1.1 Official documentation and release notes
Franz Inc. provides extensive documentation, including the “Allegro CL Manual” (a PDF and HTML reference), API documentation for all built-in libraries, and release notes for each version. The manual covers installation, configuration, the IDE, debugging, delivery, and each library in detail.
6.1.2 User manuals and guides
In addition to the manual, there are guides for specific topics: the “AllegroServe Guide”, the “Foreign Function Interface User Guide”, the “Delivery Guide”, and a “Getting Started” tutorial. Franz Inc. also publishes occasional whitepapers and blog posts on performance tuning and best practices.
6.2 Customer support and professional services
Licensed users receive technical support via a ticket system and email. Support includes bug fixes, workarounds, and general advice. Franz Inc. also offers professional services: custom library development, performance consulting, and training (on-site or remote). For critical applications, they provide an “extended support” option with guaranteed response times.
6.3 User groups and mailing lists
The primary community forum is the allegro-cl mailing list (hosted on the Franz Inc. website), where users ask questions, share tips, and report issues. There is also a comp.lang.lisp newsgroup where Allegro CL topics often appear. Franz Inc. maintains a knowledge base of frequently asked questions and hosts occasional user group meetings (physical and virtual). Third-party user groups (e.g., the Association of Lisp Users) also include Allegro CL as a topic of interest.