business

Verdict

Submitted 9/12/2026, 12:05:54 PM · Completed 9/12/2026, 12:14:21 PM

5.0
pivot
The idea

How to make the following Autolisp program support Chinese input?

Pain point
The user needs to replace text characters in AutoCAD but cannot directly input Chinese characters.
Who has this problem
AutoCAD users who need to edit text entities containing non-Latin scripts, such as Chinese.
Contradiction (TRIZ)
wants to efficiently edit text but is constrained by the inability to directly enter certain character sets
Ideal final result
Users can directly input any character set, including Chinese, without losing functionality or efficiency in editing text entities.
Suggested solution
Implement a feature that allows direct input of non-Latin scripts such as Chinese within the AutoLISP code. This could be achieved by integrating a Unicode input method editor (IME) into the AutoCAD environment, enabling users to seamlessly type in any character set while maintaining the program's performance and functionality.
Show original source text →
This AutoLISP code defines an AutoCAD command that provides an interactive in-place text character replacement tool for a single-line TEXT entity. Its purpose is to let the user select an existing TEXT object, move the mouse along the text to highlight a range of characters, type replacement text, and then replace the highlighted characters with the typed input. Howerver it cannot directly input Chinese, anyone can fix this problem? ht:chars Purpose: Split a string into a list of character tokens. Handles multi-byte (non-ASCII, e.g. CJK) characters by grouping a lead byte with its trailing byte into a single 2-byte token. Arguments: s - input string Returns: list of single- or double-byte character substrings, in order (defun ht:chars (s / l i n c a) (setq l '() i 1 n (strlen s)) (while (<= i n) (setq c (substr s i 1) a (ascii c)) (if (and a (> a 127) (< i n)) (setq l (cons (substr s i 2) l) i (+ i 2)) (setq l (cons c l) i (1+ i)))) (reverse l)) ht:bbox Purpose: Compute the text bounding box of a string by temporarily creating a TEXT entity, querying (textbox), then deleting it. Arguments: s - text content hgt - text height wf - width factor sty - text style name obl - oblique angle (radians) or nil Returns: ((minX minY minZ) (maxX maxY maxZ)) ; fallback zeros on failure (defun ht:bbox (s hgt wf sty obl / e tb fallback) (setq fallback (list (list 0.0 0.0 0.0) (list 0.0 0.0 0.0))) (if (or (null s) (= s "")) fallback (progn (setq e (entmakex (append (list '(0 . "TEXT") '(100 . "AcDbEntity") '(100 . "AcDbText") '(10 0.0 0.0 0.0) (cons 40 hgt) (cons 1 s) (cons 41 wf) (cons 7 sty) '(72 . 0) '(73 . 0)) (if obl (list (cons 51 obl)) nil) (list (cons 11 '(0.0 0.0 0.0)))))) (if e (progn (setq tb (textbox (entget e))) (entdel e) (if (and tb (listp tb) (listp (car tb)) (listp (cadr tb))) tb fallback)) fallback)))) ;; ht:wid ;; Purpose: Return the total rendered width of a string. ;; Arguments: s hgt wf sty obl - see ht:bbox ;; Returns: real (width) ; 0.0 if measurement fails (defun ht:wid (s hgt wf sty obl) (car (cadr (ht:bbox s hgt wf sty obl)))) ;; ht:layout ;; Purpose: Build a layout table for each character token in `chars`, ;; giving the start/end X offsets within the full rendered string. ;; Uses incremental prefix widths so kerning/lead-bearing of the ;; first glyph is taken into account. ;; Arguments: chars - list of character tokens (from ht:chars) ;; hgt wf sty obl - text properties ;; Returns: list of (token startX endX) tuples, in order (defun ht:layout (chars hgt wf sty obl / prefix out result n i x0 x1 totalw) (setq prefix "" out '()) (foreach ch chars (setq out (cons (list ch (- (ht:wid (strcat prefix ch) hgt wf sty obl) (ht:wid ch hgt wf sty obl))) out)) (setq prefix (strcat prefix ch))) (setq out (reverse out) totalw (ht:wid prefix hgt wf sty obl) n (length out) i 0 result '()) (while (< i n) (setq x0 (cadr (nth i out)) x1 (if (< i (1- n)) (cadr (nth (1+ i) out)) totalw)) (setq result (cons (list (car (nth i out)) x0 x1) result)) (setq i (1+ i))) (reverse result)) ;; ht:origin ;; Purpose: Compute the baseline insertion point of a TEXT entity so that, ;; when re-creating the text with the same alignment/justification, ;; it occupies exactly the same position on screen. ;; Accounts for justification (72/73), rotation, and (11) point. ;; Arguments: ed - entity data list of a TEXT entity ;; Returns: (x y) baseline origin point (defun ht:origin (ed / g72 g73 rot x y cx cy tb mnx mxx mny mxy hgt) (setq g72 (cond ((cdr (assoc 72 ed))) (t 0)) g73 (cond ((cdr (assoc 73 ed))) (t 0)) rot (cond ((cdr (assoc 50 ed))) (t 0.0)) hgt (cdr (assoc 40 ed))) (if (and (= g72 0) (= g73 0)) (setq x (car (cdr (assoc 10 ed))) y (cadr (cdr (assoc 10 ed)))) (setq x (car (cdr (assoc 11 ed))) y (cadr (cdr (assoc 11 ed))))) (setq tb (ht:bbox (cdr (assoc 1 ed)) hgt (cdr (assoc 41 ed)) (cdr (assoc 7 ed)) (cdr (assoc 51 ed))) mnx (car (car tb)) mxx (car (cadr tb)) mny (cadr (car tb)) mxy (cadr (cadr tb))) (setq cx (cond ((= g72 1) (/ (+ mnx mxx) 2.0)) ((= g72 2) mxx) ((= g72 3) 0.0) ((= g72 4) (/ (+ mnx mxx) 2.0)) ((= g72 5) mnx) (t mnx)) cy (cond ((= g73 1) mny) ((= g73 2) (/ hgt 2.0)) ((= g73 3) hgt) (t 0.0))) (list (- x (- (* cx (cos rot)) (* cy (sin rot)))) (- y (+ (* cx (sin rot)) (* cy (cos rot)))))) ;; ht:proj ;; Purpose: Project a point onto the axis defined by `base` + direction `ang`. ;; Used to convert a mouse pick point into a 1D coordinate along the ;; text's baseline direction. ;; Arguments: pt - point to project ;; base - axis origin ;; ang - axis angle (radians) ;; Returns: real (scalar distance along the axis) (defun ht:proj (pt base ang) (+ (* (- (car pt) (car base)) (cos ang)) (* (- (cadr pt) (cadr base)) (sin ang)))) ;; ht:paint ;; Purpose: Create temporary red-colored TEXT entities for the characters ;; whose layout ranges overlap the range [from, to] along the ;; baseline. Used as live visual highlight feedback. ;; Arguments: layout - layout table from ht:layout ;; base ang hgt wf lay sty obl - text properties & layer ;; from to - 1D overlap range along the baseline axis ;; Returns: list of created highlight entity names (defun ht:paint (layout base ang hgt wf lay sty obl from to / out p) (setq out '()) (foreach item layout (if (and (< (nth 1 item) to) (> (nth 2 item) from)) (progn (setq p (list (+ (car base) (* (nth 1 item) (cos ang))) (+ (cadr base) (* (nth 1 item) (sin ang))) 0.0)) (entmake (append (list '(0 . "TEXT") '(100 . "AcDbEntity") (cons 8 lay) '(100 . "AcDbText") (cons 10 p) (cons 40 hgt) (cons 1 (car item)) (cons 50 ang) (cons 41 wf) (cons 7 sty) (cons 62 1) '(72 . 0) '(73 . 0)) (if obl (list (cons 51 obl)) nil) (list (cons 11 p)))) (setq out (cons (entlast) out))))) out) ;; ht:clear ;; Purpose: Delete all entities in the given list (if still present). ;; Used to erase temporary highlight entities. ;; Arguments: lst - list of entity names ;; Returns: nil (defun ht:clear (lst) (if (listp lst) (foreach e lst (if (entget e) (entdel e))))) ;; ht:run ;; Purpose: Main interactive driver. Selects a TEXT entity, then in a ;; grread loop lets the user drag the mouse along the text to ;; highlight a range of characters, type a replacement, and press ;; Enter/Space to commit (Esc/right-click/other button cancels). ;; Highlights are drawn as temporary red TEXT entities. ;; Arguments: sel - result of (entsel ...): (entityName pickPoint) ;; Returns: nil (modifies the selected TEXT via entmod) (defun ht:run (sel / hEnt ed txt hgt wf sty lay obl ang base anchor-s chars layout input running gr code data cur-s hl-a hl-b hl-from hl-to i new-lst new-txt echo-last last-a last-b) (setq hEnt (car sel) ed (entget hEnt)) (if (/= "TEXT" (cdr (assoc 0 ed))) (princ "\n not a text") (progn (setq txt (cdr (assoc 1 ed)) hgt (cdr (assoc 40 ed)) wf (cond ((cdr (assoc 41 ed))) (t 1.0)) sty (cond ((cdr (assoc 7 ed))) (t "Standard")) lay (cdr (assoc 8 ed)) obl (cdr (assoc 51 ed)) ang (cond ((cdr (assoc 50 ed))) (t 0.0)) base (ht:origin ed) anchor-s (ht:proj (cadr sel) base ang) chars (ht:chars txt) layout (ht:layout chars hgt wf sty obl)) (princ "\n move mouse to change text") (setq running T input "" echo-last 0 *ht-tmp* '() last-a nil last-b nil) (while running (setq gr (grread T 13) code (car gr) data (cadr gr)) (cond ((= code 5) (setq cur-s (ht:proj data base ang) hl-from (min anchor-s cur-s) hl-to (max anchor-s cur-s) hl-a nil hl-b nil i 0) (foreach item layout (if (and (< (nth 1 item) hl-to) (> (nth 2 item) hl-from)) (progn (if (null hl-a) (setq hl-a i)) (setq hl-b i))) (setq i (1+ i))) (if (or (/= hl-a last-a) (/= hl-b last-b)) (progn (ht:clear *ht-tmp*) (setq *ht-tmp* (if hl-a (ht:paint layout base ang hgt wf lay sty obl hl-from hl-to) '())) (setq last-a hl-a last-b hl-b)))) ((= code 2) (cond ((member data '(13 32)) (if (null hl-a) (princ "\n No char to hightlight") (progn (setq i 0 new-lst '()) (forea
TRIZ inventive level: 3/5· Principles: parameter changes, mechanical interaction
Synthesis verdict
**PIVOT** - This is not a viable standalone business as currently framed, but the underlying interactive text-editing concept could become a small, defensible product if repositioned as a CJK/Unicode text utility inside a broader AutoCAD productivity suite. The panel is split: technical feasibility and competitive differentiation are moderate (7/10 each), but market demand is weak (4/10) and risk is high (2/10). The core problem is that AutoCAD already has native in-place text editing, so the tool solves a marginal friction rather than a painful, unmet need. Willingness to pay is low, and the addressable audience - drafters who frequently edit single-line TEXT entities and prefer mouse-driven workflows - is a small subset of AutoCAD users. The Chinese input limitation is both a technical flaw and a market signal: CJK users are the most likely to value precise multi-byte character editing, yet the current implementation excludes them. Fixing Unicode/IME handling is necessary but not sufficient; even a polished version would compete with free alternatives and built-in features. The realistic path to revenue is to bundle this as one feature within a larger LISP/.NET productivity toolkit, priced at $50-100, rather than selling it standalone.

Strengths

  • - Technically achievable: core components (grread loop, temporary highlight painting, entmod replacement) are well-documented AutoLISP patterns (Viability 7/10).
  • - Unique interactive per-character highlighting with live visual feedback is not delivered by AutoCAD's built-in EDITTEXT or Express Tools (Competitive 7/10).
  • - Existing codebase is substantial and reduces development cost, supporting a low-cost v1 (Monetization 7/10).
  • - Clear niche value for users who need precise, real-time multi-byte character editing (Competitive 7/10).
  • - A $50-100 price point is plausible for professional AutoCAD users if bundled with additional utilities (Monetization 7/10).

Weaknesses

  • - Solves a non-existent problem: AutoCAD already provides native in-place text editing, making the tool redundant for most users (Risk 2/10, Market 4/10).
  • - Chinese/CJK input failure excludes the most likely paying segment and signals deeper Unicode handling fragility (Viability 7/10, Market 4/10).
  • - Low willingness to pay for a modest productivity gain; users expect such tools to be free or bundled (Market 4/10).
  • - Reliance on AutoLISP limits durability as AutoCAD shifts toward .NET and may deprecate LISP scripts (Competitive 7/10).
  • - Fragile technical implementation using temporary entities and intricate calculations risks breaking across text styles, fonts, and AutoCAD versions (Risk 2/10).

Best angle

Reposition as a CJK/Unicode text-editing utility bundled inside a broader AutoCAD productivity suite, marketed to Asian drafting teams who need precise multi-byte character control that native tools lack.

Panel verdicts

Competition

nvidia/nemotron-3-nano-omni-30b-a3b-reasoning

7.0

“It fills a niche for precise, real - time, multi - byte character editing that standard AutoCAD tools lack.”

The concept provides a unique, interactive, per - character text replacement workflow with live highlighting and robust CJK support, which existing AutoCAD text editors (e.g., built - in EDITTEXT, Express Tools text commands, third - party utilities like Text Replacer) do not deliver; however its reliance on AutoLISP limits durability as newer AutoCAD versions favor .NET and may deprecate LISP scripts.

Monetization

mistralai/mistral-nemotron

7.0

“The tool's value is high for a niche market, but its revenue potential is constrained by the limited size of that market.”

The idea of creating an AutoLISP tool for interactive in-place text character replacement in AutoCAD is valuable for users who need to edit text entities efficiently. The tool's ability to highlight and replace specific characters within a text entity can save time and reduce errors. However, the monetization potential is limited by the niche market of AutoCAD users who are familiar with AutoLISP. The pricing model could involve a one-time purchase or subscription, with a price point around $50-$100, targeting professional AutoCAD users. The conversion path would involve marketing through AutoCAD forums, social media groups, and AutoCAD-related websites. The unit economics would depend on the development and maintenance costs, which could be relatively low given the existing codebase. The key insight is that while the tool has a specific and valuable use case, its market size is limited, which affects its revenue potential.

Risk

mistralai/mistral-nemotron(fallback #2)

2.0

“The idea fails because it solves a non-existent problem with a technically inferior and overly complex solution that lacks market viability and user appeal.”

This idea is fundamentally flawed for several critical reasons. First, the core functionality of in-place text character replacement in AutoCAD is already natively supported by AutoCAD's built-in text editing tools, making this solution redundant and unnecessary. Second, the technical implementation is overly complex and fragile, relying on temporary entities and intricate calculations that could easily break with different text styles, fonts, or AutoCAD versions. Third, the inability to directly input Chinese characters is a significant limitation that would alienate a large portion of potential users in global markets. Additionally, the solution requires users to manually select and interact with text in a non-intuitive way, which would likely lead to poor user adoption and high churn rates. The niche nature of this tool means it would struggle to attract a meaningful user base, and the lack of a clear monetization strategy would make it difficult to sustain. Finally, the reliance on AutoLISP, a scripting language with limited capabilities and declining support, would further restrict the tool's viability and scalability.

Viability

nvidia/nemotron-3-super-120b-a12b(fallback #2)

7.0

“The primary hurdle is ensuring proper multi - byte Unicode handling so that highlighting and replacement work correctly for Chinese and other CJK text.”

Building a functional v1 of this AutoLISP-based in - place text replacement tool is technically achievable for a solo developer or a two - person team with solid AutoLISP and AutoCAD internals experience. The core components - entity selection, grread loop for mouse tracking, temporary highlight painting, and text replacement via entmod - are well - documented patterns that can be assembled in a few weeks. The main difficulty lies in correctly handling Unicode (especially CJK) characters: AutoLISP's string functions operate on bytes, so the existing ht:chars helper must be extended to treat multi - byte sequences as single tokens, and the width - calculation functions (ht:wid, ht:layout) must use the actual glyph advance rather than byte length. This requires testing with various fonts, text styles, justification, rotation, and oblique angles to ensure the highlight range aligns with visual characters. Additionally, the tool must be packaged as a VLX or FAS with proper error handling, uninstall cleanup, and version - compatibility checks across recent AutoCAD releases. While the algorithmic complexity is moderate, the effort to achieve reliable Unicode support and robust UI feedback pushes the timeline toward the upper end of the 4-12 - week window, making a realistic estimate of 8-10 weeks for a polished v1.

Market

nvidia/nemotron-3-super-120b-a12b(fallback #4)

4.0

“While the tool solves a minor text - editing friction in AutoCAD, its narrow user base, low willingness to pay, and strong competition limit its viability as a standalone business venture.”

The proposed AutoLISP routine offers an interactive, mouse - driven way to replace characters inside a single - line TEXT entity, a convenience that could save a few seconds per edit for power users of AutoCAD. However, AutoCAD already provides native in - place text editing (double - click or properties palette) and many third - party LISP libraries deliver similar functionality. The addressable audience is therefore limited to drafters, engineers, and architects who frequently edit text and prefer a lightweight, keyboard - free workflow - a subset of the several million AutoCAD users worldwide. Willingness to pay for such a modest productivity gain is low; most users would expect it to be free or bundled with a larger plugin suite. The current implementation also fails to handle Chinese input correctly, excluding a significant portion of the Asian market unless the Unicode/IME issue is resolved. Even after fixing that, the tool would compete with free alternatives and built - in features, making it difficult to sustain a standalone business model without additional value - added services.

Synthesized by deepseek-ai/deepseek-v4-pro-0813 · 53.3s