Visual LISP

Visual LISP is the enhanced dialect of AutoLISP — AutoCAD’s embedded Lisp — together with the integrated development environment that made serious software engineering possible inside a CAD program. Developed in the mid-1990s by Basis Software of Exton, Pennsylvania under the name Vital LISP, it was acquired by Autodesk in November 1997, rebranded Visual LISP, sold briefly as an add-on for AutoCAD Release 14, and then built directly into AutoCAD 2000 in 1999, where its engine replaced the original AutoLISP interpreter outright. Every AutoLISP program run in AutoCAD since then has run on the Visual LISP engine. For a language that lives entirely inside one host application, its reach is remarkable: millions of drafters, engineers, and CAD managers have used AutoLISP and Visual LISP routines to automate the production of the drawings that buildings, roads, and machines are made from.

History & Origins

AutoLISP: a Lisp in a CAD program

The story begins with AutoLISP. In January 1986, Autodesk shipped AutoCAD Version 2.18 with an embedded programming language adapted from XLISP, David Betz’s small, portable experimental Lisp from 1983. The choice of Lisp was pragmatic: an interpreter was easy to embed, symbolic expressions suited the interactive command-line culture of AutoCAD, and a garbage-collected dynamic language let drafters — not professional programmers — write useful automation. AutoLISP became one of the most successful examples of an embedded application language ever shipped: for a large community of CAD users it was the first and only programming language they ever learned.

Autodesk enhanced AutoLISP steadily through the 1980s and early 1990s, but after AutoCAD Release 13 in the mid-1990s the company’s attention shifted to its C++ ObjectARX API and to VBA. AutoLISP was left stable but stagnant — no IDE, no debugger, no compiler, and no access to the emerging world of Windows COM automation.

Vital LISP fills the gap

Third-party developer Basis Software saw the opening. Its product, Vital LISP, was a considerably enhanced superset of AutoLISP built on Autodesk’s own ObjectARX technology. It added what professional developers had been missing: a full integrated development environment with syntax coloring and source-level debugging, a compiler producing protected binaries, ActiveX/COM support for driving AutoCAD’s object model (and other Windows applications), and reactors — event handlers that let Lisp code respond to things happening in the drawing.

Autodesk bought the technology in November 1997, renamed it Visual LISP, and after a short life as a paid Release 14 add-on, folded it into AutoCAD 2000 in March 1999. From that release forward, Visual LISP was AutoLISP’s implementation: the old interpreter was retired and the two names came to describe one system — “AutoLISP” the core language, “Visual LISP” the extended functions and the IDE.

Design Philosophy

Visual LISP is shaped by two constraints: it had to remain fully compatible with a decade of existing AutoLISP code, and it had to make that code base viable in a Windows, COM-centric world. The result is layered rather than redesigned:

• The Lisp core stays simple. AutoLISP is a small, dynamically scoped, dynamically typed Lisp descended from XLISP. It lacks features a Common Lisp programmer would expect — there is no user-facing macro system and the set of data types is modest — but that simplicity is precisely what made it learnable by drafters.
• Extensions are namespaced by prefix. Visual LISP’s additions arrive as function families: vl- general-purpose utilities (string, list, file, and registry functions), vlax- ActiveX/COM automation and variant/safearray conversion, and vlr- reactor functions for event-driven programming.
• Code as a deliverable. The compiler turns source into FAS files (single compiled routines) or VLX modules (self-contained applications bundling compiled code with dialog definitions and resources), giving commercial developers speed, packaging, and source protection that interpreted AutoLISP never offered.
• The drawing is the data structure. Like AutoLISP before it, Visual LISP treats AutoCAD entities and symbol tables as its native domain — programs select, interrogate, and transform drawing geometry the way other Lisps transform lists.

Key Features

• Full IDE (VLIDE): editor with Lisp-aware formatting and syntax coloring, source-level debugger with breakpoints and watch windows, symbol inspection, and project management — all running inside AutoCAD.
• ActiveX/COM automation via vlax- and vla- functions, exposing the AutoCAD object model to Lisp and allowing automation of other COM-capable applications.
• Reactors (vlr- functions): callbacks fired by drawing events — object modification, command start/end, save, and more — enabling genuinely event-driven CAD applications.
• Compilation to FAS and VLX formats for distribution and intellectual-property protection.
• Seamless AutoLISP compatibility: legacy code from the 1980s onward runs unchanged on the Visual LISP engine.

A small taste of the language — classic AutoLISP with Visual LISP’s ActiveX extensions:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

;; Draw a circle through ActiveX and report the modelspace object count
(defun c:democircle (/ acad doc mspace circ)
  (vl-load-com)
  (setq acad   (vlax-get-acad-object)
        doc    (vla-get-ActiveDocument acad)
        mspace (vla-get-ModelSpace doc))
  (setq circ (vla-AddCircle mspace (vlax-3d-point '(0.0 0.0 0.0)) 10.0))
  (vla-put-Color circ acRed)
  (princ (strcat "\nModelspace now holds "
                 (itoa (vla-get-Count mspace))
                 " objects."))
  (princ))

Evolution

After the AutoCAD 2000 integration, Visual LISP itself changed little for two decades — a stability its users largely welcomed, since routines written in 1999 still run today. The platform around it moved instead. AutoCAD 2011 for Mac (released in 2010) brought AutoLISP to macOS, though without the Windows-only Visual LISP IDE or its ActiveX/COM functions, which depend on Microsoft’s COM infrastructure.

The most significant modern development came with AutoCAD 2021 in 2020: Autodesk released the AutoLISP Extension for Visual Studio Code, an open-source (Apache 2.0) extension providing editing and debugging of AutoLISP on both Windows and macOS, alongside Unicode string-handling improvements in the language itself. Autodesk signaled that VS Code, not the aging VLIDE, is the intended future of AutoLISP development — though as of AutoCAD 2026 the classic Visual LISP IDE still ships on Windows. In 2023, AutoLISP support arrived in AutoCAD LT 2024, opening the language to the budget tier of AutoCAD for the first time.

Current Relevance

AutoLISP and Visual LISP remain fully supported in current AutoCAD, and the community around them is unusually durable. Sites like Lee Mac Programming, AfraLISP, and the CADTutor and Autodesk forums sustain an active exchange of routines, and untold numbers of firms depend on in-house Lisp libraries accumulated over thirty years. The reasons for that persistence are practical: AutoLISP is still the fastest way to automate AutoCAD for anyone who is not a professional software developer, the code is portable across decades of AutoCAD releases, and nothing else in the AutoCAD ecosystem — not .NET, not ObjectARX, not JavaScript — matches its immediacy for small, drawing-centric tasks. Within its niche, it is not legacy technology; it is the working standard.

Why It Matters

Visual LISP matters for two reasons. First, it is arguably the most widely deployed Lisp in history by user count — not among computer scientists, but among drafters and engineers who learned (setq) and (command) to get drawings out the door, most of whom never thought of themselves as Lisp programmers at all. It quietly validated Lisp’s founding claim: that a small symbolic language can make programming accessible inside a specialized domain. Second, its history is a textbook case of an ecosystem outgrowing its vendor. When Autodesk let AutoLISP stagnate, a third party built the professional tooling users needed, and Autodesk ultimately bought it back and made it the official implementation — a pattern that has repeated across the software industry ever since. Nearly forty years after AutoLISP first appeared and more than twenty-five after Visual LISP became part of AutoCAD, Lisp parentheses still shape a meaningful fraction of the world’s built environment.