CADXChange

All LISP commands

CXBLKRENBlocks and attributesVersion 1.0.0Tested in AutoCAD

Rename blocks in bulk

Renames many block definitions at once: find and replace in the name, add a prefix or suffix, limited to names that match a wildcard.

Download cxblkren.lspLISP terms

How to use it

  1. Type CXBLKREN. The block names in the drawing are listed.
  2. Enter a wildcard for the blocks to rename, such as OLD_*.
  3. Give the text to find and replace, and any prefix or suffix.

Good to know

  • Names that are already taken or not allowed are skipped and counted in the report.

Load it in AutoCAD

  1. Save the file anywhere you like.
  2. Type APPLOAD, pick the file and choose Load.
  3. Type the command name: CXBLKREN.

To have it at every start, add it to the Startup Suite in the same dialog, or load a whole folder at once with the optional loader. About the optional loader

Tested in AutoCAD (full version). Other programs that run AutoLISP may work, but they are not tested.

The code

Plain text, nothing hidden. Copy it into a file named cxblkren.lsp, or download it.

;;; ============================================================================
;;; CXBLKREN - Rename blocks in bulk
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxblkren
;;; Tested in: AutoCAD (full version). Other programs that run AutoLISP may work but are not tested.
;;; Copyright (c) CADXChange. Free for personal and commercial use; do not resell or
;;; republish it as a collection. Terms: https://cadxchange.net/legal/lisp-terms
;;; ============================================================================

;; Rename block definitions whose name matches PATTERN (wildcards, any case). The new name is
;; PREFIX + the old name with FIND replaced by REPL (FIND "" changes nothing) + SUFFIX.
;; A name that already exists, or that holds a character a block name cannot have, is skipped.
;; Returns ((old . new) ...) for the renamed blocks and the number of skipped ones: (renamed skipped).
(defun cx:blkren-run (pattern find repl prefix suffix / done skipped new bad)
  (setq skipped 0)
  (foreach name (cx:block-names)
    (if (wcmatch (strcase name) (strcase pattern))
      (progn
        (setq new (strcat prefix (if (/= find "") (cx:replace-ci name find repl) name) suffix)
              bad nil)
        (foreach ch '("<" ">" "/" "\\" "\"" ":" ";" "?" "*" "|" "," "=" "`")
          (if (cx:find new ch 1) (setq bad T)))
        (cond
          ((= new name) nil)
          ((or bad (= new "") (and (tblsearch "BLOCK" new) (/= (strcase new) (strcase name))))
           (setq skipped (1+ skipped)))
          (T
           (command "_.-RENAME" "_Block" name new)
           (setq done (cons (cons name new) done)))))))
  (list (reverse done) skipped))

(defun c:CXBLKREN ( / *error* cx:sv pattern find repl prefix suffix r)
  (setq *error* cx:err)
  (princ (strcat "\nBlocks in this drawing: " (cx:join (cx:block-names) ", ")))
  (setq pattern (cx:ask-str "Rename the blocks named (wildcards allowed)" "*")
        find    (cx:ask-str "Find in the name (- for nothing)" "")
        repl    (if (/= find "") (cx:ask-str "Replace with (- for nothing)" "") "")
        prefix  (cx:ask-str "Add in front (- for nothing)" "")
        suffix  (cx:ask-str "Add at the end (- for nothing)" ""))
  (cx:start '(("CMDECHO" . 0)))
  (setq r (cx:blkren-run pattern find repl prefix suffix))
  (foreach p (car r) (princ (strcat "\n" (car p) " -> " (cdr p))))
  (princ (strcat "\n" (itoa (length (car r))) " block(s) renamed"
                 (if (> (cadr r) 0) (strcat ", " (itoa (cadr r)) " skipped (name taken or not allowed)") "") "."))
  (cx:end)
  (princ))


;;; ---- Shared helpers (used by the command above; identical in every CADXChange tool) ----

;; 1-based position of SUB in STR at or after START, or nil.
(defun cx:find (str sub start / n i r)
  (setq n (strlen sub) i start r nil)
  (if (> n 0)
    (while (and (not r) (<= i (1+ (- (strlen str) n))))
      (if (= (substr str i n) sub) (setq r i))
      (setq i (1+ i))))
  r)

(defun cx:dxf (code ed)
  (cdr (assoc code ed)))

;; The names of the block definitions that can be inserted (no anonymous or xref blocks).
(defun cx:block-names (/ r out)
  (setq r (tblnext "BLOCK" T))
  (while r
    (if (and (/= (substr (cx:dxf 2 r) 1 1) "*") (not (cx:find (cx:dxf 2 r) "|" 1)))
      (setq out (cons (cx:dxf 2 r) out)))
    (setq r (tblnext "BLOCK")))
  (reverse out))

;;; Helpers that draw small things: labels and markers. See helpers.lsp for the format.

;; Replace every OLD in STR by NEW, ignoring case.
(defun cx:replace-ci (str old new / n out pos up uo)
  (setq n (strlen old) out "" pos 1 up (strcase str) uo (strcase old))
  (if (= n 0)
    str
    (progn
      (while (<= pos (1+ (- (strlen str) n)))
        (if (= (substr up pos n) uo)
          (setq out (strcat out new) pos (+ pos n))
          (setq out (strcat out (substr str pos 1)) pos (1+ pos))))
      (strcat out (substr str pos)))))

;; Close the undo step and put the system variables back.
(defun cx:end ()
  (foreach v cx:sv (setvar (car v) (cdr v)))
  (command "_.UNDO" "_End")
  (setq cx:sv nil)
  (princ))

;; Error handler: restores everything, stays quiet on Esc.
(defun cx:err (msg)
  (if (> (getvar "CMDACTIVE") 0) (command))
  (cx:end)
  (if (and msg (not (wcmatch (strcase msg) "*BREAK*,*CANCEL*,*EXIT*")))
    (princ (strcat "\nError: " msg)))
  (princ))

(defun cx:join (lst delim / out)
  (setq out "")
  (foreach s lst
    (setq out (if (= out "") s (strcat out delim s))))
  (if lst out ""))

;; Ask for a string (spaces allowed) with a default; "-" means an empty string.
(defun cx:ask-str (msg def / v)
  (setq v (getstring T (strcat "\n" msg " <" def ">: ")))
  (cond ((= v "") def) ((= v "-") "") (T v)))

;; Save the system variables in VARS ((name . value) ...), set them, and open one undo step.
;; The caller declares cx:sv as a local so the saved values live exactly as long as the command.
(defun cx:start (vars)
  (setq cx:sv (mapcar (function (lambda (v) (cons (car v) (getvar (car v))))) vars))
  (command "_.UNDO" "_Begin")
  (foreach v vars (setvar (car v) (cdr v)))
  (princ))

(princ "\nCXBLKREN loaded. Type CXBLKREN to start.")
(princ)

Version history

Version 1.0.0 · October 27, 2026

First release.

Need this across many drawings?

BlockCopy does this kind of job on a whole folder of drawings in one run.

BlockCopy

More commands: Blocks and attributes