Allegro CL 10.1

Persistency built in, not a database add-on

Allegro CL ® is the most powerful dynamic object-oriented development system available today, and is especially suited to enterprise-wide, complex application development. Complex applications with billions of objects are now made easy with Allegro CL 10. The complexity of today's software applications and the explosion of data size are pervasive in all fields ranging from Life Sciences to Manufacturing to Financial Analytics. Allegro CL 10 is the most effective system for developing and deploying applications to solve these complex problems in the real world. For more information, contact

"Allegro CL 10 confirms Franz's commitment to providing a leading Common Lisp platform. The upgrade path is completely smooth and the under-the-hood improvements, especially in the garbage collector, make it a worthy successor to what remains one of the best environments for developing and delivering amazing software."

Jason Cornez CTO, RavenPack International

"Allegro CL 10 with AllegroCache continues to deliver performance improvements that facilitate the success of our products with the U.S. Dept of Defense. Lisp is the ideal implementation vehicle for our machine learning algorithms and large scale, parallelized stochastic simulation product sets. We are delighted with the Garbage Collection enhancements in Allegro CL 10."

Glenn D House Sr. President, 2Is Inc.

"Common Lisp remains one of the best languages for Artificial Intelligence applications, its flexibility enables rapid experimentation and deployment. Today's Lisp compilers are robust and flexible allowing development entirely within Lisp or in combination with other languages. For example, our CyclePad system for helping engineering students learn thermodynamics is written entirely in Allegro CL. Similarly, our sketch understanding system, CogSketch, which is a novel platform for both cognitive science research and education is primarily written in Allegro CL with two modules in C."

Ken Forbus - Walter P. Murphy Professor of Computer Science at Northwestern University


See the Release Notes for a complete description of new features and enhancements.

New Features in 10.1

  • 64-bit Linux ARM (aka ARM64 or ARMv8): both SMP and non-SMP
  • New external format: GB18030
  • For macOS and Windows: executable signing
  • Character tables updated to Unicode 9.0.0
  • OpenSSL is dynamically loaded rather than statically linked
  • defstruct slot-option validation

  • xmlrpc now uses the SAX parser rather than the older, deprecated XML parser
  • The IDE's trace dialog reports the elapsed time for each traced call
  • Implements "grab_fast_mutex" for all architectures, leading to performance improvements for multiprocessing on some architectures
  • GC improvements
    • find-gcpath: A new tool to help locate the reason specific objects are being kept alive across garbage collections (see documentation)
    • collected-newstuff: A tool to help analyze the heap allocations made while executing a block of code. (see documentation)
    • Handle exceptions during gc: Exceptions during gc are now reported, with a mechanism for using a low-level (non-lisp) debugger to analyze the problem
    • Misc performance enhancements for the global gc
  • With more than 200 fixes and 150 enhancements (see the release notes for the highlights), this release focuses on stability and some important new features.

New Features in 10.0

For additional information on these, and many other new features and improvements, please read the release notes for this major new release of Allegro Common Lisp.


Connectivity Tools Database Tools Deployment Tools GUI Tools
IDE Prolog Tuning Tools Web Server

