Save 15% On All Single Licences! Loading... GET OFFER

BricsCAD LISP Migration Guide

Migrating an established AutoCAD-style LISP set into BricsCAD is rarely about whether it runs. It is about when, where, and how it loads, and how you package it for repeatable rollout across teams, offices, and versions. This BricsCAD LISP migration guide covers startup files, compatibility, and best practices for CAD managers who need clear load order, clean search paths, secure loading, and fewer it works on my machine surprises.

If your current setup uses a Startup Suite, many support paths, network toolsets, and a mix of AutoLISP and Visual LISP, you can migrate well. The key is to treat BricsCAD startup LISP as part of the environment, not as a pile of loose .lsp files.

1. Pre-migration inventory: treat LISP like a managed product

Before you migrate LISP to BricsCAD, capture what you have now:

  • Entry points – what starts the code:
    • Startup Suite entries
    • acaddoc.lsp, acad.lsp, .mnl, .cui(x) partials
    • VBA/ARX/.NET shims that call LISP through (command) or (vl-load-com)
  • Dependencies:
    • DCL dialogs, .pat, .lin, .ctb / .stb, tool palettes, custom fonts, scripts, reactors
    • External files: spreadsheets, JSON or INI config, licence checks, web calls
  • APIs used:
    • pure AutoLISP vs Visual LISP COM calls
    • vlax-*, vla-*, ActiveX/COM automation
    • hard-coded AutoCAD paths, registry keys, or old install path assumptions

This inventory becomes your check list. It also helps you spot where autolisp bricscad compatibility issues are most likely to appear.

2. AutoCAD environment file types: what you may be moving

Companies often miss how many AutoCAD environment file types are involved in a LISP deployment. A successful move knows that LISP is only one part of the stack.

Common file types you may have today:

  • LISP and related: .lsp / .fas / .vlx – AutoLISP source plus AutoCAD’s compiled and encrypted packages. BricsCAD loads .lsp files but cannot load .fas or .vlx files at all, so any of these must be rebuilt from their original .lsp sources before migration. BricsCAD’s equivalent is the DES format, produced by the DEScoder.exe utility installed with BricsCAD, which also reads VLX-compatible .prv and .prj project files so a single project definition can build a .vlx for AutoCAD and a .des for BricsCAD. Note that DES is encryption rather than compilation, so unlike VLX it gives no execution speed benefit over plain .lsp.
  • .dcl – Dialog Control Language files used by new_dialog.
  • .mnl – Menu LISP files that load with .mnu or .cuix menus. This is often where hidden startup code lives.
  • UI and workflow.cuix – custom UI definitions for menus, ribbons, toolbars, and partial CUI files.
  • .arg / profiles – profile exports for search paths and system variables, often used to set standards. BricsCAD uses the same .arg extension, but profiles exported from other CAD software will not import correctly. A new BricsCAD profile has to be built from your documented paths and settings, then exported and shared using the ProfileManager command.
  • .scr – scripts for command automation and bootstrapping installs.
  • CAD standards and config.ctb / .stb – plot style tables.
  • .pc3 / .pmp – plotter config and paper sizes.
  • .lin / .pat – linetype and hatch patterns that many routines reference.
  • .shx / .ttf – fonts that affect text, width, and plotting.
  • Blocks and templates.dwg – blocks, title blocks, and libraries.
  • .dwt – templates that can trigger standards and layers your LISP expects.
  • .dws – standards files used by CAD checks.

Recognising these file types helps you move custom commands to BricsCAD without chasing missing resource errors that look like LISP faults but are not.

3. Understanding BricsCAD’s LISP runtime and compatibility

3.1 AutoLISP BricsCAD compatibility: what usually works

BricsCAD LISP support is strong for normal production automation:

  • core AutoLISP functions
  • (command) and (command-s) style automation
  • symbol tables, entities, DXF access, and selection sets
  • DCL dialogs, as long as paths are correct
  • Visual LISP: the vl-, vlax- and vlr- function families are supported, and BricsCAD’s Fast-COM layer provides the COM based vla- functions on Windows, Linux and macOS. The gaps are by platform rather than by licence edition, since not every vla- property and method is implemented on Linux and macOS.

For most teams, most routines will run after you fix load order, paths, and dependencies.

3.2 BricsCAD AutoLISP compatibility: where to test first

