Layout -- Details

OK, so we’ve covered the basic objects, and how they are created, and we’ve covered hierarchical design, view levels and layers. Let’s dig in a bit deeper with some more details....

Use Hierarchy

To the extent reasonably possible, use hierarchy in your design. It often makes both mask-masking and e-beam writing faster, and thus cheaper. For certain more advanced options such as proximity correction, the time/cost savings can be significant. It also makes design modifications much easier, and many times, it’s necessary to do design several iterations of design modifications to get your final desired lithography. Most mask shops specifically request that you do not send them flattened data (that is, data without hierarchy) because it adds too much to their overhead.


There are some very important details about polygons of which you should be aware:

Illegal Polygons

It is possible to create various illegal polygons. Self-intersecting polygons, such as shown here, are not legal in any known mask-making or e-beam system.

Although self-intersection or self-overlapping polygons are illegal, self-touching polygons, in which one or more sides touches another side, but not overlaps, are allowed, and are a way to have “holes” inside of other shapes.

Creating Holes In Shapes
So how do you create a shape with a “cut out” or hole in it, such as shown on the right above? In KLayout, it’s pretty easy, as shown in the next figure. Create the larger shape and the smaller “hole” shape that you want to cut from the larger shape. Next, first select the outer shape you want to subtract from, then holding down the SHIFT key, select the shape (or shapes) you want to subtract from the first shape. Then select Edit : Selection : Subtraction - Others from First. and the shape on the right is what will remain.

In this second example of the same command, you can see this same technique also works for removing notches from edges or corners, or multiple holes in one operation. The output polygon from this operation should always be a legal GDSII polygon.

Making Curves

You may have noticed that every shape described so far has been a square or rectangular polygon. It is possible to make curves, but these are really just polygons with multiple vertices. This is achieved in KLayout by selecting one (or more) boxes or polygons, and then Edit : Selection : Round Corners... Here’s an example showing a 50 um square, and then two corner radii, one which results in a rounded square, the other in a circle. When rounding polygons, you do need to be aware of the fabrication tool you plan to use -- for many systems, curves can create an explosion in the data the exposure tool needs to process and expose, which can cause the exposure time to multiply rapidly (and fabrication cost usually scales with exposure time...)

Consider, for example, making very small circles with the JEOL ebeam. You may well be able to use a simple square, which, given electron scattering and resist processing rounding, may come out to be a nice, round dot. If you choose to use 8, or 16 sides for your circle, be aware that the number of shapes the JEOL has to expose goes up quickly:

The 8 sided figure requires 4 shapes to expose, while the 16-sided dot has 17 shapes. Why does shape count matter? Well, it directly impacts exposure time, and time is money, so the more sides per shape, the more money your exposure will cost. If you’re making a few dozen or a few hundreds of dots, the difference is completely negligible. But if you want to cover a large area with arrays of closely-spaced dots, the dot count can quickly become enormous -- I’ve written ebeam dots at 2 x 1010 dots per square centimeter, where shape overhead becomes very significant. For one example, the increment in exposure time from a square to an octagon is about 30% increase in exposure time. For a 16-sided shape, the overhead quickly soars to 340% increase in exposure time -- 3.4 times a long for the same area! The lesson: it pays to consider how many points to make your curves and circles.

Vertex Count in Polygons

If you’re making curved or complicated polygons, you can get shapes with many, many vertices in each polygon. This has long been a problem-spot with GDS-II data interchange, in particular in research. In integrated circuit manufacturing, by far the largest application of GDS-II, most shapes are simple, orthogonal (sometimes called “Manhattan”) geometries. Anyway, some older software only supports up to 200 vertices per polygon. Other more modern systems support up to 1000 vertices, maybe 2047, in some cases 8192 vertices, and some systems use extensions to allow an arbitrary number of vertices per polygon.

Here are two polygons -- the left one has 16 vertices, the right one has corners rounded off, and has 1440 vertices. This second polygon might create an illegal polygon on some data conversion systems. (One solution is to break this larger polygon into smaller polygons, each of which has fewer vertices.)

Layer Numbers

The upper limit for both layer numbers and datatypes is of some ambiguity with the GDSII data format. The most common range for both Layer numbers and Datatypes 0-255. Very old systems may only support values in the range 0-63, and systems with unofficial extensions often support up to 1023, 2047, or even 8191 layers and/or datatypes in a file. There’s no way to know in advance what values your mask-making or writing system can handle; you’ll have to check before you make your design. Of course, the safest option is just to stay in the range 0-63 for both layer and datatype values; all known systems support values in this range.


You may have noticed that objects you create have an additional value assigned to them called a “Datatype”. The Datatype is an integer, also in the range of 0-255 (or 63 for older versions of GDSII, and sometimes 1023, 2047 or 8191, for extended versions of gdsii.) In general, datatype isn’t used for much, but in e-beam, there’s a very valuable function for this value -- it can be used to identify which shapes should receive different exposure doses during ebeam writing. So if you assign different datatypes to different shapes, you will be able to assign different doses to each of those datatype values in the ebeam’s JDF file, provided you prepare the pattern data taking this desired datatype-to-dose mapping into account, as described here.

Exposable text

As mentioned earlier, the TEXT primitive type is not normally exposed by any mask-making or ebeam tools. To have labeling text appear on a mask or ebeam-written layer, the text must be converted to polygon shapes. There isn’t a great way to do this within KLayout, yet, but I have two other paths by which this can be achieved, so talk to me if you need this capability.


