In 1998, Roger Corman announced his new project, Corman Lisp, to comp.lang.lisp:

On Lisp’s 40th birthday, I am pleased to announce a new Common Lisp compiler and development environment for Windows 95/98/NT. This is a full featured system with very fast performance (competitive with the fastest Windows Common Lisps) and full support for using Win32 to build applications. It compiles to machine code (no interpreter is included), supports OS-level threads (minimal support now, more under development) save-image, save-application, etc.
The compiler is free, and I am distributing the source code along with it (in Common Lisp). A free console app may be used to interact with the compiler (a listener) but the included IDE application provides a much richer lisp-enhanced editor and development environment. I plan to ask a modest license fee for the IDE, although details are not finished. The included evaluation copy of the IDE is fully functional for 30 days, after which it will add a nag dialog (and I hope to have licensing details finalized by then).
I know many of you in this newsgroup will be both interested and possibly skeptical of this system, and I encourage you to please download a copy and try it out. I have included some documentation (in the form of a Word 97 format manual) but have not had time to document it extensively. Any of you who get back to me with helpful feedback I will be happy to repay you with a free registration code for the IDE.
I am the developer of PowerLisp for the Macintosh, which has been useful for many years for a large number of people. This new product, called Corman Lisp, is far superior, however, and has been written from the ground up for the Win32 environment. I have been working on it for over 2 years, and am eager to get some feedback. I believe it will fill an important niche and make Common Lisp a more viable development platform.

It filled a void in the Common Lisp world. Roger later wrote:

When Corman Lisp was first developed in the late 90s, there was really no competition on Windows platforms. Franz only had a 16-bit Lisp they were selling, and not really taking the Windows market seriously. Mac Common Lisp was on 680x0 and later PowerPC but didn’t get to Windows for a very long time, and LispWorks didn’t support Windows until much later. Now I think most all of those have good implementations on Windows (though only MCL is free). I have used Allegro extensively for a large contract with SRI and I see the value of a mature cross-platform system like they have. It is however extremely expensive, and developing applications for distribution requires lots of negotiation and per-license payments to Franz. Corman Lisp still has some advantages, I think–it is really a good hackers Lisp, when you want to easily get down into the assembly level, or in the guts of the compiler, to do almost anything. You have the power of Lisp to do those things with macros and a nice high-level dynamic environment.

The final release, 3.0, came out in 2006.

In 2013, I contacted Roger about the future of Corman Lisp. He decided it would be good to release the sources under a permissive license. At the start of 2015, he allowed me to update and publish the source code with the MIT license.

The code isn’t something you can use right away in a modern environment. Here’s Roger’s take:

I see two primary issues at this point. First, the Corman Lisp kernel needs to be built with Visual Studio 2005, which is an old version of VS. At one point I built it with VS2008 and it built and ran, but some problem with the FFI caused applications saved, and the IDE, to have problems. This type of thing is fairly common as Microsoft makes subtle changes to the code generation of their C compiler, which in turn affects the Lisp kernel which has very tight rules about how it expects its code to look. I did a lot to reduce the kernel (move things from the kernel to Lisp code, which is then compiled safely), but did not fully resolve the VS 2008 issues. Now there is VS 2010 and 2012, and I never tried building with either of those. In general I find each newer version of VS is worse for native C/C++ debugging, as .NET has become Microsoft’s primary platform for new software.
The other issue is running on 64-bit OS. Again, the FFI misbehaves when you have saved an application, or just doing a bunch of FFI stuff in an application. It is something to do with GC and the 64-bit support for running 32-bit applications (which is what CL is). It could be related to the same issue as I encountered with building under VS2008.
Tracking down this problem is difficult.
Regarding converting to a full 64-bit Lisp, this would be a much bigger effort. Corman Lisp gets such good performance by a large amount of hand-optimized x86 assembly code. This would all have to be rewritten/replaced in a 64-bit Lisp.

And:

Going forward with the code, I would probably say that the first step is getting the kernel (Corman Lisp server) to compile using a new version of MS Visual Studio (such as VS2012 or VS2013)–it was last compiled with VS2005. I tried at one point to get it to build with VS2008 (and I think the project files are still there) but ran into some bugs and didn’t resolve them.
Getting the kernel to compile properly and the GC and FFI to work properly is tricky. The kernel is very sensitive to the generated code, and you pretty much have to disable all optimizations (since the GC depends on things like proper stack frames and the various code patterns when it is looking for references). The Makefiles and project files should have the settings set correctly (for VS2005) but newer compiler versions try to add new sophisticated optimizations, which then causes new issues.
Turning off optimizations shouldn’t really negatively affect performance, as most of the kernel code gets replaced by compiled Lisp code during the build process. Some functions don’t, however (the kernel code generator, for instance) and these are probably the source of the compiled code sensitivity.

Even though it may not be easy to use directly, I think it’s fantastic that Roger has relicensed the code. It’s a piece of Common Lisp history. It was a real, shipping, commercial Common Lisp environment, with a compiler, garbage collector, standard Common Lisp library, IDE, and an interesting set of add-ons. I hope that it helps people understand implementation techniques and provides inspiration for future Common Lisp projects.

The source of Corman Lisp 3.0 is now available at https://github.com/sharplispers/cormanlisp.

Enjoy!

2 notes

bendiken liked this
ludwig1024 liked this
zblisp posted this