The hardest faults to see in a layer stack are the ones that only exist between layers: a solder mask opening that misses its pad by half its width, a silkscreen line crossing exposed copper, a via that lands half on a trace and half on a gap. Viewed one layer at a time, every file looks plausible; viewed stacked at full opacity, the board is an illegible tangle in which the top layer hides everything beneath it. Transparency is the tool that threads between those two failures, and in Gerbv it comes from the Cairo renderer — Cairo rendering with a transparency mode, showing you which layers are underneath other layers, has been part of the program since the 2.0.0 era. This tutorial explains what Cairo rendering and transparency actually do in the viewer, and how to work a stack systematically with them to surface the between-layer faults. It builds directly on loading and aligning Gerber layers; Gerbv itself is on the download page (see the macOS installation guide for that platform), and our Gerber viewer page covers the wider inspection this technique belongs to.
Cairo: the renderer underneath the view
Gerbv draws its board view with Cairo, the 2D graphics library that also powers its exported images — the picture exports to PNG, PDF, PS and SVG exist because of Cairo, and command-line image export is documented as a Cairo path. That shared rendering is worth understanding: the transparency you set up in the viewer, the antialiasing that keeps fine traces readable at odd zoom levels (the command-line export documents an antialias option), and the colours you assign are not a screen approximation of the board — they are the same rendering that produces the documentation you export in exporting to PDF, PNG or SVG. Historically there was also a GDK drawing path, described as the legacy, faster frontend; the project’s direction has been to retire it in favour of Cairo as part of a longer-term GTK port plan, and Cairo is the renderer current releases are built around. For inspection purposes, the practical translation is: learn to drive the one renderer well, and both your screen checks and your exported records improve together.
What transparency changes about a stack
At full opacity, a stack shows you the top layer and hides the rest; transparency lets each layer be drawn see-through, so overlapping geometry from several layers is visible in one view, with colours blending where features coincide. That single change converts several checks from memory exercises into direct observations. A solder mask layer drawn transparently over its copper shows at a glance whether each mask opening is centred on the pad it exposes — offset openings announce themselves as crescents. A transparent drill layer over copper, the overlay from viewing Excellon drill files, shows concentricity everywhere at once instead of hit by hit. Silkscreen over mask and copper shows whether ink stays on mask or strays across pads. And two copper layers drawn transparently together reveal the relationship between a via and the features it passes on the other side. In each case the fault class is the same — a spatial relationship between layers that no single-layer view contains — and transparency is what makes that relationship visible.
Working a stack systematically with transparency
Transparency rewards method, because a fully transparent six-layer stack can be as confusing as an opaque one. Work in deliberate pairs and triples, in the physical order of the board. Start with one copper layer and its own solder mask: assign them distinct colours from the layer list — right-clicking a layer offers per-layer operations including changing its colour — set the mask see-through, and scan pad by pad class: connectors first, then ICs, then discretes. Add the silkscreen for that side and repeat the pass looking only at ink-versus-pad relationships. Then switch sides and do the same for the bottom pair. Bring the drill layer in transparently over each copper layer in turn for the registration pass. Only at the end, if you want the record image, assemble the full stack transparently and export it; the full composite is a fine summary picture, but the pairwise passes are where faults are actually found. Zoom discipline matters as much as layer discipline: at whole-board zoom, transparency checks orientation and gross alignment; the crescent mask openings and half-landing vias only exist at magnifications where pads are centimetres wide on screen, which ties this technique to the habits in measuring distances and clearances — see it transparently, then measure it to be sure.
Colour choices are part of the technique
Because transparent layers blend, colour stops being decoration and becomes encoding. Give each layer family a consistent hue across every board you inspect — copper one family, mask another, drills a high-contrast accent — so a blended overlap colour means the same thing in every session: when mask-over-copper always produces the same combined tone, a pad whose tone differs stands out before you consciously analyse it. Avoid assigning two layers colours that blend into a third layer’s colour, and avoid red-green pairings as the sole distinction between two layers, for the usual readability reasons. None of this requires any feature beyond the documented layer operations — visibility, colour change, reload — plus the transparency mode itself; the technique is in the workflow, not in exotic settings.
Limits: transparency shows, it does not judge
End with the honest boundary, as with every Gerbv capability. Transparency and Cairo rendering show relationships with great clarity, but Gerbv does not evaluate them: there is no design-rule or DFM checking in the program, no automatic flag that a mask opening is undersized or a clearance too tight — the report windows summarise codes and apertures, and the judging remains yours. A transparent view can also mislead the hurried: a blend that looks like overlap can be two features at different depths that never interact physically, which is why the pairwise, board-order discipline above matters. Used that way — renderer understood, pairs checked in order, colours encoding layer families, suspicions confirmed by measurement — transparency is the closest thing a 2D viewer has to holding the board up to the light, and it is the technique this site’s other tutorials keep pointing back to.
Frequently asked questions
What does transparency mode actually do in Gerbv?
It draws layers see-through using the Cairo renderer, so geometry from layers underneath remains visible through the layers above. That makes between-layer relationships — mask openings over pads, drills over copper, ink over mask — directly visible instead of inferred.
Is the Cairo rendering the same as what gets exported?
Yes — Cairo is also the rendering behind Gerbv’s image exports to PNG, PDF, PS and SVG, and command-line image export is a documented Cairo path. The colours, transparency and antialiasing you set up for inspection carry into exported documentation.
Can transparency find shorts and errors automatically?
No. Transparency makes potential problems visible to you; Gerbv has no design-rule or DFM checking and flags nothing automatically. Confirm anything suspicious with the measure tool and your own checklist.