AutoLISP

AutoLISP is a dialect of the LISP programming language embedded within Autodesk’s AutoCAD computer-aided design software. Introduced in 1986, it gives CAD users and developers a programming language directly inside the drawing environment — one capable of creating geometry, reading and modifying drawing entities, prompting users for input, and defining entirely new AutoCAD commands. For nearly four decades, AutoLISP has served as the primary accessible customization layer for AutoCAD, enabling architects, engineers, CAD managers, and technical users to automate repetitive drawing tasks and build domain-specific tools on top of the platform without requiring a separate compiler or development environment.

History & Origins

AutoCAD Before AutoLISP

When AutoCAD was first released in 1982 by Autodesk (then Marinchip Software Partners), it was a significant achievement: a professional-grade CAD application that ran on microcomputers rather than the dedicated workstations that computer-aided drafting had previously required. However, the early AutoCAD offered limited customization. Users could record and replay simple command sequences through script files, but there was no way to write programs that made decisions, computed geometry, or responded to conditions in the drawing.

This limitation mattered because much of engineering and architectural drafting is inherently repetitive and rule-driven. Standard details appear over and over. Dimensions follow formulas. Room labels must be consistent. The ability to automate these tasks through a real programming language had obvious value, and AutoCAD’s user community recognized it early.

Michael Riddle and AutoLISP 1.0

AutoLISP was introduced with AutoCAD Version 2.18 in 1986, developed primarily by Michael Riddle. The choice of LISP as the foundation was deliberate. LISP had a long history as a language for symbolic computation and had already been used in a number of interactive environments where programs needed to manipulate structured data — in this case, CAD geometry and drawing entities. LISP’s homoiconic nature (code and data share the same representation) made it well-suited to a CAD environment where programs would construct and manipulate geometric descriptions.

The initial implementation was modest but functional. AutoLISP programs could be loaded into AutoCAD and called from the command line. They could call AutoCAD commands programmatically, interact with the user through prompts, and perform arithmetic — enough to build the routine automation tools that the CAD community needed.

Growth Through the Late 1980s and 1990s

AutoLISP grew alongside AutoCAD through successive releases. Each new AutoCAD version extended the AutoLISP function library, adding capabilities for 3D geometry as AutoCAD moved into three dimensions, entity selection sets, and access to the drawing database. By the late 1980s, AutoLISP had become a significant platform in its own right: third-party software vendors sold AutoLISP libraries commercially, and the CAD community shared routines on bulletin board systems.

AutoCAD Release 12 in 1992 introduced the ADS (AutoCAD Development System), a C-language API for more performance-intensive AutoCAD customization. While ADS addressed use cases where AutoLISP’s interpreted performance was insufficient, it required C programming skills and a compiler — a much higher barrier than AutoLISP. For the large majority of CAD customization tasks, AutoLISP remained the tool of choice throughout this period.

The Visual LISP Transition

The most significant evolution in AutoLISP’s history came through Autodesk’s 1997 acquisition of Vital LISP, a more sophisticated LISP environment for AutoCAD developed by Basis Software. Autodesk integrated this technology as Visual LISP, shipping it first as a separate product and then as an integrated component of AutoCAD 2000 in 1999.

Visual LISP brought a full integrated development environment to AutoLISP programming: a dedicated editor with syntax highlighting and code completion, an interactive debugger, an object inspector, and a project manager. Crucially, Visual LISP was backward compatible with existing AutoLISP code — the language semantics did not change, only the development tooling and some extensions improved. This compatibility meant that the large installed base of AutoLISP routines accumulated over thirteen years continued to work without modification.

Visual LISP also added object-oriented extensions that allowed AutoLISP code to interact with AutoCAD’s object model through a more structured interface, and the ability to expose AutoLISP routines as COM objects for integration with other Windows applications.

Modern AutoLISP

AutoLISP has continued to be shipped with every AutoCAD release through the present day. With AutoCAD 2021, Autodesk extended AutoLISP support to AutoCAD for Mac and AutoCAD Web (the browser-based AutoCAD client), marking the first time AutoLISP code could run on platforms other than Windows AutoCAD. This expansion reflected both the continued importance of the AutoLISP ecosystem and Autodesk’s commitment to maintaining compatibility for the large installed base of AutoLISP customization.