The friction points usually fall into these buckets:

  • ActiveX/COM – object names, properties, or interfaces may differ
  • Command differences – some prompts or options are not the same
  • File system and security – unreachable network locations, files that are not on the support file search path held in SRCHPATH, and name or case mismatches between the loader and the file it calls
  • UI hook differences – menu loading, ribbon or tool palette links, and tuning plans

Treat autolisp bricscad compatibility as a test programme, not a guess.

3.3 Visual LISP support in BricsCAD

If you rely on Visual LISP features, especially COM automation, validate them early. Many corporate toolsets depend on (vl-load-com) and vla-* calls for layer work, xrefs, plotting, title block attributes, and more. Plan a COM-heavy pilot set first.

4. Startup strategy in BricsCAD: stable loading, not guesswork

A reliable migration needs a disciplined BricsCAD startup LISP plan. You want:

  • one small bootstrap file that is easy to deploy and version
  • clear rules for machine settings vs user settings
  • clear rules for document-specific loading

4.1 The two key startup hooks: ON_START.LSP and ON_DOC_LOAD.LSP

BricsCAD gives you two startup hooks that map well to enterprise deployment:

  • ON_START.LSP – loads once at BricsCAD startup, for the first drawing only, unless the ACADLSPASDOC system variable is set to 1, in which case it also loads for every new drawing. Because LISP symbols are bound to a document, functions and C: commands defined here will not exist in drawings opened later while

ACADLSPASDOC is 0. Use it for:

  • search paths, where needed
  • setup that genuinely only needs to happen once per session
  • global flags, published across documents with (vl-propagate), since an ordinary global lives only in the drawing that created it
  • setting (setvar “ACADLSPASDOC” 1) if you want the on_start files to run per drawing
  • ON_DOC_LOAD.LSP – runs when a drawing opens. Use it for:
    • reactors that depend on a document
    • modules that load on demand
    • standards checks
    • drawing variables that must be right for each file

Use ON_DOC_LOAD.LSP as the primary loader for libraries and command definitions, because it loads unconditionally for every drawing opened or created, independently of ACADLSPASDOC. Octaves’ own customisation guidance states that on_doc_load.lsp is the better of the two for launching your programs. Reserve ON_START.LSP for the small amount of work that only needs to happen once per session, and set ACADLSPASDOC to 1 if you want the on_start files to run per drawing as well.

Make sure your rollout notes cover both files, plus naming and case rules, so helpdesk staff can diagnose issues fast. Note also that BricsCAD ships two reserved files of its own, on_start_default.lsp and on_doc_load_default.lsp, which load before your equivalents. Octave advises against editing them, because the user file manager can replace them with newer copies from the installation’s UserDataCache folder after an update. Always put your own code in on_start.lsp and on_doc_load.lsp.

5. Where to put LISP files in BricsCAD

The real question is how to keep file locations stable, supportable, and findable. BricsCAD locates startup and support files through the support file search path held in the SRCHPATH system variable, whose default first entry on Windows is C:\Users%username%\AppData\Roaming\Bricsys\BricsCAD\V26x64\en_US\Support, reachable with the SUPPORTFOLDER command. The startup files do not have to live in that folder. They only need to be found somewhere along that path, which you can confirm in one line with (findfile “on_doc_load.lsp”).

A practical enterprise layout looks like this:

  • Read-only main libraryone central library on a managed share
  • versioned folders if you need them, such as v25 and v26
  • no user writes
  • Local cacheoptional
  • deployed by IT tools
  • useful for offline work and speed
  • User overridesminimal
  • only for personal tools, not standards

Recommended code layout:

  • /bootstrap – tiny loader files only
  • /lib – shared helpers for strings, math, geometry, and errors
  • /apps – business modules for plotting, title blocks, QA, and layer tools
  • /ui – DCL, icons, and tool palette assets
  • /config – INI or JSON settings and version flags
  • /tests – regression scripts and sample DWGs

This layout makes it easier to troubleshoot fix LISP not loading BricsCAD cases because you can see whether the bootstrap failed, the library failed, or one module failed.

6. How to load LISP automatically in BricsCAD

There are several ways to load LISP automatically in BricsCAD. In corporate settings, prefer stable methods over ad-hoc ones.

Option A: Use ON_START.LSP as one bootstrap

