Allegro X Scripting - Skill - Recent Threads

It Worked the First Time! Why Does My SKILL Code Fail on the Second Run?

JuanCR — Sat, 31 Oct 2026 14:35:49 GMT

Have you ever run a SKILL function successfully, only to find that running it again produces an error or unexpected behaviour?

One common cause is that the first execution changes the database or application state that the code assumes will still be available on the next run. For example, your code may keep references to database objects that have since been deleted, replaced, or modified.

A useful troubleshooting technique is to avoid relying on database object IDs stored globally between executions. Instead, retrieve the objects you need each time the function runs and validate the returned values before operating on them.

For instance:

procedure(processSelectedObject()
let((obj)

obj = car(axlGetSelSet())

    if(obj then
      printf("Current object: %L\n" obj)
      ; Process obj here
    else
      printf("No object is currently selected.\n")
    )
  )
)

This also demonstrates another useful habit: check the result before using it. For example:

obj = car(axlGetSelSet())

when(obj
printf("Selected object type: %L\n" obj->objType)
)

Database objects aren't the only thing to consider. A SKILL script can also change session state such as the current selection or Find Filter. If your function depends on a particular state, the second execution may start under different conditions than the first.

When debugging this kind of problem, try this approach:

Run the function once.
Check what changed in the design or session.
Run it again and identify the first operation that behaves differently.
Add printf() statements around your operations.
Inspect database objects and return values instead of assuming they are valid.
Where appropriate, reacquire database objects rather than relying on references retained from an earlier execution.

These steps are crucial specially when you're testing loose SKILL commands, where moving the canvas, zooming in or modifying the position of the elements might change the dbIDs of the objects.

The important question isn't always "Why did my SKILL code fail?" Sometimes the better question is:

"What did the first execution change that the second execution wasn't expecting?"

That small shift in troubleshooting approach can make intermittent SKILL problems much easier to isolate.

Have you encountered a SKILL function that behaves differently on its second execution? What was the root cause, and how did you track it down?

How to calculate Actual Value in Allegro skill?

SK202607205032 — Tue, 20 Oct 2026 02:21:07 GMT

Hi All,

I am trying to calculate the actual distance between a pin and silkscreen text. Although I am using axlAirGap(), the returned value doesn't match the actual value shown in the DRC.
Instead, it returns 'No Air Gap', which is consistent with the Measure tool's result.
Is there a way to accurately calculate this 'Actual Value'?

Thanks!!

Extract areas on the FPCB that do not contain arcs.(Season2)

SG20260713408 — Wed, 30 Sep 2026 02:36:21 GMT

Hello, everyone.
I am reposting this with the finalized code,
which builds upon the code shared by "Hoangkhoipcb".
Once again, I would like to thank "Hoangkhoipcb".

Note : Changed on 26Y/10M/16D (;; Change Here)

Enabled execution by layer within APD.

/*
================================================================================

*(26Y/09M/30D)
* Command : create_arc_chk
* Function : Checks for bent corners (sharp angles) without arcs on CLINES.
* Highlights detected segments and generates a report log.
*
* [How to Use]
* 1. Modified to allow checking of individual layers or all layers.
* 2. When the window appears after execution:
* 3. Select the layer you wish to check and click the OK button.
* - All_Layer : Checks clines on all layers.
* - Others : Checks clines only on the specific layer.
* 4. Clicking the Cancel button stops the operation.
*
* Output File : create_arc_chk.log
================================================================================
*/