AutoCAD 2025 continues to document and support AutoLISP as a first-class customization language, alongside the AutoCAD .NET API and ObjectARX C++ API that serve more complex application development needs.

Design Philosophy

LISP in the CAD Context

AutoLISP’s design is that of a practical LISP dialect shaped by the constraints and needs of the CAD environment in which it lives. It is not a general-purpose LISP in the tradition of Common LISP or Scheme — it is a domain-specific extension of LISP ideas tuned for interactive use inside a drawing application.

The language is dynamically typed: variables are not declared with types, and the type of a value is determined at runtime. This is typical of LISP dialects and makes AutoLISP accessible to users with informal programming backgrounds — the target audience for much AutoLISP work.

Prefix notation (S-expression syntax) is inherited from LISP’s origins. All function calls are written with the function name first, inside parentheses, followed by arguments:

1
2
3

(+ 3 4)          ; returns 7
(* pi 10.0)      ; returns 31.41592...
(strcat "Hello" ", " "World!")  ; returns "Hello, World!"

This syntax is unfamiliar to users coming from languages with infix notation, but it has the advantage of complete uniformity: every operation, including conditionals and loops, is written the same way.

Integration with the AutoCAD Environment

The central design principle of AutoLISP is deep integration with AutoCAD itself. AutoLISP programs can:

• Call any AutoCAD command programmatically via (command ...), exactly as if a user were typing at the command line
• Access and modify drawing entities (lines, circles, arcs, text, blocks) through the entity database
• Read and write entity properties using association lists
• Define new AutoCAD commands that users can invoke by typing the command name
• Prompt users for point picks, distances, text input, and entity selection using AutoCAD’s standard input mechanisms

This integration means that AutoLISP routines feel like extensions of AutoCAD itself rather than external programs. A new command defined in AutoLISP is indistinguishable to the user from a built-in AutoCAD command.

Practical Accessibility

AutoLISP was designed to be accessible to CAD users who are not professional programmers. Functions have descriptive names (getpoint, getdist, getstring, entmake, ssget). The interactive LISP read-eval-print loop allows experimentation: users can type expressions at the AutoCAD command line and immediately see results. Simple routines can be written in minutes by users with minimal programming experience.

Key Features

Defining Custom Commands

The defun function defines new procedures. When defined with the c: prefix convention, a function becomes a new AutoCAD command:

1
2
3
4

; Define a new AutoCAD command called HELLO
(defun c:HELLO ()
  (alert "Hello from AutoLISP!")
)

After loading this definition, typing HELLO at the AutoCAD command prompt triggers the function.

Geometric Computation

AutoLISP provides built-in functions for the geometric operations that appear constantly in CAD work:

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