Your ON_START.LSP should do the minimum:

  • set a session flag and publish it with (vl-propagate) so it survives into other documents, since a plain global does not
  • add support paths if your setup needs them
  • set ACADLSPASDOC to 1 if you want on_start.lsp to run for every drawing
  • log startup details, including version, paths, and loaded modules
  • Load the versioned core file, such as company_core.lsp, from ON_DOC_LOAD.LSP rather than here, so that its functions and C: command definitions exist in every drawing and not only the first.

Option B: Use ON_DOC_LOAD.LSP for drawing-dependent modules

Keep document setup separate so you avoid slow startup and no-active-document errors.

Option C: Use APPLOAD’s AutoLoad list with discipline

BricsCAD has no Startup Suite. The equivalent is the AutoLoad column in the APPLOAD dialog, backed by an appload.dfs text file and per-user, per-profile registry entries under HKEY_CURRENT_USER. Keep the list limited to bootstrap files, not dozens of modules. Load order is not random: the dialog’s Up and Down arrows set the sequence, and LISP files are always loaded after BRX, .NET and VBA modules, because those load globally and often define interface functions for LISP. Because appload.dfs is located through the normal support path search, putting one copy in the first support folder lets a single file serve all users and profiles. Too many entries still:

  • slow startup
  • make dependency order harder to reason about
  • make support painful

Option D: Manual loading for tests and exceptions

You still need an escape hatch for support work:

  • use APPLOAD to load one file at a time
  • watch for dependency errors
  • look for missing DCL files
  • look for blocked paths

A good migration plan uses A and B in production, C only when needed, and D for support. Be aware that BricsCAD documents three further automatic loading mechanisms you will meet in third party products. Menu LISP: a same-named .mnl file in the folder of a loaded menu is loaded for each drawing. Registry based DemandLoad: keys under Software\Bricsys\BricsCAD\version\language\Applications load a LISP file either for every drawing (LoadCtrls 2) or on invocation of a declared command (LoadCtrls 4). Plug-in bundles: from V26.2, .bundle packages containing BRX, .NET or LISP content are parsed from a manifest by the bundle loader, controlled by the APPAUTOLOAD system variable and the APPAUTOLOADER command.

7. A robust ON_START.LSP pattern

This is a pattern, not a copy-paste universal answer. Adjust it to your standards and security model.

Key rules:

  • keep the bootstrap tiny
  • centralise config
  • fail cleanly
  • log useful errors

Good startup logic should:

  • find the company library root, for which BricsCAD provides (vl-list-loaded-lisp), a function that returns every loaded LISP file with its full path, so your code can locate a known marker file, derive its own home folder at runtime, and stop depending on SRCHPATH altogether
  • guard every load with (findfile) before calling (load), so a laptop off the network fails quietly rather than throwing an error
  • add required support paths only if they are missing
  • load one core package
  • print a short banner to the command line for support tracking

Also think about:

  • version gating – detect the host product and version from (getvar “ACADVER”), whose returned string contains BRICSCAD under BricsCAD and LMS TECH under AutoCAD, then load the right modules. This is also the standard way to keep one codebase running on both platforms during a parallel rollout.
  • module registry – keep one approved list of modules, with checksums or signed packages where you can

These are basic best practices for LISP deployment in managed CAD environments.

8. Secure loading LISP in BricsCAD

Deployment hygiene is where many LISP migrations fail. The code is not always wrong. More often the loader never ran, or the file was not on the support file search path when BricsCAD looked for it. BricsCAD’s documented loading mechanisms are path based rather than trust based, and no equivalent of AutoCAD’s SECURELOAD and trusted paths model is described in the current BricsCAD help. Treat trusted location as an organisational policy you enforce through share permissions and a release process, not as a product feature that will block a findable file from loading.

In a corporate rollout:

  • prefer read-only central libraries
  • avoid loading from:
    • user downloads
    • temp folders
    • emailed ZIP files
    • random shared drives
  • create:
    • one approved CAD content share
    • one release process
    • one rollback plan

If users say routines do nothing, or load on and off, treat it as a security or path issue first. Most fix LISP not loading BricsCAD cases come down to:

  • the file is not on the support path, which (findfile “yourfile.lsp”) confirms in seconds
  • the loader itself is not running, because on_doc_load.lsp cannot be found
  • the code sits in on_start.lsp while ACADLSPASDOC is 0, so it loaded only for the first drawing of the session
  • a needed file, such as DCL, icons, or config, cannot be found

