Cadence SKILL Scripting Guide

If your design flow runs on Cadence Virtuoso, then SKILL scripting is the most powerful tool in your automation toolkit. SKILL is the native programming language for every tool in the Cadence custom IC platform — from Virtuoso Layout Suite to the Analog Design Environment to the schematic editor. It gives you direct, programmatic access to the tool's database, commands, user interface, and design data at a level that no external scripting language can match. For teams serious about IC design productivity, SKILL proficiency is not a luxury — it is a requirement.

What Is Cadence SKILL?

SKILL (Software Command Interface Language) is a dialect of Lisp developed by Cadence Design Systems specifically for controlling and extending its EDA tools. It has been the scripting backbone of the Virtuoso platform for over three decades, and it remains the primary interface for deep customization of every Cadence custom IC tool. SKILL code runs inside the Virtuoso environment, giving it direct access to design databases, tool commands, GUI elements, and the event-driven programming model that controls user interactions.

The syntax follows Lisp conventions: everything is expressed as S-expressions — parenthesized lists where the first element is a function name and the rest are arguments. A simple function call looks likeprintf("Hello, %s\n" name). Conditional logic uses if andcond statements. Loops usefor,foreach, andwhile. Once you get past the unfamiliar parentheses, the language is expressive and well-suited to the design automation domain.

SKILL provides access to several key APIs within Virtuoso. The database API lets you read and write design data — cells, instances, shapes, layers, pins, and connectivity. The UI API lets you create custom forms, menus, and dialog boxes. The command API wraps every Virtuoso operation as a callable function. And the event system lets you attach callbacks to user actions like mouse clicks, menu selections, and cell opens. Together, these APIs make it possible to build automation that feels like a native part of the tool.

Why SKILL Matters for IC Design

Custom IC design is fundamentally different from digital design in one important way: the layout is hand-crafted. Every transistor, every wire, every contact is placed and shaped by a layout engineer (or by code that generates them). This means the productivity of the layout team directly determines the time-to-tapeout for the chip. SKILL is the primary lever for improving that productivity because it operates inside the layout tool itself.

Consider a simple example. A layout engineer needs to place 200 identical capacitor structures in a matched array. Manually, this means placing each instance, aligning it, adding routing, and verifying that the placement meets matching constraints. With a SKILL script, the engineer specifies the array parameters (rows, columns, spacing, matching pattern) and the script generates the entire array in seconds. The result is not just faster — it is more consistent and less error-prone than manual placement.

This pattern repeats across dozens of layout tasks: device generation, guard ring placement, routing automation, DRC-aware spacing, label generation, pin placement, and layout migration. In each case, SKILL lets you encode the engineer's knowledge into a reusable tool. The knowledge does not leave when the engineer goes on vacation — it lives in the script and benefits every user on the team.

Beyond layout, SKILL is essential for analog design flow automation. The Virtuoso Analog Design Environment (ADE) can be driven programmatically through SKILL to set up simulation campaigns, sweep parameters, manage corners, and collect results. CDF (Component Description Format) callbacks written in SKILL control what happens when a designer changes a component parameter in the schematic. These are deep integrations that external scripting simply cannot replicate.

SKILL Use Cases in Production Design

The following use cases represent the most common and highest-value applications of SKILL scripting in production semiconductor design environments.

Parameterized Cells (PCells)

PCells are the single most important application of SKILL. A PCell is a layout cell whose geometry is generated by code rather than drawn by hand. The code — a SKILL function — takes a set of parameters and produces the corresponding layout shapes. For example, a MOSFET PCell takes width, length, number of fingers, gate contact style, and well/substrate options as parameters, and generates a DRC-clean layout that matches those specifications.

The power of PCells becomes clear when you consider how many variants a single device needs. A MOSFET with width from 1 to 500 microns, length from minimum to 10 microns, 1 to 20 fingers, and various contact and guard ring options generates thousands of possible configurations. Without PCells, each configuration would need to be drawn by hand. With PCells, the layout engineer instantiates the cell, sets the parameters, and the correct layout appears.

Writing production-quality PCells is a specialized skill. The code must handle edge cases (what happens when the width is so small that two fingers overlap?), generate clean DRC and LVS results, and integrate with the foundry's design rules. Well-written PCells include parameter validation, default values, and documentation so that other engineers can use them confidently. SkyCadEda'sSKILL scripting services include production PCell development for foundry and custom design flows.

Layout Automation Tools

Beyond PCells, SKILL powers a wide range of layout automation tools. These include automatic guard ring generators that surround devices or blocks with the correct well and substrate rings, routing assistants that automate common routing patterns like differential pairs and current mirrors, DRC-aware placement tools that enforce minimum spacing during interactive editing, and batch layout modification scripts that update properties across hundreds of instances at once.

Layout automation through SKILL also covers repetitive tasks like generating standard cell layouts from truth tables, creating fill patterns for metal density compliance, extracting parasitic-aware layout annotations, and generating layout-versus-schematic markers for debug. Each of these tools encodes domain knowledge into repeatable automation. For more on layout automation specifically, see ourlayout automation services.

Custom GUIs and Interactive Tools

SKILL's UI API lets you build custom graphical interfaces inside Virtuoso. These GUIs present complex operations as simple forms that any engineer can use without knowing SKILL. A PCell configuration GUI, for example, might present a dropdown for device type, sliders for width and length, checkboxes for options like guard rings and deep N-well, and a preview of the resulting layout. Under the hood, the GUI calls SKILL functions that generate the layout, check constraints, and write the cell to the database.

