Editing CMU Common Lisp

{{Short description|Free Common Lisp implementation}}
{{Primary sources|date=May 2022}}
{{Infobox software
| name                   = CMUCL
| logo                   =
| screenshot             =
| caption                =
| author                 = [[Carnegie Mellon University]]
| developer              = Various
| released               = Early {{Start date and age|1980}}
| latest_release_version = 21e<ref>{{cite web |url=https://gitlab.common-lisp.net/cmucl/cmucl/wikis/home |title = Home · Wiki · cmucl / cmucl · GitLab}}</ref>
| latest_release_date    = {{Start date and age|2023|05|14}}
| latest_preview_version =
| latest_preview_date    =
| operating_system       = Several [[POSIX]]-compliant OSs
| platform               = [[Cross-platform]]
| language               = [[Common Lisp]]
| genre                  = [[Compiler]] and [[Run-time system|runtime]]
| license                = [[Public domain]]
| website                = {{URL|cmucl.org}}
}}
'''CMUCL''' is a [[free software|free]] [[Common Lisp]] implementation, originally developed at [[Carnegie Mellon University]].

CMUCL runs on most [[Unix-like]] platforms, including [[Linux]] and [[Berkeley Software Distribution|BSD]]; there is an experimental [[Microsoft Windows|Windows]] port as well. [[Steel Bank Common Lisp]] is derived from CMUCL. The [[Scieneer Common Lisp]] was a commercial derivative from CMUCL.

==History==
The earliest implementation predates Common Lisp and was part of [[Spice Lisp]], around 1980. In 1985 Rob MacLachlan started re-writing the compiler to what would become the Python compiler and CMUCL was ported to Unix workstations such as the IBM PC RT, MIPS and SPARC. Early CMUCL releases did not support Intel's x86 architecture due to a lack of registers. CMUCL strictly separated type-tagged and immediate data types and the garbage collector would rely on knowing that one half of the CPU registers could only hold tagged types and the other half only untagged types. This did not leave enough registers for a Python backend.

After CMU canceled the project (in favor of a [[Dylan (programming language)|Dylan]] implementation using some of CMUCL's compiler base) maintenance has been taken over by a group of volunteers. By 1996 this group was making regular releases on its own infrastructure.

Around the same time a port to Intel's x86 architecture was completed, first running on [[FreeBSD]], later [[Linux]]. The problem of lacking registers was solved by a new conservative garbage collector. This new garbage collector accepts any value of any type in the registers, and treats anything that might be a pointer as a pointer for the purpose of not collecting or moving its target.

==Compiler and other code execution units==
* CMUCL features an interpreter that is mainly used for the [[REPL]], but can be used for faster loading of Lisp files that don't need compilation.
* A machine to interpret compact bytecode (which can be emitted from the compiler). This is rarely used now, but was popular in early CMUCL releases because image sizes were drastically reduced at a time where download bandwidth on the Internet was low.
* A native code [[compiler]] named "Python" (not to be confused with [[Python (programming language)|the Python programming language]]). If Common Lisp source code has been written with appropriate declarations and is organized with speed in mind the Python compiler generates code that is almost free from overhead compared to code compiled from languages like C++.  Some inefficiencies such as function call interfaces and lack of pointer-free arrays of user-defined data types are dictated by the Common Lisp standard and still need to be worked around (e.g. by inlining more and using macros to build constructs that look like user-defined structures but are actually accessing fields in preallocated specialized arrays). The Python compiler also features powerful [[type inference]]s, helping the programmer in writing overhead-free code by either inferring types automatically or issuing hints about missed optimization opportunities.

==Features==
* Generational [[garbage collection (computer science)|garbage collection]] and multiprocessing capability on the x86 ports.
* A [[foreign function interface]] which allows interfacing with C code and system libraries, including [[shared libraries]] on most platforms, and direct access to [[Unix]] [[system calls]].
* Support for [[interprocess communication]] and [[remote procedure call]]s.
* An implementation of [[CLOS]], the Common Lisp Object System, which includes multimethods and a metaobject protocol.
* A graphical source-level debugger using a [[Motif (software)|Motif]] interface, and a [[code profiler]].
* An interface to the [[X11 Window System]] (CLX), and a sophisticated graphical widget library (Garnet).
* Programmer-extensible input and output streams.
* [[Hemlock (text editor)|Hemlock]], an [[Emacs]]-like editor implemented in Common Lisp.

==See also==
{{Portal|Free and open-source software}}
*[[Steel Bank Common Lisp]]

==References==
{{Reflist}}

==External links==
*[http://cmucl.org CMUCL Home Page]

{{Common Lisp}}

{{DEFAULTSORT:Cmu Common Lisp}}
[[Category:Carnegie Mellon University software]]
[[Category:Common Lisp implementations]]
[[Category:Common Lisp (programming language) software]]
[[Category:Free and open source compilers]]

[[Category:Free and open source interpreters]]
[[Category:Public-domain software with source code]]