AutoLISP

AutoLISP is AutoCAD’s built-in customization language: a Lisp dialect you use to automate drawing tasks and build custom commands inside the CAD session. It is the oldest continuously shipped customization API in the AutoCAD product line.

Purpose

AutoLISP automates AutoCAD, not general computing: it manipulates the live drawing database, asks the user for input, and registers new commands — all in-process, with no external toolchain.

The Problem It Solves

Drafting is repetitive. AutoLISP turns that repetition into a command: create and modify entities, manage layers and blocks, extract data, and build dialogs (DCL). Because it runs inside the drawing, it reads and writes the drawing through the editor’s own API — no files, no servers, no deployment step.

Where It Fits

AutoLISP is the Lisp family’s embedded, domain-specific member: like Emacs Lisp for Emacs, it only exists to customize its host. It runs in AutoCAD and in compatible CADs such as BricsCAD, ZWCAD, and GstarCAD, which makes it the pragmatic automation lingua franca of drafting offices.

History

AutoLISP has outlived every other AutoCAD API and nearly all of its Lisp contemporaries.

Origins (1986)

AutoLISP shipped in 1986 with AutoCAD 2.18, based on XLISP (a small Lisp interpreter by David Betz). It was AutoCAD’s first programmatic interface — a decade before VBA arrived.

Milestones

  • 1994 — DCL (Dialog Control Language) adds native dialog boxes to AutoLISP tools.
  • 2000 — AutoCAD 2000 ships the Visual LISP IDE (VLIDE), a debugger/console, and ActiveX/COM automation (VLA functions).
  • 2010s–2020s — .NET and VBA get promoted, yet AutoLISP remains shipped, documented, and used; third-party CADs keep it for compatibility.

Current Status

Mature and still supported. Autodesk documents it in the current AutoCAD Developer Documentation, and the accumulated public library of .lsp utilities across engineering firms is enormous.

Stage

AutoLISP is finished and stable — and that stability is exactly why it survives.

Maturity

Fully mature. The language has barely changed since the Visual LISP environment standardized it in 2000; existing .lsp code keeps working in current AutoCAD releases.

Governance & Maintenance

Proprietary, owned by Autodesk. Documentation lives in the AutoCAD Developer Documentation; the Visual LISP IDE ships inside AutoCAD. Compatible CAD vendors maintain their own ports.

Popularity & Usability

Invisible in language surveys, unavoidable in CAD-using firms.

Adoption

Used by drafters, CAD managers, and automation engineers worldwide; thousands of public .lsp utilities and forum posts form a huge, searchable knowledge base.

Learning Curve

Approachable for non-programmers: the data model is lists of coordinates and entity data. The two APIs to learn are user input (getpoint, getreal) and the drawing database (entget/entmod); the Visual LISP IDE adds a debugger and console.

Tooling

APPLOAD (load utilities), the Visual LISP IDE, the command line, and in-product help. No external build step, dependency manager, or runtime install.

Use Cases

Any repetitive, rule-driven drafting workflow is a candidate.

Primary Domains

  • Drawing creation and cleanup: generate entities, fix layers, purge and audit en masse.
  • Layer, block, and attribute management across projects.
  • Data extraction and reporting from drawing databases.
  • Custom commands, menus, and pre-BIM data preparation.

Strengths

Direct access to the live drawing, zero installation (built into AutoCAD), quick iteration, and a decades-deep pool of examples.

Weak Spots

Single-vendor language, single-threaded in-product execution, slower for heavy math, and subtle differences between CAD vendors and releases.

Performance

AutoLISP performance is about interactivity, not throughput.

Execution Model

The interpreter runs inside the AutoCAD process; commands via (command ...) round-trip through the editor, and entity access goes through the selection and database APIs. That model suits interactive tools perfectly.

Published Claims

Community consensus: AutoLISP is fast enough for interactive automation; heavy batch processing over huge drawings should move to compiled .NET or preprocessing outside CAD. The practical rule: minimize command round-trips and drive hot loops over entity lists retrieved once.

Example

A complete AutoLISP command that asks the user for two points and draws a line.

hello.lsp

; hello.lsp — a custom AutoCAD command that draws a line
(defun c:HELLO ( / startpt endpt )   ; c: prefix exposes it at the command line
  (setq startpt (getpoint "\nPick start point: "))  ; ask the user
  (setq endpt   (getpoint startpt "\nPick end point: "))
  (command "_.LINE" startpt endpt "")               ; run the LINE command
  (princ "\nLine drawn by AutoLISP!")
  (princ))                                          ; quiet return value

How to Run

  1. In AutoCAD: type APPLOAD, pick hello.lsp, and click Load (or drag the file into the drawing).
  2. Type HELLO at the command line; click two points.
  3. From the Visual LISP console you can instead evaluate (load "hello.lsp").

The c: prefix and the empty quote argument ("" to end the LINE command) are the two AutoLISP idioms beginners meet first.

Learn More

Official sources and free materials; the full categorized catalog is on the References & Downloads page.

Official Docs & Downloads

Learning Material