I understand that klayout is largely code-centric, less a
classical GUI CAD system once you get past the basic
polygon-pushing. But for a guy like me, whose layout
abilities are adequate but last serious programming was
many decades ago, there is value in a "meta-layer" that
could produce the effects of script development but in
a "visual programming" style (or just sub-GUIs for some

I would like to suggest that the developers consider this.

For example, I used to get good throughput in creating
transistor PCells using Cadence's graphical PCell interface.
It wasn't that fancy, but you could place stretch-lines and
edit their properties, select a group of objects and assert
stepping or conditional presence, and that sort of stuff
sufficed for me to build libraries of BJT, MOS, passives,
etc. in my time developing silicon processes and doing
chip design based on what I created.

I imagine that something like this could either be an internal
feature-bundle, or that it might be an add-on script-pile.
The set of functions and actions is not large.

As another example I was looking at Glade DRC, extract
examples the other day and they looked a lot like old Diva
decks, like Silvaco Guardian decks. Simple and fairly
obviously-named verification commands, object and rule
arguments, easier to understand and pick than what I am
baffled by in the object-oriented scripting. Seems to me
that a "meta-layer" which produces lines of script from
a GUI or (quite valuable, perhaps) a commercial tool
verification deck would really ease the pain of developing
or porting verification decks. Like maybe the GUI has a
pulldown menu for the DRC common verification tasks,
lets you enter layer1, layer2, criterion, message in fields
and "bang!", there's a copy / pastable code snippet that
is built syntax-correct, referring to the low level functions
that get it done (so the newbie or learning-resistant can
not have to figure that out from docs and choose among
sometimes quite similar-named functions and understand
all the details). Or what about a straightforward translation
(parser?) for the "existing verification deck in hand" - couldn't
many of "the usual suspects" like space, width, nest, etc.
be pretty easily mapped to a consistent OO script form,
transfer the args, like? Anything that can't be so translated,
for complexity or obscurity or lack of manpower, just flag
it - but let the machine do the grunt translation without
making so many typos?

Maybe an extraction deck builder similarly, but letting the
user click-select features to assign connectivity to a
layout cell with some "relationship" fields (like maybe I
want to use CONT, which is inside NPLUS and PBAS,
to be "E" terminal - couldn't this be done by pick-to-list?

Just putting it out there....


  • Some looong time ago I coded some script which turned a Cadence schematic view into a Calibre rule deck.

    The idea is to use schematic symbols to represent operations: there is a WIDTH check operation (with options), and AND, OR, NOT and various other symbols. Nets are layers. The operations have input ports (input layers) and output ports (generated layers). There are output "pins" for the check outputs and input "pins" for the original layout layers.

    The script generator essentially is a special kind of netlister then. This wasn't a productive tool but a proof of concept.

    Unfortunately this code went down with the company I used to work for by then. But the idea isn't patented AFAIK.

Sign In or Register to comment.