By all means, use KLayout’s GRID capabilities when you are building your layout. While it’s easy to just click away and draw shapes that are about the size you want, and appear near the locations you want, carelessness with size and placement of your shapes will often result in problems later. You want to consider your design and placement grids from the start of your design, in which case, you need to consider how your masks will be built. If you design to a smaller grid, or place shape vertices off-grid, they will be rounded to the nearest grid point, which might cause problems with your design, by, for example, shifting some shapes or changing the size of some shapes as they snap to the nearest grid point. So what grid should you use? Well, as always, that depends on the capability of your mask making shop or ebeam. PhotoSciences, for example, specifies the use of a 1 um grid for all layouts. CompuGraphics is a considerably more expensive mask shop, and like many mask shops, has a range of grid options available, but indicates rapidly increasing price with smaller grid sizes. The design grids they offer include: 0.125 um (=$), 0.1 um (=$), 0.0625 um (=$$), 0.05 um (=$$$+), 0.03125 um (=$$$$), 0.025 um (=$$$$$). (Yes, the $-signs are their indication of price!). Why so much more expensive? Well, the in general, machine time goes as the inverse square of machine grid, so the time for a 0.025 um grid mask may be up to 25X longer than a 0.125 grid mask, and well, as the saying goes: time is money.

For our direct write ebeam, the grid sizes are discussed in detail here. The placement grid is typically 1 nm, while the exposure grid is mostly often some even integer multiple of this value, ranging from 2 nm (medium current HSQ exposures) to 20 (high current maN exposures).

In KLayout, there’s quite a bit of flexibility in how grids are implemented, which means some complexity as well. And grid behavior is set in three distinct locations, which complicates usage a bit. The primary feature to be aware of is that the snapping grid, the grid that vertices will be placed on, can be different from the displayed grid, where dots are shown. The snapping behavior is set in the Object Editor Options dialog, (Edit : Editor Options...) where you set whether snapping occurs on no grid at all (in which case, vertices are to the nearest database unit, which is seldom what you should be using), the “Global Grid”, which is the displayed grid in KLayout, or to some other grid you set in that dialog. The “Global Grid” is turned on or off with View : Show Grid, and the global grid spacing is selected either with the menu option: View : Grid... or from Preferences : Application : Grid, where you can the “Grid For Display and ruler snapping.” Nearby, in Preferences : Application : Default Grids, you can set what grid values appear in the View : Grid... menu list. Finally, you control the appearance of the grid, color and style, under Preferences : Display : Background. Phew, complex, isn’t it? Well, you’ll have to try out the various settings and find what works for you, but your results will generally be better (faster, more accurate and consistent) if you take care to use proper grids when doing your layout.

Angle Constraints

Closely related to grids are angular constraints, which limits the angles at which you can draw the sides of polygons and paths. You’ll find this setting in the Object Editor Options dialog, (Edit : Editor Options...) under “Angle Constraints”, with two sets of options: connections (which refers to polygon and path edges), and movements (which refers to moving objects). The options are: Any Angle (no constraints at all), Manhattan (aka square, orthogonal to axes, 0 or 90 degrees), or Diagonal (Manhattan + 45 degree angles.) Using either Manhattan or Diagonal will typically help your mask making or ebeam writing by keeping the exposures faster. For most systems, off-angles requires excessive fracturing to make odd angles.

{put figure here}


You should also take some care to place your design origin, the (0,0) coordinate, at some sensible location. The two most common locations are the lower left corner, and the center. Placing the origin arbitrarily will complicate your future work, especially when doing layer-to-layer alignment with the e-beam, where you need to specify the location of each alignment mark with respect to the pattern origin. You will typically have to know your data extents for either ebeam exposures or mask making, and it’s just easier and less error prone to report a data extent such as (0,0) to (3200, 4600) rather than (-1542.23, 7253.02) to (1657.77, 11853.02).

Cell Names

Some CAD systems allow more flexibility than others with respect to cell naming. The official GDSII specification says this:
  • Cell names can be up to 32 characters in length.
  • Legal characters are: A-Z, a-z, 0-9, _ , ?, $
  • Do not start names with numbers

Zero-width Paths

In general, shapes must have area to be exposed by a mask-maker or an ebeam system. There is one exception to this with our JEOL e-beam system. We can use a Zero-Width Path, that is, a PATH primitive with a width specified as 0, to generate what e-beam writers refer to as a “Single Pass Line”, which is a single-trace of the electron beam, independent of the grid sized used. Note that while using Single Pass Lines will allow you to theoretically achieve the smallest possible linewidths, some additional overhead and care is necessary, both during pattern preparation, and job file setup, as you must explicitly enable Single Pass Lines in your LayoutBEAMER conversion, and you must specify a Line Dose value (in addition to the traditional Area Dose value) in your Job Deck File (JDF).

Non-orthogonal Arrays

KLayout allows an interesting extension to arrays of cells -- you can specify an arbitrary X,Y vector between each row and column placement. So rather than arrays just being rectangular, they can be offset or skewed. This figure shows the effect of non-zero off-diagonal elements in the array vector specification dialog. This might be a useful feature for your designs. However, this may or may not work with various mask vendors. I can confirm that skewed array placement does work for LayoutBEAMER converting files to the JEOL ebeam.


Undoubtedly, there are additional design rules and considerations I’m not including here. I’ll try to extend this list as I come up with new issues; let me know if you know of something I’ve omitted here.

If you would like to see more information about CAD layout and good design practices, continue to the Next Page, where I’ve linked to some other sites that have useful information.