Powered by Common Lisp, Allegro CL's true dynamic object technology allows developers to generate leading edge, mission-critical applications that are robust, extensible, and easy to evolve and deploy.

  • AllegroCache
  • AllegroCache -- The enabling technology behind Allegro CL persistent objects is a high-performance, scalable, dynamic object-caching database. It allows programmers to work directly with objects as if they were in memory while in fact the object data is always stored on disk. It supports fully ACID-compliant transaction mode with both long and short transactions. It automatically maintains referential integrity of complex object networks. AllegroCache provides 64-bit real-time data caching on the application memory to achieve very high data access throughput over as large a data set as required. AllegroCache features include:

    • Persistent CLOS Objects in Allegro Common Lisp -- Class definitions are stored as first class objects in the database
    • Dynamic Schema Evolution -- Redefine classes on the fly, persistent objects are lazily updated when accessed
    • Standalone & Client Server -- Single user on local disk or multiple clients talking to single server over sockets
    • Bulk Loading -- Improved performance adding objects to the database
    • Transaction Logging -- Restore databases after power failure or disk crash
    • Expression Cursors -- Iterate over a set of instances that satisfy a predicate over multiple slots of an instance
    • Range Queries -- Retrieve objects with slots that match a range of values
    • Native lisp btrees -- Comparable in speed with BerkeleyDB, with more control
    • Transactional model -- All ACID features, commit/rollback, and optimistic concurrency
    • Supports databases with billions of objects (and Terabytes of Data)
    • Convenient macros to loop over classes, maps and sets
    • Indexed slots -- A mapping from slot-values to objects, retrieve objects and object ids (oid)
    • Maps -- Transactionally safe persistent hashtables
    • Sets -- Persistent large collections of objects
    • Supports most common datatypes -- Including unsigned-byte 8 arrays, maps and sets
    • Object ID's unique for the lifetime of the database -- User accessible
    • Dump the database into XML files
    • Restore database from the XML dump
    • User controlled caching -- For the size of the btrees and the total number of objects stored in the cache
  • Connectivity
  • Connectivity:
    • SAX/DOM XML Parsers: Validating XML parsers, successfully tested against all major test suites. Analyze and process enterprise XML data extremely fast
    • SOAP API: Enables Allegro CL applications to communicate with new and legacy applications over the internet via the SOAP protocol, and to access web services over the internet
    • WSDL Compiler: Automatically generates client SOAP templates from WSDL files and server WSDL files from Lisp expressions
    • Allegro Webactions: A Web Application Framework for building dynamic web pages that can be easily maintained and updated
    • AllegroServe: A dynamic, high-performance Lisp-based web server that also interoperates with other web/application servers
    • HTML Parser: Process and analyze web page data
    • SSL Socket Streams: Secure internet transactions
    • XML RPC (Remote Procedure Call): Allows Lisp applications to communicate via XML
    • Lisp RPC (Remote Procedure Call): Allows two Lisp applications to more easily communicate
    • IPv6 -- Internet Protocol version 6 socket support
  • Control Development
  • Control Development:
    • Allegro Prolog: A classic AI programming language in Allegro CL for Logic Programming, with an execution speed in excess of 1 Mlips and running essentially cons free
    • Pcache -- An update to Allegro Prolog, an implementation of Prolog within Allegro CL. It allows Allegro Prolog to be used as a query language for AllegroCache
    • Regular Expressions: A fast, Perl-compatible Regular Expression matcher
    • Allegro Runtime Analyzer: Profiles function calling patterns and analyzes their space and time utilization for code optimization, an important tool for tuning application performance
    • Very large array-total-size-limit (229 for 32-bit, 260 for 64-bit)
    • Operating System Interface: Built-in interface for direct interaction between Allegro CL and the OS, without the need to write foreign code
    • Shell Module: Provides access to the Unix/Linux/Mac commands at the application code level, enhancing performance, portability and consistency across platforms
    • asdf System Definition Facility (see for info on asdf)
    • OpenGL Interface on platforms with available OpenGL libraries (see for more information)
    • IDE and Common Graphics for greater usability and navigation
    • HTML Widget in Common Graphics -- Used by the IDE help facility for better integration
    • Large file support -- On 32-bit platforms this greatly increases the size of files that can be reliably handled. (Functions which may not have worked before but now do include file-position and file-length, and the OS Interface functions stat, os-truncate, and os-ftruncate). The new limit is 263 - 1 in size. This is about nine billion times larger that the old limit, which was 4 Gigabytes. (On 64-bit platforms, the maximum allowable size has always been 263 - 1)
    • Cryptography: SHA1, HMAC and RC4 support
    • Localization support for Unicode international character sets, local time, currency, etc.
    • Graphical profiling and debugging tools for multiple threads
    • Interact with GNU Emacs with the Franz Inc. Emacs-Lisp interface or SLIME
  • Source Level Debugger for Mac, Windows, and Linux
  • The Allegro CL Source Stepper

    Watch the recorded webinar here.

    The new Allegro CL Source Stepper is an offering unique to existing Lisp debuggers, and in fact probably unique to source-level debuggers provided by other languages. The new Allegro Source Stepper provides the following:

    • Debug/stepping info can be loaded on demand, without recompiling the function under debug.
    • Assembler instructions can be displayed and stepped.
    • Macros are rendered transparent, allowing macro forms as well as all levels of their expansions to fully participate in the debug process.
    • Language personalities can be defined and loaded, which customize the debugger behavior for domain specific languages implemented in Common Lisp.

    The source stepper displays source code while stepping through a form. When using it with the IDE, (not available on Sparc or AIX platforms) the source stepper is associated with the new Stepper Dialog. The Stepper Dialog allows carefully testing compiled code by interrupting execution at selected forms in the original source code and at macroexpansions of the code, allowing state to be examined at each stop point.

    The dialog displays the original lisp source code for a function or method that is being stepped through, highlighting the form at which the stepper is stopped. Button widgets allow proceeding in various ways each time execution has been interrupted. The dialog also displays macroexpanded forms and the values of arguments and local variables, updated after each step. The IDE's code editor can be invoked at any time on the code being stepped through.

    The dialog is implemented on top of the base lisp's stepping facility, which also has a simpler textual interface that can be used in a lisp listener. See The Lisp DeBug (ldb) stepper and The source stepper, both in debugging.htm.

    Stepper Dialog Example (click on picture to enlarge)

    The Definition Pane

    The Definition Pane (at the top of the dialog) shows the source code for the function or method that's currently being stepped through. This is a copy of the real source code text, complete with comments and original line breaks. The form at which the stepper is currently stopped will be highlighted with a different background color. Red parentheses are drawn around any breakpointed forms. The breakpointable form under the mouse (if any) in the Definition Pane will have a blue border drawn around it.

    The form in the Definition Pane where the stepper is stopped is drawn with a background color that can have different meanings. An explanatory note will appear in the dialog the first three times each highlighting color is used. The default color is blue. When green, source-level debugging information is available for the function that the highlighted form will call. This is a "green light" that pressing the Step Into button will continue doing source-level stepping. When orange, you are stopped at a macro form. When gray, it means that no source code range is known for the current step point.

    The Form Pane

    The Form Pane (second from the top) shows just the form at which the stepper is currently stopped. This form would be executed by a subsequent Step Next. Sometimes this is a form in the original source code, and is the same as the highlighted form in the Definition Pane, and at other times it is all or part of a macroexpansion.

    The Stack Pane

    The Stack Pane (third from the top) lists the arguments and local variables of the function that is being stepped through, followed by the arguments to the function that called the function being stepped, and then by the arguments to to the next calling function.

    Assembly-Language Stepping in the Stepper Dialog

    If breakpoints are added to functions for which source-level debugging information is not available, the Stepper Dialog will still display some information and allow stepping to be done.


    Please refer to the Stepper Dialog documentation for the full details.

  • Interoperability
  • Interoperability:
  • Runtime
  • Runtime:

Minimum Supported Operating System Versions

Allegro CL 10.1 is available on the following operating system versions. The Types are either non-SMP or SMP. SMP is not available on all platforms.

Platform Types available
New! 64-bit Linux (ARMv8) with glibc 2.17 non-SMP, SMP
32-bit Linux (x86) with glibc 2.12 non-SMP, SMP
64-bit Linux (x64) with glibc 2.12 non-SMP, SMP
32-bit macOS 10.11 non-SMP
64-bit macOS 10.11 non-SMP, SMP
32-bit Windows non-SMP, SMP
64-bit Windows non-SMP, SMP
32-bit FreeBSD (x86) non-SMP
64-bit Solaris/AMD non-SMP
32-bit Solaris/SPARC non-SMP
64-bit Solaris/SPARC non-SMP
Copyright © 2021 Franz Inc., All Rights Reserved | Privacy Statement Twitter