newLISP

newLISP is a scripting-oriented dialect of Lisp designed to be small, fast to start, and easy to deploy as a single self-contained binary. Created by Lutz Mueller, it pares the Lisp tradition down to a pragmatic core aimed at everyday scripting tasks — text processing, networking, rapid prototyping, and gluing systems together — while adding a distinctive set of design choices that set it apart from Common Lisp and Scheme. Among those choices are an unconventional memory model called one reference only (ORO), first-class contexts that double as namespaces and object prototypes, and a large library of built-in functions for networking, statistics, and distributed computation.

History & Origins

newLISP’s development began in 1991, when Lutz Mueller started writing it, originally on a Sun-4 workstation. The early language then moved into the personal-computer world: around 1993, version 1.3 was distributed through CompuServe, with versions targeting Windows and MS-DOS. As Windows shifted from 16-bit to 32-bit through the 1990s, newLISP followed.

A pivotal moment came in April 1999, when newLISP was ported to Linux. As part of that work, several of the core algorithms were rewritten and the older Windows-specific code was removed, and the project was released as open-source software under the GNU General Public License. In 2001, the language was ported back to Windows (initially through the Cygwin environment), and a Tcl/Tk-based GUI front end, newLISP-tk, was introduced.

The language continued to mature through the 2000s. In 2006, version 9.0 introduced 64-bit precision for integer arithmetic and for some operations on large files. Development has continued steadily since, with the latest stable release, 10.7.5, published in 2019 under version 3 of the GPL.

Design Philosophy

newLISP’s guiding aim is to be a fast, full-featured, cross-platform scripting language with modest memory and storage requirements. Where Common Lisp grew into a large, standardized, industrial language, newLISP deliberately stayed small and opinionated, optimized for quick startup and small scripts rather than large compiled systems.

Several design principles flow from this:

• Simplicity over orthodoxy. newLISP departs from traditional Lisp semantics where its author judged a simpler or more practical alternative was available — sometimes controversially among Lisp purists.
• Batteries included. A great deal of functionality that other languages relegate to external libraries — networking, basic statistics, encryption, distributed processing — is built directly into the interpreter.
• Deployment as a single file. newLISP can be packaged as a standalone executable, making distribution straightforward.
• Predictable performance. Its memory model is designed so that execution time is constant and repeatable rather than punctuated by unpredictable garbage-collection pauses.

Key Features

One reference only (ORO) memory management

newLISP’s most distinctive feature is its approach to memory. Instead of traditional tracing or reference-counted garbage collection, it uses a scheme its documentation calls one reference only (ORO): most objects are allowed to have only a single reference at any time, and they are reclaimed as soon as that reference goes away. Values are copied when stored in data structures or passed to functions, rather than shared.

Because reclamation is synchronous, newLISP avoids the unpredictable pauses associated with conventional garbage collectors, giving it constant and repeatable execution timing. The main exceptions to copying are symbols and contexts, which are shared rather than copied and therefore provide the language’s mechanism for indirection.

Contexts as namespaces and objects

A context in newLISP is a lexically separated namespace. Contexts are first-class objects: they can be created and destroyed at runtime, passed as parameters, and referred to by symbols. This single concept does a lot of work — it provides modular namespacing and also serves as the basis for a prototype-based, object-oriented style of programming, where contexts act as object prototypes.

Fexprs and macros

newLISP creates special forms using fexprs, defined with define-macro. Unlike a hygienic macro system that transforms code before evaluation, a newLISP define-macro definition receives its arguments unevaluated and decides what to do with them at call time — a return to an older Lisp tradition that gives the programmer direct control over evaluation.

A practical built-in library

The interpreter ships with a broad standard library that reflects its scripting focus:

• Networking: TCP/IP and UDP sockets, plus higher-level support for protocols such as HTTP, SMTP, POP3, FTP, and XML-RPC.
• Distributed and multi-core processing: primitives for spawning and coordinating parallel work.
• Statistics: functions including Bayesian and other statistical routines.
• Data access: interfaces to databases such as SQLite, MySQL, and ODBC.
• Foreign functions: the ability to import and call functions from shared libraries and DLLs.

A small example shows the familiar Lisp shape with newLISP’s conventions:

1
2
3
4
5
6
7
8
9

; define a function and call it
(define (greet name)
  (println "Hello, " name "!"))

(greet "World")

; map an anonymous function over a list
(map (fn (x) (* x x)) '(1 2 3 4 5))
;=> (1 4 9 16 25)

Evolution

Over three decades newLISP evolved from a 16-bit personal-computer curiosity into a portable, open-source scripting language. The two most consequential turning points were the 1999 Linux port and open-sourcing, which opened the project to a wider community and a Unix-centric design, and the 2006 move to 64-bit precision in version 9.0. Throughout, the language preserved its core identity — small, fast-starting, batteries-included — rather than chasing standardization or feature parity with larger Lisps. The most recent stable release, 10.7.5, dates to 2019.

Current Relevance

newLISP occupies a niche in the broader programming landscape. It never achieved the mainstream adoption of Python or the standardized reach of Common Lisp, and active development has slowed in recent years. Its documentation lists support across BSD, Linux, macOS, Solaris, and Windows on common 32-bit and 64-bit hardware, reflecting its long-standing emphasis on portability.

The language retains a small but devoted community, and its most visible artifacts include web frameworks such as Dragonfly and newLISP on Rockets, the bundled newLISP-GS graphical server, and a thorough reference manual. For developers who value a tiny, quick-launching Lisp with networking built in, it remains an appealing tool.

Why It Matters

newLISP matters less for its market share than for the design questions it poses. By rejecting conventional garbage collection in favor of its ORO model, treating contexts as both namespaces and object prototypes, and embracing fexprs over hygienic macros, it stands as a deliberate experiment in how small and how different a useful Lisp can be. It demonstrates that a one-person language project can sustain decades of development, run nearly everywhere, and carry a complete networking and scripting toolkit in a footprint measured in megabytes. For students of language design — and for anyone curious about the road Lisp didn’t take — newLISP is a compact, thought-provoking case study.

Sources: newLISP — Wikipedia, newLISP official site, newLISP v.10.7.5 Manual and Reference.