; Calculate the distance between two points
(setq pt1 '(0.0 0.0 0.0))
(setq pt2 '(3.0 4.0 0.0))
(distance pt1 pt2)    ; returns 5.0

; Find the angle between two points (in radians)
(angle pt1 pt2)       ; returns approximately 0.9273 radians (53.13 degrees)

; Find the midpoint of a line
(setq midpt (list (/ (+ (car pt1) (car pt2)) 2)
                  (/ (+ (cadr pt1) (cadr pt2)) 2)
                  0.0))

The polar function, which computes a point at a given distance and angle from a base point, is one of the most heavily used functions in AutoLISP programming:

1
2
3

; Point 10 units from origin at 45 degrees
(polar '(0.0 0.0 0.0) (/ pi 4) 10.0)
; returns approximately (7.071 7.071 0.0)

User Input Functions

AutoLISP provides a family of functions for prompting the user through AutoCAD’s standard input mechanisms:

1
2
3
4
5

(defun c:DRAWCIRCLE ()
  (setq center (getpoint "\nPick center point: "))
  (setq radius (getdist center "\nEnter radius: "))
  (command "CIRCLE" center radius)
)

The input functions (getpoint, getdist, getangle, getstring, getint, getreal, getkword) integrate with AutoCAD’s rubber-band display, coordinate entry, and object snap systems — the user experience matches that of built-in AutoCAD commands.

Entity Access and Manipulation

AutoLISP can read and modify drawing entities through the entity database:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

; Select an entity and read its properties
(setq ent (car (entsel "\nSelect a circle: ")))
(setq entdata (entget ent))

; Extract the radius from the entity data (group code 40)
(setq radius (cdr (assoc 40 entdata)))

; Modify the radius and update the entity
(setq entdata (subst (cons 40 (* radius 2.0)) (assoc 40 entdata) entdata))
(entmod entdata)

Entity data is returned as an association list of dotted pairs, where the key is a DXF group code (a standard AutoCAD data format) and the value is the property. This design connects AutoLISP entity manipulation to AutoCAD’s underlying DXF file format, making the data model consistent across the application.

Selection Sets

AutoLISP provides ssget for building sets of entities that match criteria, enabling batch operations across many drawing objects:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

; Select all circles on the layer "COLUMNS"
(setq ss (ssget "X" '((0 . "CIRCLE") (8 . "COLUMNS"))))

; Iterate over the selection set
(setq i 0)
(while (< i (sslength ss))
  (setq ent (ssname ss i))
  ; ... process each entity ...
  (setq i (1+ i))
)

The ssget filter system mirrors the selection mechanisms available interactively in AutoCAD, allowing programs to build precisely targeted entity sets.

System Variable Access

AutoLISP can read and write AutoCAD system variables, which control the behavior of the drawing environment:

1
2
3
4
5

; Save current layer, switch to "NOTES", draw text, restore layer
(setq saved-layer (getvar "CLAYER"))
(setvar "CLAYER" "NOTES")
(command "TEXT" pt height 0 "Note text here")
(setvar "CLAYER" saved-layer)

This access to system variables allows AutoLISP routines to temporarily reconfigure the drawing environment, perform operations, and restore the original state — a pattern used extensively in production routines.

File I/O

AutoLISP can read from and write to text files, enabling integration with external data sources:

1
2
3
4
5
6
7

; Read room data from a file and place room labels in the drawing
(setq f (open "rooms.txt" "r"))
(while (setq line (read-line f))
  ; parse line and place text in drawing
  (command "TEXT" (getpoint) 3.0 0 line)
)
(close f)

File I/O is the foundation for data-driven drawing generation: producing drawings from spreadsheet exports, database queries, or survey data files.

Evolution

From AutoLISP to Visual LISP

The transition from the original AutoLISP interpreter to Visual LISP (completed with AutoCAD 2000 in 1999) was architecturally significant but transparent to most users. The AutoLISP language itself did not change: existing routines ran without modification. What changed was the development environment and the availability of extended capabilities.

Visual LISP added:

• A compiled execution path (in addition to interpreted execution) for improved performance
• The vl- function family for accessing AutoCAD’s ActiveX/COM object model
• Object-oriented programming through the vlax- functions for COM object manipulation
• A proper IDE with an interactive debugger — a major improvement over the previous practice of debugging by inserting (alert ...) calls

The vl- functions opened up capabilities that the original AutoLISP functions did not provide, including access to non-graphic drawing data, application-level events, and integration with the Windows COM ecosystem.

Coexistence with Newer APIs

AutoLISP has coexisted with successive generations of AutoCAD APIs:

• ADS (AutoCAD Development System): C-language API introduced in Release 12 (1992) for performance-critical applications
• ObjectARX: C++ API introduced in Release 13 (1995) for deep AutoCAD integration, enabling full custom object types
• AutoCAD .NET API: Managed .NET API introduced in AutoCAD 2000i, providing access to the full object model from C# and VB.NET

These APIs address use cases requiring capabilities beyond AutoLISP — complex custom objects, performance-intensive geometry processing, sophisticated user interface development — but they require significantly more infrastructure and expertise. AutoLISP retains a durable advantage for routine automation tasks: it is interactive, requires no compilation step, and can be written and tested directly within the AutoCAD session.

The VLIDE and Modern Tooling

The Visual LISP IDE (VLIDE), accessed via the AutoCAD VLIDE command, remains the primary development environment for AutoLISP today. It provides syntax highlighting, parenthesis matching, a REPL for interactive evaluation, and a debugger. While it has not received substantial updates in recent years, it is functional for the tasks AutoLISP addresses. Some developers use external editors (VS Code with LISP extensions, Emacs) for editing and paste code into the VLIDE for testing.

Platform Support

AutoLISP runs within AutoCAD, and its platform availability tracks AutoCAD’s:

• Windows: Supported across all versions since 1986; the full Visual LISP environment including the VLIDE is available
• macOS: AutoLISP support was added in AutoCAD 2021 for Mac, according to Autodesk’s official documentation, though the Visual LISP IDE is not available on Mac — routines must be edited externally and loaded into AutoCAD
• Web (AutoCAD Web): AutoLISP support was added in AutoCAD Web as of the AutoCAD 2021 release cycle, per Autodesk documentation, enabling browser-based AutoCAD to run AutoLISP routines

AutoLISP is not available as a standalone language outside of AutoCAD. It cannot be run from a command line, as a web server, or in general-purpose computing contexts. No official Docker image exists for AutoLISP because its execution environment is the AutoCAD application itself.

Community and Ecosystem

The AutoCAD Customization Community

The AutoLISP community is one of the longer-standing programming communities in the CAD world. Major online gathering points include:

• The AutoCAD forums on the Autodesk Community site: The official forum with decades of accumulated AutoLISP questions, answers, and shared routines
• CADTutor: A long-running community site with a dedicated AutoLISP forum and tutorial resources
• The Swamp (theswamp.org): An independent forum specifically focused on AutoCAD customization, with deep AutoLISP expertise

A large archive of AutoLISP routines exists across these communities, covering virtually every common drafting task. Much of this code is freely shared and can be adapted to specific needs.

LISP Files and Loading

AutoLISP code lives in .lsp files. Routines are loaded into AutoCAD using the APPLOAD command (which provides a GUI file picker) or the (load "filename") function at the command line or from another AutoLISP file. AutoCAD also supports automatic loading through acad.lsp (loaded for every drawing) and acaddoc.lsp (loaded for each new drawing document), as well as the LISP Files section of the CUI (Customize User Interface) system.

Compiled Visual LISP files use the .fas extension and load faster than source .lsp files, though the performance difference is rarely significant for routine automation tasks.

AutoLISP vs. Other AutoCAD Customization Options

For users choosing how to automate AutoCAD, the practical tradeoffs are well understood in the community:

AutoLISP occupies the most accessible tier of real programming for AutoCAD: it has the full power of a programming language (conditionals, loops, functions, data structures) while remaining interactive and requiring no external toolchain.

Current Relevance

AutoLISP continues to be actively used in 2025 across the industries that have historically depended on AutoCAD: architecture, civil engineering, mechanical design, electrical engineering, and facilities management. The installed base of AutoLISP customization accumulated over nearly four decades is enormous — many organizations have libraries of routines written in the 1990s or 2000s that continue to run without modification in current AutoCAD versions.

The language’s longevity is a direct consequence of Autodesk’s commitment to backward compatibility. Code written in 1992 typically runs in AutoCAD 2025 without change. This is unusual in the software world and is one reason AutoLISP investments have proven durable.

New AutoLISP development continues, particularly for routine automation tasks where the language’s accessibility and interactive nature make it the practical choice. However, for complex new applications, Autodesk’s own documentation and the community increasingly recommend the AutoCAD .NET API for Windows development, which provides access to the full object model from modern C# or VB.NET.

The 2021 expansion to Mac and Web platforms suggests that Autodesk sees continued value in AutoLISP as a lightweight scripting layer across its product lines, not merely as a legacy compatibility concern.

Why It Matters

AutoLISP holds a significant place in both CAD history and the broader history of domain-specific languages. It was one of the earliest examples of a major commercial software application embedding a real programming language — not a macro recorder, not a simple scripting syntax, but a full dialect of LISP — as its primary extension mechanism. This approach gave AutoCAD users capabilities that most applications would not offer for many more years.

The influence of that decision shaped the CAD industry. AutoCAD’s programmability became a competitive differentiator and encouraged a generation of CAD users to think of customization as a normal part of working with the tool. The community of AutoLISP practitioners that formed around this capability developed skills and practices that informed CAD management and customization culture across the architecture and engineering industries.

For the history of programming languages, AutoLISP is a case study in how a LISP dialect can thrive in a domain where LISP is not intuitively the obvious choice — not because LISP is the best language for geometry, but because its interactive nature, dynamic typing, and uniform syntax made it practical for the specific context of CAD customization by non-specialist programmers. Nearly forty years after its introduction, that context has not fundamentally changed, and neither has the language’s role within it.