axlCmdRegister("create_arc_chk" 'create_arc_chk)

(defun create_arc_chk ()
(let (all_layers sel_layer clines seg_list Out_file segs seg next_seg angle pt_corner error_count)

all_layers = append(list("All_Layer") axlSubclassRoute(?field 'isEtch))
sel_layer = nth(axlUIMultipleChoice("Select a Layer" all_layers "All Etch Layer") all_layers)

when(sel_layer
if(sel_layer == "All_Layer" then
axlSetFindFilter(?enabled '("noall" "CLINES" "INVISIBLE") ?onButtons '("all"))
axlAddSelectAll()
clines = axlGetSelSet()
else
axlVisibleDesign(nil)
axlVisibleLayer(strcat(axlMapClassName("ETCH") "/" sel_layer) t) ;; Changed here.
axlVisibleLayer(strcat("PIN/" sel_layer) t)
axlVisibleLayer(strcat("VIA CLASS/" sel_layer) t)
axlVisibleLayer("BOARD GEOMETRY/OUTLINE" t)
axlVisibleUpdate(t)
axlSetFindFilter(?enabled '("noall" "CLINES") ?onButtons '("all"))
axlAddSelectAll()
clines = axlGetSelSet()
)

axlClearSelSet()

seg_list = nil
error_count = 0

Out_file = outfile("create_arc_chk.log" "w")

fprintf(Out_file "%-5s %-7s %-10s %s\n" "No" "Angle" "Layer" "Location")

foreach(cline clines
segs = cline->segments
while(cdr(segs)
seg = car(segs)
next_seg = cadr(segs)

/* Proceed only if both segments are straight lines */
if(seg->xy == nil && next_seg->xy == nil then

/* Find the intersection point of two consecutive line segments */
if(axlGeoPointsEqual(car(seg->startEnd) car(next_seg->startEnd)) || axlGeoPointsEqual(car(seg->startEnd) cadr(next_seg->startEnd)) then
pt_corner = car(seg->startEnd)
else
pt_corner = cadr(seg->startEnd)
)

angle = abs(axlRadToDeg(axlGeoAngleBetweenLines(seg->startEnd next_seg->startEnd)))

if(!axlGeoEqual(angle 0.0) && !axlGeoEqual(angle 180.0) then
error_count = error_count + 1

fprintf(Out_file "%-5d %-7.2f %-10s %L\n" error_count angle cadr(parseString(seg->layer "/")) pt_corner)

seg_list = cons(seg seg_list)
seg_list = cons(next_seg seg_list)
)
)
segs = cdr(segs)
)
)
close(Out_file)

if(error_count > 0 then
axlHighlightObject(seg_list)
axlUIViewFileCreate("create_arc_chk.log" "Arc Segments Check" nil)
printf("### Errors : %d ###\n" error_count)
else
printf("### No arc-less corners found. ###\n")
)
)
)
)

SKILL: "Error if: too many arguments (missing then?)" error on running "if" command

JuanCR — Mon, 28 Sep 2026 10:08:01 GMT

Check out the following statement:

if( order
parameters = foreach( mapcar param order (get cdfgData param))
parameters = (getq cdfgData parameters)
)

It seems a then keyword is missing, and the tool does not complain.

Now let's say you add a printf command like:

if( order
parameters = foreach( mapcar param order (get cdfgData param))
parameters = (getq cdfgData parameters)
printf("%L" parameters~>values)
)

In this case, you'll get the following error:

*Error* if: too many arguments (missing then?) -
(order (parameters = foreach(mapcar param order get(cdfgData param)))
(parameters = (cdfgData->parameters)) printf("%L" (parameters~>values)))

Why did you get this error, and how can you fix it? I'll show you:

Consider a simpler example. In the command line, type:

x = 2

Then enter this expression:

if( (x > 5) 1 0)

The tool will evaluate whether x > 5; if so, a "1" will be returned; otherwise, a "0" will be returned. Since 2 is less than 5, you will see the returned value as follows:

=> 0

This is because the "if" command falls into the following syntax:

if( g_condition g_thenExpression [ g_elseExpression ] )

Now, if a fourth argument is added ("3" in this case) as follows:

if( (x > 5) 1 0 3)

You will now see the following error:

*Error* if: too many arguments (missing then?) - ((x > 5) 1 0 3)

You get it because the 'compact' form of the if command is no longer applied. The syntax now becomes:

if( g_condition then g_thenExpr1 ... [ else g_elseExpr1 ... ] )

Thus, you need to add a "then" for a complete "if" command. If it is not present, the tool will generate an error message.

It is recommended to use the "then" and "else" keywords to avoid such syntax errors and reduce confusion. There are times when the 'compact' form is handy without the bloat of then...else, but it is generally recommended to add these keywords.

Check the SKILL Language Reference for details. Here's an excerpt from the input for the if conditional:

Description

This command selectively evaluates two groups of one or more expressions. The syntax is as follows:

if( g_condition g_thenExpression [ g_elseExpression ] )
=> g_result

The "if" form evaluates g_condition, typically a relational expression, and executes g_thenExpression if the condition is true (that is, its value is non-nil); otherwise, g_elseExpression is executed. The value returned by "if" is the value of the corresponding expression evaluated. The "if" form can therefore be used to evaluate expressions conditionally.

if( g_condition then g_thenExpr1 ... [ else g_elseExpr1 ... ] )
=> g_result

The second form of "if" uses the keywords "then" and "else" to group expressions into a conditional execution sequence. If the condition is true, the sequence of expressions between "then" and "else" (or the end of the if form) is evaluated, with the value of the last expression evaluated returned as the value of the form. If the condition is nil instead, the sequence of expressions following the "else" keyword (if any) is evaluated instead. Again, the value of the last expression evaluated is returned as the value of the form.

Extract areas on the FPCB that do not contain arcs.

SG20260713408 — Sat, 19 Sep 2026 04:48:27 GMT

When designing an FPCB (Flexible Printed Circuit Board), corners are often rounded using arcs.

This script extracts the coordinates of connection points between cline segments where no arc has been generated.
In other words, assuming that all corners should be rounded with arcs, it identifies the locations where arcs are missing.
Therefore, you can verify the design by running the test after applying arcs to all corners.

GoodBye~~

axlCmdRegister("find_napoc" 'Find_No_Arc_Point_Of_Clines ?cmdType "interactive")

procedure(Find_No_Arc_Point_Of_Clines()

let((theta_lists check_list check_lists cline_seg_count all_cline_seg_count
sel_nets sel_net_name sel_net_branches sel_net_branches_childrens pin_via_dbs cline_dbs
cline_db_segments first_seg_in_pin_via_value layer first_startend
first_start_xy first_end_xy first_find_pin_via_db first_find_pin_via_db_poly first_start_xy_in_db_result first_end_xy_in_db_result
last_startend last_start_xy last_end_xy last_find_pin_via_db last_find_pin_via_db_poly
segment_objtype segment_layer segment_start_end_xy segment_start_xy segment_start_x segment_start_y
segment_end_xy segment_end_x segment_end_y delta_x delta_y
theta theta_lists seg_start_xy_in_first_db_result seg_start_xy_in_last_db_result)

theta_lists = list(nil)

check_lists = list()

axlClearSelSet()

sel_nets = axlDBGetDesign() -> nets

foreach(sel_net sel_nets

sel_net_name = sel_net -> name

sel_net_branches = sel_net -> branches

when(sel_net_branches

foreach(sel_net_branche sel_net_branches

sel_net_branches_childrens = sel_net_branche -> children

pin_via_dbs = setof(db sel_net_branches_childrens db -> objType == "pin" || db -> objType == "via")

cline_dbs = setof(db sel_net_branches_childrens db -> objType == "path")

when(cline_dbs

foreach(cline_db cline_dbs

cline_db_segments = cline_db -> segments

when(cline_db_segments

cline_db_segments_length = length(cline_db_segments)

cline_seg_count = 0

all_cline_seg_count = 0

first_seg_in_pin_via_value = nil

layer = car(cline_db_segments) -> layer

first_startend = car(cline_db_segments) -> startEnd

first_start_xy = car(first_startend)

first_end_xy = cadr(first_startend)

first_find_pin_via_db = car(setof(db pin_via_dbs axlGeoPointsEqual(db -> xy first_start_xy)))

if(first_find_pin_via_db then

first_find_pin_via_db_poly = car(axlPolyFromDB(first_find_pin_via_db ?layer layer ?padType 'REGULAR))

first_start_xy_in_db_result = axlGeoPointInShape(first_start_xy first_find_pin_via_db_poly)

first_end_xy_in_db_result = axlGeoPointInShape(first_end_xy first_find_pin_via_db_poly)

when(first_start_xy_in_db_result && first_end_xy_in_db_result first_seg_in_pin_via_value = t)

else

first_find_pin_via_db_poly = nil

first_seg_in_pin_via_value = nil

)

last_startend = lastelem(cline_db_segments) -> startEnd

last_start_xy = car(last_startend)

last_end_xy = cadr(last_startend)

last_find_pin_via_db = car(setof(db pin_via_dbs axlGeoPointsEqual(db -> xy last_end_xy)))

if(last_find_pin_via_db then

last_find_pin_via_db_poly = car(axlPolyFromDB(last_find_pin_via_db ?layer layer ?padType 'REGULAR))

else

last_find_pin_via_db_poly = nil

)

foreach(segment cline_db_segments

cline_seg_count = ++cline_seg_count

all_cline_seg_count = ++all_cline_seg_count

segment_objtype = segment -> objType

segment_layer = cadr(parseString(segment -> layer "/"))

segment_start_end_xy = segment -> startEnd

segment_start_xy = car(segment_start_end_xy)

segment_start_x = car(segment_start_xy)

segment_start_y = cadr(segment_start_xy)

segment_end_xy = cadr(segment_start_end_xy)

segment_end_x = car(segment_end_xy)

segment_end_y = cadr(segment_end_xy)

delta_x = segment_start_x - segment_end_x

delta_y = segment_start_y - segment_end_y

if(oddp(cline_seg_count) then

theta = axlRadToDeg(atan2(delta_y delta_x))

theta_lists = cons(theta theta_lists)

when(all_cline_seg_count == 1 && first_seg_in_pin_via_value cline_seg_count = 1)

when(segment_objtype == "arc" cline_seg_count = 0)

)

if(zerop(cline_seg_count) && evenp(cline_seg_count) then

theta = axlRadToDeg(atan2(delta_y delta_x))

theta_lists = cons(theta theta_lists)

else

when(!zerop(cline_seg_count) && evenp(cline_seg_count)

seg_start_xy_in_first_db_result = axlGeoPointInShape(segment_start_xy first_find_pin_via_db_poly)

;;seg_end_xy_in_first_db_result = axlGeoPointInShape(segment_end_xy first_find_pin_via_db_poly)

seg_start_xy_in_last_db_result = axlGeoPointInShape(segment_start_xy last_find_pin_via_db_poly)

;;seg_end_xy_in_last_db_result = axlGeoPointInShape(segment_end_xy last_find_pin_via_db_poly)

before_theta = car(theta_lists)

if(segment_objtype != "arc" then

theta = axlRadToDeg(atan2(delta_y delta_x))

if(axlGeoEqual(before_theta theta) then

cline_seg_count = 1

theta_lists = cons(theta theta_lists)

else

if(seg_start_xy_in_first_db_result || seg_start_xy_in_last_db_result then

cline_seg_count = 1

theta_lists = cons(theta theta_lists)

else

check_list = list(segment_layer segment_start_xy sel_net_name)

check_lists = cons(check_list check_lists)

cline_seg_count = 1

theta_lists = cons(theta theta_lists)

)

else

cline_seg_count = 0

)

theta_lists = list(car(theta_lists))

)

check_lists = sortcar(check_lists 'axlStrcmpAlpNum)

if(zerop(length(check_lists)) then

;;printf("### Error Count = 0 ###\n")

axlUIConfirm("Error Count Zero(0)" 'info)

else

Create_Find_No_Arc_Point_Of_Clines_log_File(check_lists)

)

procedure(Create_Find_No_Arc_Point_Of_Clines_log_File(checking_result_infor_lists)

let((total_all_error_count Date)

total_all_error_count = 0
Date = (getCurrentTime)
Date = parseString(Date " ")
Date = strcat(nth(3 Date) " " nth(0 Date) " " nth(1 Date) " " nth(2 Date))

Find_No_Arc_Point_Of_Clines_Log_File = outfile("./Find_No_Arc_Point_Of_Clines.log" "w")

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "\nDATE : %s\n" Date)

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "\nSyntax : Layer, Point_XY, Net_Name\n")

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "\n=========================================================================\n")

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "\n ## REPORT OF NO ARC BETWEEN TWO CLINE SEGS ##\n\n")

foreach(checking_result_infor_list checking_result_infor_lists

total_all_error_count = ++total_all_error_count

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "%d.%s, %L, %s\n" total_all_error_count car(checking_result_infor_list) cadr(checking_result_infor_list) caddr(checking_result_infor_list))

)

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "\n=========================================================================\n\n")

fprintf(Find_No_Arc_Point_Of_Clines_Log_File "Total Error Count = %d ea.\n" total_all_error_count)

close(Find_No_Arc_Point_Of_Clines_Log_File)

axlShell("viewlog ./Find_No_Arc_Point_Of_Clines.log")

)

Extraction of RLC Values for Cline using skill

ABIKRISHNA — Wed, 16 Sep 2026 12:26:31 GMT

Is it possible to extract or calculate the following parameters for a selected cline using Allegro SKILL code?

Resistance
Inductance
Capacitance

Could you please provide some guidance on the relevant SKILL APIs or approach?

How to write a simple CMXL code that retrieves or edits data from Constraint Manager

JuanCR — Sun, 30 Aug 2026 20:22:55 GMT

Imagine you want to access some constraint values using SKILL. I know there are AXL functions available; However, what if you want to use CMXL because it dives deeper into the Constraint Manager capabilities.

Let's show an example. Let's set static phase values of a differential pair configuration. This is how the code would look like:

axlCMDBInit()

dsn = cmxlFindObject(ACNS_DESIGN);

when(dsn

cmxlDBSkillInit(dsn);

cset = cmxlFindObject(ACNS_ECSET, "DIFF", dsn);

when(cset

println(cmxlPutAttribute(cset "DIFFP_PHASE_TOL" ACNS_STRING list("0.5")))

println(car(cmxlGetAttribute(cset "DIFFP_PHASE_TOL" ACNS_STRING))); should return 0.5mm

)

cmxlDBSkillExit(dsn);

Here's a brief explanation of what each section is doing:

If the same logic is used with any other attribute name, you can construct the new code to edit a different constraint. Make sure you use the right Object type with cmxlFindObject. You can find all the object types and definitions at the end of the CMXL Reference Manual.

Feel free to ask any questions!

Skill script for checking BGA pitch

SG20260713408 — Fri, 21 Aug 2026 10:17:44 GMT

This is a skill for inspecting the pitch of BGAs on a board.

If you know of a more concise and elegant code than this, please let me know. (SKILL++, OOP...)

Thank you.

Note: On September 25, 2026,

27.0 was changed to 270.0

/*
============================================================================================
* Tool Name : min_pitch_bga (Enhanced Version)
* Description : Automatically checks the minimum pitch of BGA components to prevent fine-pitch routing defects.
* Features :
* 1. Support multiple symbol filtering cases (Property, SymType)
* 2. Performance Optimization: Auto-bounding box shrinkage for
* high pin-count components to prevent computation lag.
* 3. Auto-sorting and reporting with an interactive .log viewer.
* Command : min_pitch_bga [Optional Pitch Value, default "0.5"]
* To change the pitch value, simply apply the desired pitch value after the command. (min_pitch_bga 1.0 or min_pitch_bga 0.5 .......)
============================================================================================
*/

axlCmdRegister("min_pitch_bga" 'min_pitch_bga ?cmdType "interactive")

procedure(min_pitch_bga(@optional (argu_bga_pitch "0.5") "S")

let((min_bga_pitch symbols loop sym_pins_locs obj1 objPairs pitch_datas min_pitch_data

pair_count var_x var_y delta_x delta_y refdes sym_xy layer sym_rot all_x_loc all_y_loc min_x min_y max_x max_y sym_pins total_results)

min_bga_pitch = atof(argu_bga_pitch)

when(min_bga_pitch

;;========================================================================================

;;Comment : Please select and use the case that fits the situation.

;;Comment(Case1) : Use when a symbol(footprint) is given a property name("DFA_DEV_CLASS") and a property value("bga").

;; Property values are entered by the user, so they are case-sensitive.

symbols = foreach(mapcan item axlSelectByProperty("symdef" "DFA_DEV_CLASS" "bga") ~> instances item) ;; Use if applicable to Case 1

;;symbols = foreach(mapcan item axlSelectByProperty("symdef" "DFA_DEV_CLASS" "bg*" t) ~> instances item) ;; Use if applicable to Case 1

;;symbols = foreach(mapcan item axlSelectByProperty("symdef" "REF_PATTERN_NAME" "BGA*" t) ~> instances item) ;; Use if applicable to Case 1

;;========================================================================================

;; Comment(Case2) : The name given when generating the symbol(footprint).

;; In other words, when the symbol name(footprint name) starts with "BGAXXXXXXXX_XXX_XXX"

;;symbols = axlSelectByName("SYMTYPE" "BGA*" t) ;; Use if applicable to Case 2, Delete ";;" and use

;;========================================================================================

axlClearSelSet()

if(symbols then

foreach(symbol symbols

loop = t

sym_rot = nil

sym_pins = nil

sym_pins_locs = nil

all_x_loc = nil

all_y_loc = nil

objPairs = nil

pitch_datas = nil

min_pitch_data = nil

pair_count = nil

var_x = nil

var_y = nil

delta_x = nil

delta_y = nil

sym_xy = symbol -> xy

refdes = symbol -> refdes

unless(refdes refdes = "No RefDes")

layer = if(symbol -> isMirrored then "BOTTOM" else "TOP")

sym_pins = setof(e symbol -> pins e -> number != "" || e -> isMech != t)

when(sym_pins && length(sym_pins) > 1

sym_rot = symbol -> rotation

if(axlGeoEqual(sym_rot 0.0) || axlGeoEqual(sym_rot 90.0) || axlGeoEqual(sym_rot 180.0) || axlGeoEqual(sym_rot 270.0) then ;;Changed here.

sym_pins_locs = sym_pins ~> xy

else

foreach(sym_pin sym_pins

sym_pin_xy = sym_pin -> xy

rot_pin = axlGeoRotatePt(minus(sym_rot) car(sym_pin_xy):cadr(sym_pin_xy) car(sym_xy):cadr(sym_xy))

sym_pins_locs = cons(rot_pin sym_pins_locs)

)

)

all_x_loc = foreach(mapcar item sym_pins_locs car(item))

all_y_loc = foreach(mapcar item sym_pins_locs cadr(item))

var_x = apply('min all_x_loc)

sym_x = apply('max all_x_loc)

var_y = apply('min all_y_loc)

sym_y = apply('max all_y_loc)

delta_x = abs(sym_x - var_x)

delta_y = abs(sym_y - var_y)

sym_xy = list((sym_x - (delta_x / 2)) (sym_y - (delta_y / 2)))

delta_x = delta_x / 30

delta_y = delta_y / 30

sym_pins_locs = setof(e sym_pins_locs axlIsPointInsideBox(e list(sym_xy list(var_x var_y))))

when(length(sym_pins_locs) > 1

pair_count = (length(sym_pins_locs) * (length(sym_pins_locs) - 1)) / 2

when(pair_count > 1500

while(loop

var_x = var_x + delta_x

var_y = var_y + delta_y

delta_x = (car(sym_xy) - var_x) / 30

delta_y = (cadr(sym_xy) - var_y) / 30

sym_pins_locs = setof(e sym_pins_locs axlIsPointInsideBox(e list(sym_xy list(var_x var_y))))

pair_count = (length(sym_pins_locs) * (length(sym_pins_locs) - 1)) / 2

when(pair_count < 1500 loop = nil)

)

when(sym_pins_locs

while(sym_pins_locs

obj1 = car(sym_pins_locs)

sym_pins_locs = cdr(sym_pins_locs)

foreach(obj2 sym_pins_locs objPairs = cons(list(obj1, obj2), objPairs))

)

when(objPairs

foreach(objPair objPairs

pitch_datas = cons(axlDistance(car(objPair) cadr(objPair)) pitch_datas)

)

min_pitch_data = car(sort(pitch_datas 'lessp))

)

when(min_pitch_data

when(min_pitch_data < min_bga_pitch

axlHighlightObject(symbol)

total_results = cons(list(layer refdes min_pitch_data symbol -> xy symbol -> name) total_results)

)

total_results = reverse(sortcar(total_results 'axlStrcmpAlpNum))

MPB_Create_log_File(total_results min_bga_pitch)

else

printf("###### BGA cannot be found. !! ######\n")

)

procedure(MPB_Create_log_File(total_results min_bga_pitch)

let((err_count Date Min_Pitch_BGA_Log_File)

err_count = 0

Date = (getCurrentTime)
Date = parseString(Date " ")
Date = strcat(nth(3 Date) " " nth(0 Date) " " nth(1 Date) " " nth(2 Date))

Min_Pitch_BGA_Log_File = outfile("./Min_Pitch_BGA.log" "w")

fprintf(Min_Pitch_BGA_Log_File "\nDATE : %s\n" Date)

fprintf(Min_Pitch_BGA_Log_File "\nTarGet Pitch : %f\n" min_bga_pitch)

fprintf(Min_Pitch_BGA_Log_File "\nSyntax : nIndex, Layer, RefDes, Pitch, Symbol_XY, Symbol_Name\n")

fprintf(Min_Pitch_BGA_Log_File "\n=========================================================================\n")

if(length(total_results) == 0 then

fprintf(Min_Pitch_BGA_Log_File "\n=========================================================================\n")

fprintf(Min_Pitch_BGA_Log_File "\n Total Error Count = 0\n")

else

fprintf(Min_Pitch_BGA_Log_File "\nIndex, Layer, RefDes, Pitch, Symbol_XY, Symbol_Name\n")

foreach(total_result total_results

err_count = ++err_count

fprintf(Min_Pitch_BGA_Log_File "\n%d, %s, %s, %f, %L, %s\n" err_count nth(0 total_result) nth(1 total_result) nth(2 total_result) nth(3 total_result) nth(4 total_result))

)

fprintf(Min_Pitch_BGA_Log_File "\n=========================================================================\n")

fprintf(Min_Pitch_BGA_Log_File "\n Total Error Count = %d.\n" err_count)

)

close(Min_Pitch_BGA_Log_File)

axlShell("viewlog ./Min_Pitch_BGA.log")

)

Skill to open Custom Variables Window in Allegro x 25.1 PCB Editor

MZ20250602835 — Wed, 19 Aug 2026 12:40:07 GMT

Dear all,

i can use Command tbx customvar update to open the custom variables window.

I can also use axlShell("tbx customvar update") to open the same window but My current Problem is that:

after giving axlShell("tbx customvar update") I do not get the Skill > for the next skill

Skill > axlShell("tbx customvar update")

Reading file "C:/Users/emp8124501/ECAD/projects/251_demo/output/251_demo/physical/customvar.cfg"

Info: Reading custom variables from "C:/Users/emp8124501/ECAD/projects/251_demo/251_demo.cpm"

It missing the Skill > after Info: Reading custom variables from "C:/Users/emp8124501/ECAD/projects/251_demo/251_demo.cpm"

May i ask how could i solve this issue or are there any other skill to use instead of axlShell in allegro x pcb editor such as axlCmd, axlUIWExecuteCommand or axlDBCmd?

Many thanks

Moyan

How to remove an element from a group without deleting or disbanding the group using SKILL

JuanCR — Mon, 27 Jul 2026 15:37:01 GMT

Let's say you have a specific group of elements in a brd file and you want to remove one element from this group. How can you remove it without disbanding the group or deleting the element?

The SKILL function axlDBRemoveGroupObjects can be used to remove database objects from the specified group. Group members, though removed, are not deleted.

axlDBRemoveGroupObjects(o_group lo_members) ⇒ t/nil

Arguments:

o_group: The database ID of the group from which objects will be removed.
o_members: A list of database objects to be removed from the group. A single database ID can be substituted for a list.

This function removes the selected objects (lo_members) from the specified group (o_group). Neither the group nor the member is deleted.

The following SKILL code can be used to remove an object from multiple groups at the same time:

procedure( removeObjectFromGroup()
let((objects_dbid group_dbd group_bibliotec elemnt group)

  axlSetFindFilter(?enabled list("all") ?onButtons list("noall" "symbols" "shapes"))
  axlClearSelSet()
  axlSingleSelectPoint()

objects_dbid=axlGetSelSet()

group_bibliotec=makeTable("groups" nil)
  foreach(elemnt objects_dbid
  foreach(group elemnt->parentGroups
if(group then group_bibliotec[group]=append(group_bibliotec[group] list(elemnt)))
)
)
  foreach(group_dbd group_bibliotec
  axlDBRemoveGroupObjects(group_dbd group_bibliotec[group_dbd])
)
)
)

Explanation of the SKILL code:

The first step in the removeObjectFromGroup() function is to set the Find filter:

axlSetFindFilter(?enabled list("noall" "symbols" "shapes") ?onButtons list("noall" "symbols" "shapes"))

This will decide what kind of objects you can select on the canvas. In this case, from all possible objects, only “symbols” and “shapes” are selectable; “symbols” and “shapes” are already set to "on".

Then, selection of the objects can be done using the following function. Note that there are many functions that let you select objects in different ways. You can read more about it in Allegro SKILL Reference 22.1 > Select and Finds Functions.

axlSingleSelectPoint()

This function allows you to select a single point on the screen. When this function is called, it will wait for an action from the user to pick a point. Everything that matches the Find filter will be selected. To get all objects selected, use:

objects_dbid=axlGetSelSet()

The variable objects_dbid can have multiple objects, and each one of these objects can belong to a different group. To classify which object belongs to each group, use a table (group_bibliotec):

group_bibliotec=makeTable("groups" nil)

In the below code, foreach is used to pass by each element of the objects_dbid list. Then, foreach is used again to pass by all parent groups that this element can belong to. The code then checks if the object does belong to any group. If it does, the current element is appended to the group_bibliotec with the matching key.

foreach(elemnt objects_dbid
foreach(group elemnt->parentGroups
if(group then group_bibliotec[group]=append(group_bibliotec[group] list(elemnt)))
)
)

To remove the components from the groups:

foreach(group_dbd list_groups_dbid
axlDBRemoveGroupObjects(group_dbd objects_dbid)
)

How to use skill code to check pin to pin mark air gap?

SK202607205032 — Wed, 22 Jul 2026 08:21:37 GMT

Hi all,

I would like to get the air gap value between the first pin and the pin-1 marker (silkscreen text such as "*" or ">"), as shown below.

I found the API axlAirGap(), but I'm not sure how to implement it.

Could anyone provide an example or some guidance?

Thanks!!

How to merge excel cell in Allgero SKILL using axlSpreadsheet API

SK202607205032 — Tue, 21 Jul 2026 05:56:35 GMT

I just using axlSpreadsheetInit() to write excel file, but I don't know how to merge cell,example as the picture below.

Is there any suggestion? Thanks a lot.

How to check BGA minimum pitch using Allegro Skill language

BZ202408076026 — Mon, 13 Jul 2026 06:33:23 GMT

I want to check BGA minimum pitch. If BGA pitch is less than 0.5mm, need to highlight these BGA in PCB layout. Does anyone have experience to write script to do the check?

Shape Degassing parameters extraction using SKILL in allegro APD

AnanthVedalaLM — Wed, 08 Jul 2026 23:02:08 GMT

I'm trying to extract the values set for a specific degassing pattern using skill , but instead of name , i'm unable to get anything else , is there any way we can extract the void array parameters and void spacing constraints that we set in the shape degassing tool, instead of using GUI, is there any other option to set those parameters for a pattern and also extract them

usually i'm getting the pattern name in this way

shapedbId->shapeBoundary->prop->DEGAS_SHAPE_PROPERTIES

which just leaves me with the name of the pattern used on the shape, but unable to figure out how do we actually get these parameters using skill

other questions i have ,

Are these parameters for the dynamic shapes global or local ? and how are these parameters stored in the database

axlOpenDesignForBatch( works differently between 22.1 and 25.1 ( appears broken )

Mhawley1 — Tue, 07 Jul 2026 13:05:43 GMT

I just found something interesting today and would be nice for someone to test.

It would seem like axlOpenDesignForBatch( no longer runs without a save prompt in 25.1 under the WF mode . Can someone try this out . Try out the example and see if you can batch open two dra's without the prompt coming up .

axlOpenDesignForBatch("u.dra" "wf") ( tested in 25.1 S 30 )

Should I make a ticket ?

How to import a techfile through SKILL

JuanCR — Thu, 02 Jul 2026 12:30:33 GMT

axlRunBatchDBProgram can be used to import a techfile.

Open the design in Allegro X PCB Editor or Package Designer and type skill at the command line:

Command > skill

The command line changes to the Skill prompt:

Skill >

The following skill code will create a log file and import a techfile. In the following skill code, replace mytechfile.tcfx with your own techfile name including the .tcfx extension:

Skill > axlRunBatchDBProgram("techfile" "techfile -$ -r mytechfile.tcfx %s" ?reloadDB t ?logfile "techfile")

Wait while the techfile (apd) runs:

The view of the techfile UI will appear. Scroll to view the summary.
Close the file.
In the database, to exit from the skill prompt, type exit:

Skill > exit

The Command window changes from Skill > to Command >:

Command >

axlDesignFlip()

DavidAhl — Fri, 26 Jun 2026 10:06:26 GMT

Hi,

Im using the axlDesignFlip() in a script. In version 23.1 it worked great but when i run the script in version 25.1 it wont flip back the design. From the documentation i cant see that anything has changed. Is this a known bug in 25.1 or have i missed if something changed?

I tried this in both 23.1 and 25.1, both gave the same print out but in 25.1 the design doesnt flip back..

best regards

david

How to start SKILL IDE from APD or Allegro in Linux?

JuanCR — Fri, 05 Jun 2026 23:35:51 GMT

The debugger environment is not so convenient for APD / Allegro debug. It is more oriented for SKILL DFII development. SKILL Debugger is incapable to debug the axlSKILL (Allegro specific) functions.

There is no graphical debugger for axlSKILL, but you can set the telskill environment variable to open a SKILL development window.

If you are looking for line debugger with Allegro, there are some command line debugging options available to you:

installDebugger() and axlDebug() are functions you can use to set debug mode.

The following is an extract from the axlIsDebug() function description in cdnshelp, which describes what axlDebug enables:

When this mode is set, AXL may print additional AXL API argument warnings when arguments to AXL functions are incorrect. Many warnings do not obey this variable because they are considered serious or edge conditions. Warnings supported are less serious and are known from user feedback to be troublesome to program around.

Typically, when an AXL API function encounters an argument error, it will print a warning and return nil.
When unset, the code runs in development mode and eliminates many of these warnings. You should have this mode enabled when developing SKILL code.

Another function available to you is sstatus. Refer to the online documentation to get the full list of the internal variable names and switch values available to you through this command.

sstatus(
s_name
g_switchValue
)
=> g_switchValue

Description: Sets the internal system variable named to a given value. This is a syntax form. Internal variables are typically Boolean switches that accept only the Boolean values of t and nil. Efficiency and security are the reasons why these system variables are stored as internal variables, which can only be set by sstatus, rather than as SKILL variables you can set directly.

Other things you can do are set breakpoints with breakpt and then progress through your code with step and continue etc.

Note: The online document, SKILL Development Functions Reference, is helpful for describing the functions. However, you must be aware that any reference to a graphical interface for debugging does not apply to axlSKILL. As with any programming language, you can set a debug variable and then make conditional checks for it. If set, you can have your code print values of variables from your code.

The other way to check the code before delivery is to launch the SKLINT tool and to try to solve all warnings, errors given by this tool.

Steps to use SKLINT on UNIX:

Run setenv TELSKILL in your local env file.
Run Allegro and then keep Allegro iconified.
In the current shell window, the prompt becomes SKILL>. Launch SKILL> sklint ?file "filetodebug.il".
filetodebug.il is the file name you want to debug.

customized GUI to control artwork film

MZ20250602835 — Mon, 01 Jun 2026 05:45:19 GMT

Dear all,

i would like to use film_domain.form as the base to create a customized GUI in which the user/Layouter can assign specific artwork films for Artwork and PDF domains(the Domains IPC2581 and Visibility will not be displayed).

may i ask in my case which skill should i used to achieve the expected function?

Many thanks

Moyan

How to use Stack in Allegro SKILL

JuanCR — Thu, 16 Apr 2026 21:46:08 GMT

Stack is a popular data structure in programming languages. It is like a real-world stack such as piles of papers, where papers are usually added to the top of the pile and removed from the top. So, in a stack data structure, you can add or remove elements from the top of the stack using the LIFO (Last-In-First-Out) principle.

Stack in Allegro SKILL is a list that works like a stack using APIs/functions pushf and popf.

pushf adds an element to the top of the stack, that is, adds the first element to the list.
popf removes an element from the top of the stack, that is, the first element of the list.

The code is as shown below:

myStack=list(3 4 5 6)
printf("Stack is %L\n" myStack)
pushf(2 myStack)
printf("After pushing 2 Stack is %L\n" myStack)
pushf(1 myStack)
printf("After pushing 1 Stack is %L\n" myStack)

printf("Before popping Stack is %L\n" myStack)
elem=popf(myStack)
printf("After popping: Element removed from stack is %L and Stack is %L\n" elem myStack)
elem=popf(myStack)
printf("After popping again: Element removed from stack is %L and Stack is %L\n" elem myStack)

The following image shows its output:

How to get all voids on conductor layer?

khuranav007 — Wed, 08 Apr 2026 22:39:22 GMT

What is the best way or methodology to obtain all voids (lack of metal) on a conductor layer?

I tried to use the following polygon->holes like shown below but it does not get all voids (lack of metal).

shpAbovePoly = car(axlPolyFromDB(shpAbove))
shpAbovePolyHoles = shpAbovePoly->holes

Voids in orange box are desired.

Thanks for help.

Need the Skill files

PK202511125928 — Thu, 26 Mar 2026 06:40:05 GMT

Hi Every one,

Please for allegro 23.1 any skill files ther please give me.

Like checklist runner for.

Interactive Form

AA202603241137 — Wed, 25 Mar 2026 07:20:07 GMT

I am planning to create a script but this needs to have a form that is interactive. The form changes depend on the number of layers in the PCB. My idea to list all the layers of the PCB in the form and also have a checkbox beside each layer name. But my knowledge on the form is basic only. I only use TEXT, GROUP, MENUBOTTON, STRFILLIN. Can somebody guide or educate me. Thank you.

how to Fetch parameters of the Options window

Hoangkhoipcb — Wed, 18 Mar 2026 07:32:09 GMT

Hi everyone,

Methods for identifying form handles and fetching parameters from the dynamic Options sidebar in Cadence Allegro

Any code snippets or references to the documentation would be greatly appreciated.

Thank you.

How to use regular expressions in SKILL

SaiPavanl — Fri, 20 Feb 2026 07:55:52 GMT

Often, you need to match strings or symbols against a pattern. A regular expression is an object that describes a pattern of characters. Regular expressions are a way to match patterns with sequences of characters. They are used in every programming language like C++, Java, and Python. SKILL also provides a number of pattern-matching functions like rexMatchp, rexCompile, and rexExecute.

SKILL also supports pcreCompile and pcreExecute for Perl-Compatible Regular Expressions (PCRE).

rexMatchp

If you want to see whether the string matches a regular expression, you can use rexMatchp. For example, to check if a string has only numbers with a decimal point, you can use rexMatchp, as shown below:

Rules for constructing patterns or regular expressions are given later in this article.

Note: Here, the output of the SKILL command is shown after the => symbol:

rexMatchp("[0-9]*[.][0-9][0-9]*" "100.001") => t

rexMatchp("[0-9]*[.][0-9]+" ".001") => t

rexMatchp("[0-9]*[.][0-9]+" ".") => nil

rexMatchp("[0-9]*[.][0-9][0-9]*" "10." => nil

rexMatchp("[0-9" "100")

*Error* rexMatchp: Missing ] - "[0-9"

rexMatchp( t_pattern S_target )

This function matches S_target against the t_pattern regular expression and returns t if a match is found; otherwise, it returns nil.

An error occurs if the given pattern is ill-formed.

rexCompile and rexExecute

For greater efficiency when matching a number of targets against a single pattern, use the rexCompile and rexExecute functions. For example, if you need to work on nets that match a pattern, use rexCompile and rexExecute instead of using rexMatchp.

rexExecute matches a string or symbol against the previously compiled pattern that was set up by the last rexCompile call.

To check if the name of the nets that can be alphanumeric begins with alphabets, use the following command:

rexCompile("^[a-zA-Z][a-zA-Z0-9]*") => t

rexExecute('Net123) => t

rexExecute("123 Nets") => nil

Note: Calls to rexMatchp reset the pattern set up by rexCompile. If any calls to rexMatchP have been made, rexExecute will not match the pattern set by rexCompile.

PCRE

The PCRE library provides functions for pattern matching using Perl-compatible regular expressions. For more details, refer to https://www.pcre.org.

pcreCompile compiles a regular expression string pattern(t_pattern) into an internal representation that you can use in a pcreExecute function call. The compilation method is PCRE or Perl-compatible. You can use a second (optional) argument to specify independent option bits for controlling the pattern compilation.

pcreCompile(

t_pattern

[ x_options ]

)

=> o_comPatObj / nil

For example, the [12[:^digit:]] PCRE pattern matches 1, 2, or any non-digit.

comPat1 = pcreCompile( "[12[:^digit:]]" ) => pcreobj@0x27d150 (Note that your object will be different)

pcreExecute( comPat1 "abc" ) => t

pcreExecute( comPat1 "12a") =>t

pcreExecute( comPat1 "3") =>nil

Here is another example:

comPat5 = pcreCompile( "^\\d?\\d(jan|feb|mar|apr|may|jun)\\d\\d$/" )

pcreExecute( comPat5 "25jun3" ) => nil

pcreExecute( comPat5 "25jun3" pcreGenExecOptBits(?anchored t) ) => nil

pcreExecute( comPat5 "25jun3" pcreGenExecOptBits(?partial t) ) => t

Rules for constructing pattern or regular expressions

Regular expressions can contain both special and ordinary characters. Most ordinary characters, like 'A', 'a', or '0', are the simplest regular expressions; they simply match themselves. You can concatenate ordinary characters, so that last matches the 'last' string. There are also special symbols like *, +, and so on, which you can see in detail here:

\ General escape character with several uses

^ Assert start of the string (or line, in multi-line mode)

$ Assert end of the string (or line, in multi-line mode)

. Match any character except new line (by default)

[ Start character class definition

| Start of alternative branch

( Start subpattern

) End subpattern

? Matches 0 or 1 quantifier

* Matches 0 or more

+ Matches 1 or more

The part of a pattern that is in square brackets is called a "character class". In a character class, the only metacharacters are:

\ General escape character

^ Negates the class, but only if the first character

- Indicates character range

[ POSIX character class (only if followed by POSIX syntax)

] Terminates the character class

Asterisk symbol (*)

While matching, it checks if the preceding character (or set of characters) repeats for 0 or more times (up to infinite).
Example: The ab*c regular expression matches with ac, abc, abbc, abbbc, and so on.

Plus symbol (+)

While matching, it checks if the preceding character (or set of characters) repeats for at least one or more times (up to infinite).
Example: The ab+c regular expression matches with abc, abbc, abbbc, and so on.

Wildcard (.)

The dot symbol can match any character; hence. it is called the wildcard character.
Example: The .* regular expression matches with any character any number of times.

Optional character (?)

While matching, the preceding character may or may not be present in the string to be matched.
Example: In docx?, the ? character tells the computer that x may or may not be present in the name of file format.

Caret symbol (^)

The match must start at the beginning of the string or line.
Example: ^abc matches abcd but not zabc.

Dollar symbol ($)

The match must occur at the end of the string or before \n at the end of the line or string.
Example: 333$ matches 901-333 but not 333-901

Allegro X Scripting - Skill - Recent Threads

It Worked the First Time! Why Does My SKILL Code Fail on the Second Run?

How to calculate Actual Value in Allegro skill?

Extract areas on the FPCB that do not contain arcs.(Season2)

SKILL: "*Error* if: too many arguments (missing then?)" error on running "if" command

Extract areas on the FPCB that do not contain arcs.

Extraction of RLC Values for Cline using skill

How to write a simple CMXL code that retrieves or edits data from Constraint Manager

Skill script for checking BGA pitch

Skill to open Custom Variables Window in Allegro x 25.1 PCB Editor

How to remove an element from a group without deleting or disbanding the group using SKILL

How to use skill code to check pin to pin mark air gap?

How to merge excel cell in Allgero SKILL using axlSpreadsheet API

How to check BGA minimum pitch using Allegro Skill language

Shape Degassing parameters extraction using SKILL in allegro APD

axlOpenDesignForBatch( works differently between 22.1 and 25.1 ( appears broken )

How to import a techfile through SKILL

axlDesignFlip()

How to start SKILL IDE from APD or Allegro in Linux?

customized GUI to control artwork film

How to use Stack in Allegro SKILL

How to get all voids on conductor layer?

Need the Skill files

Interactive Form

how to Fetch parameters of the Options window

How to use regular expressions in SKILL

SKILL: "Error if: too many arguments (missing then?)" error on running "if" command