Custom GUIs are particularly valuable for team-wide tools. A senior engineer can package their expertise into a GUI tool that junior engineers use to perform complex operations correctly and consistently. The GUI enforces the right defaults, validates inputs, and prevents common mistakes — effectively training the user while they work.

CDF Callbacks and Schematic Automation

The Component Description Format (CDF) in Virtuoso controls how components behave in the schematic editor. CDF callbacks are SKILL functions that execute when a user changes a component's parameter, opens its properties dialog, or performs other actions. Well-implemented callbacks validate parameter values, compute derived parameters, update the component's display, and ensure that the schematic stays consistent with the design intent.

For example, a resistor CDF callback might automatically compute the number of segments based on the desired resistance and sheet resistance, update the component's display to show the computed value, and flag an error if the requested resistance is not achievable with the available geometry options. This kind of intelligent behavior is implemented entirely through SKILL callbacks attached to CDF parameters.

Bindkeys and Command Extensions

SKILL lets you bind custom functions to keyboard shortcuts (bindkeys) and add menu items to Virtuoso's interface. This is one of the simplest but most impactful forms of automation. A bindkey that runs a DRC check on the current cell, a bindkey that centers the view on a selected device, or a bindkey that generates a pin report — each of these saves seconds per use, but those seconds add up over hundreds of uses per day across an entire design team.

SKILL vs Tcl vs Python: Choosing the Right Language

A common question from teams building their automation strategy is which language to use. The answer depends on the tools and the tasks.

SKILL: The Virtuoso Native Language

SKILL is the right choice when you need deep integration with Virtuoso. PCells, CDF callbacks, custom GUIs, interactive bindkeys, and direct database manipulation all require SKILL. No other language gives you the same level of access to the Virtuoso environment. If your work lives inside Virtuoso, SKILL is the foundation.

Tcl/Tk: The Synopsys and Verification Standard

Tcl is the native scripting language for Synopsys tools (Custom Compiler, ICC2, PrimeTime) and for Calibre. If your flow includes these tools, Tcl is essential. It is also widely used for flow orchestration — controlling tool execution, parsing logs, and managing file I/O. Tcl's syntax is more conventional than SKILL's, and its Tk toolkit is useful for building quick GUIs. In many production environments, Tcl scripts orchestrate the flow while SKILL scripts handle the Virtuoso-specific steps.

Python: The Integration Layer

Python is the best choice for cross-tool integration, data analysis, report generation, and web-based interfaces. It is increasingly supported within EDA tools themselves, but its primary value is as a glue language that connects different tools and processes. Python excels at parsing data from multiple sources, generating reports in various formats, and building management dashboards. For teams starting new automation projects, Python offers the gentlest learning curve and the broadest applicability outside the EDA domain.

The Practical Answer: Use All Three

In production environments, the best automation uses the right language for each task. SKILL for Virtuoso integration. Tcl for Synopsys and verification tool control. Python for data processing, reporting, and cross-tool orchestration. Shell scripts for job scheduling and environment management. The languages interoperate well — a Python script can call a Tcl script that controls a tool which runs SKILL internally. Building multilingual automation is a sign of a mature CAD organization.

Getting Started with SKILL Scripting

If you are new to SKILL, start with the Cadence documentation — the SKILL Language Reference and the Virtuoso SKILL Functions Reference are the definitive sources. Cadence also offers training courses and online resources through their support portal. The best way to learn is by doing: pick a simple task you perform repeatedly in Virtuoso and write a SKILL script to automate it.

A good first project is a bindkey that performs a useful operation — opening a specific report, toggling a display setting, or navigating to a frequently used cell. From there, move to simple layout manipulation scripts: reading cell data, iterating over instances, modifying properties. Once you are comfortable with the database API, try building a simple PCell. Each step builds on the previous one and expands what you can automate.

For production automation needs, consider working with an experienced SKILL development team. Writing SKILL that works in a demo is one thing; writing SKILL that runs reliably across thousands of cells, handles edge cases, and is maintainable by other engineers is a different discipline. SkyCadEda'sCadence SKILL scripting services provide production-grade development with full documentation, testing, and knowledge transfer so your team owns the code long after the engagement ends.

The Strategic Value of SKILL Expertise

In an industry where experienced SKILL programmers are increasingly scarce, investing in SKILL capability is a strategic decision. Companies with strong internal SKILL skills can adapt their design flows quickly to new technology nodes, new tool releases, and new design challenges. Companies without that capability are dependent on external support and slower to respond to change.

Whether you build that capability internally, bring it in through specialized consulting, or use a combination of both, SKILL scripting remains the single most impactful automation investment for any team whose design flow runs on the Cadence Virtuoso platform. It is the difference between using Virtuoso as a drawing tool and using it as a programmable design engine.

Related Articles

• What Is EDA Automation?
• CAD Infrastructure for Semiconductor
• PDK Setup and Enablement
• DRC/LVS Physical Verification
• Synopsys Custom Compiler Automation
• ASIC Design Flow & Platform Support
• Tcl/Tk for EDA Automation
• Virtuoso Layout Automation
• GDSII OASIS Layout Automation
• FlexNet Licensing for EDA Tools
• Open Source EDA Tools Guide
• RISC-V EDA Tools Guide
• Advanced Node Verification
• Cloud EDA SaaS Solutions
• DFT Design for Test Automation
• Timing Closure Automation Guide
• Calibre SVRF TVF Rule Decks Guide
• Python EDA Automation Guide
• IP Porting and Migration Guide
• Mixed-Signal Verification Guide