9. Compatibility and code changes

When you migrate AutoCAD LISP to BricsCAD, work through these items in order.

9.1 Hard-coded paths and environment assumptions

Search for:

  • absolute drive letters
  • vendor install paths
  • registry reads tied to AutoCAD keys
  • assumptions about CUI location

Replace them with:

  • relative paths from a known root
  • config-driven paths
  • environment variables your IT team can manage

9.2 Command automation

If you use (command) a lot:

  • test prompts and options
  • always use the English command and option names, prefixed with an underscore, because Octave documents this as necessary to avoid failures on localised, non-English BricsCAD builds, and use the dash prefixed forms such as -LAYER and -PURGE to suppress dialog boxes in unattended code
  • prefer clear values over press Enter guesses

9.3 Reactors and document lifecycle

If your routines attach reactors on load:

  • move document logic into ON_DOC_LOAD.LSP
  • avoid duplicate reactors on every open
  • add safe guards for MDI setups

9.4 COM and Visual LISP calls

For Visual LISP support in BricsCAD, test:

  • object creation
  • property names
  • method availability
  • plot and layout behaviour

When behavior differs, isolate a small repeatable script before you refactor the whole toolset.

10. BricsCAD vs AutoCAD LISP differences that matter in practice

From a CAD management view, the biggest differences are practical rather than syntactic:

  • Startup hooks – on_start.lsp and on_doc_load.lsp are direct one for one equivalents of acad.lsp and acaddoc.lsp, so this part of the move is a rename rather than a redesign. What changes is the discipline around it: you must understand the per drawing loading rules and the ACADLSPASDOC switch before deciding what goes in which file.
  • Deployment – you will likely standardise support paths and secure locations in a different way
  • UI plumbing – menu LISP itself behaves the same way, since BricsCAD loads a same-named .mnl file from the menu’s own folder whenever that menu is attached. The mismatch is in the menus, because only partial CUI and CUIX files can be migrated from AutoCAD and not the main customisation file, so LISP hanging off a main menu will need rehoming into the startup hooks.
  • Troubleshooting workflow – support staff should confirm startup files, then paths, then dependencies, then code

Thinking about these as process changes makes migration smoother than chasing one code edit after another.

11. Troubleshooting playbook: when routines do not load or VLIDE causes friction

11.1 Fix LISP not loading BricsCAD

Use this order:

  1. Confirm the bootstrap is running
    • Does ON_START.LSP print a short banner or write a log line?
  2. Confirm the file paths
    • Is the library location reachable?
    • Are support paths set as expected?
  3. Confirm dependencies
    • Is the DCL file found?
    • Are config files present?
  4. Confirm security and trust
    • Are you loading from approved locations only?
  5. Confirm module order
    • Do shared libraries load before apps?

If you log early, most not-loading tickets become 5-minute fixes.

11.2 Editing and debugging: VLIDE and BLADE in BricsCAD

There is no separate Visual LISP IDE in BricsCAD. The VLIDE command opens BLADE, the BricsCAD LISP Advanced Development Environment, so existing macros and documentation that call VLIDE still work. BLADE runs on Windows, Linux and macOS and provides editing, project handling, breakpoints, an inspector, a syntax and variables check, and an integrated profiler. If code behaves differently under the debugger than in production:

  • load and test through APPLOAD
  • test the same code from the command line
  • keep structured logging inside the code itself, so production never depends on the IDE being present

Keep the IDE for development if it fits your process, but do not make production depend on it being identical across tools.

12. Packaging and rollout

A migration succeeds when you can deploy it the same way every time.

A strong rollout plan has:

  • one bootstrap pair for each environment – on_start.lsp for session scoped setup, on_doc_load.lsp for the per drawing load
  • one config file – controls:
    • library root
    • enabled modules
    • feature flags
    • version map
  • one release artifact – a zipped library with a manifest, or a managed installer
  • one regression suite – small DWGs and scripts that cover key workflows

For CAD managers, this is the difference between we migrated once and we can maintain it for years.

13. Practical examples: what good looks like

After you migrate LISP to BricsCAD, good results usually look like this:

  • users launch BricsCAD and see core commands within seconds
  • drawing tools run only when a DWG opens
  • support can check:
    • whether ON_START.LSP ran
    • which library version loaded
    • whether the module manifest passed
  • teams can add new tools without editing five different loaders

That is the mindset behind LISP routines for BricsCAD setup as a managed system, not as a pile of files.

Conclusion: the shortest route to a stable BricsCAD LISP estate

A successful BricsCAD LISP migration guide comes down to three priorities:

  1. Stable startup using ON_START.LSP and ON_DOC_LOAD.LSP rather than scattered loaders.
  2. Compatibility by design, with dependencies, COM-heavy routines, and command automation tested early.
  3. Enterprise-grade deployment, with versioned libraries, logging, and secure loading rules.

Do that well and migrate AutoCAD LISP to BricsCAD stops being a risky one-off project. It becomes a stable platform upgrade without giving up custom workflows or the gains your custom commands deliver.

Frequently Asked Questions

Question: Where should I put ON_START.LSP and ON_DOC_LOAD.LSP, and what should go in each?

Short answer: Put ON_START.LSP in a path BricsCAD searches at launch, such as a central read-only support path or a managed local cache on the support path. Use it only for once per session work: set or check support paths, set globals and publish them with (vl-propagate), and log events. Load your core file from ON_DOC_LOAD.LSP instead, because on_start.lsp runs only for the first drawing unless ACADLSPASDOC is set to 1. Put ON_DOC_LOAD.LSP in the same managed library. It runs when a drawing opens and should handle document-scoped tasks such as reactors, on-demand modules, and per-drawing variables or standards.

Question: Our AutoCAD setup uses acad.lsp, acaddoc.lsp, and .mnl loaders. How do these map to BricsCAD?

Short answer: The mapping is a straight rename. acad.lsp becomes on_start.lsp, acaddoc.lsp becomes on_doc_load.lsp, and BricsCAD does not read the AutoCAD file names. Put the bulk of your loading in ON_DOC_LOAD.LSP, which runs for every drawing, and keep ON_START.LSP for once per session work, remembering it runs only for the first drawing unless ACADLSPASDOC is 1. Menu LISP works as it does in AutoCAD, since a .mnl file beside a loaded menu of the same name is loaded for each drawing, so keep it small and use it only to bootstrap your standard loaders. That gives you predictable order and easier support.

Question: What are the most common reasons my LISP does not load after migration, and how do I triage fast?

Short answer: Most failures are environmental, not code related. The bootstrap did not run, the library path is not on the support path, the code was placed in on_start.lsp while ACADLSPASDOC was 0 so it only loaded for the first drawing, or a needed resource was not found. Triage in this order: 1) confirm your loader runs with a banner or log, 2) run (findfile “on_doc_load.lsp”) and (findfile “yourfile.lsp”) to verify the support paths and network access, 3) run (vl-list-loaded-lisp) to see exactly which LISP files loaded and from which folders, 4) check that dependencies such as DCL and config files exist, 5) ensure shared libraries load before app modules. Use APPLOAD for targeted checks.

Question: How should we structure and deploy our LISP library for multiple offices and BricsCAD versions?

Short answer: Use one read-only central library with optional versioned subfolders, plus a managed local cache if you need speed or offline use. Keep a tiny /bootstrap, shared /lib helpers, business /apps, /ui assets, /config files, and /tests. Drive everything from one bootstrap file and one config file that maps BricsCAD versions to the right library. Package each release as one artifact with a manifest, and include a small regression suite to check updates.

Question: What should we test first if our toolset relies heavily on Visual LISP and COM?

Short answer: Run a COM-heavy pilot early. BricsCAD implements the vla-, vlax- and vlr- families through its own Fast-COM layer, which also makes them available on Linux and macOS, although not every vla- property and method is implemented on those platforms. Validate object creation, property and method names, plot and layout behavior, and any ActiveX differences, use (vlax-get-acad-object) rather than a product specific application ProgID, and consider the non-COM property functions (getPropertyValue), (setPropertyValue), (isPropertyValid), (isPropertyReadonly) and (dumpAllProperties), supported since V21, which behave consistently across all three platforms. Focus on high-value workflows such as layers, xrefs, plotting, and title block attribute automation. When behavior differs, isolate a minimal repeatable script before you refactor. Keep command automation strong by testing prompts and options and by avoiding locale-based inputs. If needed, gate features by BricsCAD major version through your bootstrap and config.

Powered by Full Pelt Ltd