The Gerber layers say what the board is; the drill file says where the holes go; the pick-and-place file says where the components sit — and it is the file most likely to be trusted without ever being looked at. Assembly houses consume it directly to programme placement machines, so an error in it does not produce a wrong-looking board, it produces a correctly fabricated board assembled wrong: a connector placed off its pads, a whole row of parts shifted, bottom-side components nobody accounted for. Gerbv closes the loop by viewing CSV pick-and-place files — XY centroid data — as layers in the same stack as your RS-274X Gerber and Excellon drill files. This tutorial covers loading the pick-and-place layer over the board view, reading the overlay intelligently, and the assembly sanity checks that catch bad position exports before an assembler does. Open the board set first with how to open and view Gerber files; Gerbv is on the download page with the Windows installation guide for setup, and our Gerber viewer page covers the viewer’s full format support.
What a pick-and-place file contains
A pick-and-place file is a centroid file: for each component, it records the position of the part’s centre — its XY coordinates — in the same board coordinate space as the Gerber data. Depending on the exporting tool, the file may also carry each part’s reference designator, its value or package, and its rotation, which is why the format travels under several names: XY, XYRS and CSV pick-and-place files all appear in the project’s documentation history, and the man page describes pick-and-place input as XY (centroid) files produced by the PCB design program. The essential point for viewing is that the data is positional and tabular, not graphical: until something draws it over the board, an origin slip or mirrored export hides inside a perfectly plausible-looking spreadsheet of numbers. Gerbv’s contribution is exactly that drawing step — positions become visible objects, in registration with the copper they belong to.
Loading the pick-and-place layer over the board
Build the board stack first — copper layers, mask and outline, following loading and aligning Gerber layers — then open the CSV pick-and-place file from the main window so it joins the layer list as its own layer, stacked where you can toggle it over the top copper and silkscreen. If you opened the fabrication folder in one step, remember that Gerbv loads the loadable files it finds by content in alphabetical order, so the position file is already present and simply needs to be identified in the list. Give the layer a colour nothing else uses; component positions are sparse points compared with the dense copper, and a distinct colour keeps them legible without needing to hide the layers beneath. Start, as with drills, at the whole-board view: the pattern of positions should read as the board’s component layout — dense where the design is dense, empty where it is empty, everything inside the outline. That first glance is the audit’s foundation, because the common pick-and-place failures are all visible at exactly this scale.
Reading the overlay: the assembly sanity checks
Now interrogate the pattern. Coverage: every populated area of the board should carry positions, and every position should sit on a component’s pads — toggle the pick-and-place layer over the top copper and check the connectors and large parts first, because their centres are unambiguous, then sweep the fields of small parts where a missing position is easy to miss. Orientation plausibility: where positions form rows and arrays, they should follow the orderly pattern of the footprints beneath them; a single position floating off-grid, or a cluster at the board origin, usually means one part was placed in the design at a stray location or exported from a different origin. Inside the outline: no position should fall outside the board edge or inside a cutout — the assembly equivalent of the drill check in viewing Excellon drill files. Side awareness: know whether the file contains top-side parts, bottom-side parts or both, and view bottom-side positions against the bottom copper, not the top. And where the exported file includes designators, cross-check a few against the silkscreen layer — the position the file calls one reference should sit on the footprint the silkscreen labels with that reference.
Scale, origin and mirror: the three failures this catches
Pick-and-place exports fail in the same three geometries as drill files, and the overlay exposes each one instantly. A scale failure — positions interpreted in the wrong unit — spreads the components across an area 25.4 times too large or compresses them into one corner, invisible in the CSV and grotesque in the viewer. An origin failure keeps the pattern’s shape perfect but shifts it as a block relative to the pads, which is why the check must be done against the copper and never by looking at the position layer alone. A mirror failure — most often a bottom-side file exported as if viewed from the top — produces a pattern that matches the board only when flipped, with symmetric areas looking deceptively fine and asymmetric features betraying it. All three are export-setting problems in the EDA tool, fixed by re-exporting the position data with the same origin, units and side conventions as the Gerber set — and all three are vastly cheaper to find in this viewer, with measurement to confirm a suspect position’s coordinates against the footprint it should centre on, than on an assembler’s line.
Sharing the assembly view, and the honest limits
The overlay is also a communication tool: export the pick-and-place layer over the silkscreen and copper to PNG or PDF using the picture export workflow, and you have an assembly reference an assembler or a hand-soldering colleague can actually use — positions in context, rather than a raw CSV. Keep the limit in view while doing so: Gerbv views position data; it is not assembly software. It does not manage bills of materials, generate placement programmes or check parts against a library. The sanity check described here is a visual audit by the designer, and its power is that it puts the assembler’s data in front of the designer’s eyes, in registration, before the data drives any machine.
Frequently asked questions
Which pick-and-place formats does Gerbv view?
CSV pick-and-place files — XY centroid data of the kind PCB design programs produce; the format also appears as XY and XYRS in the project’s documentation. Gerbv draws the positions as a layer over your Gerber stack.
What is the fastest way to spot a bad pick-and-place export?
Overlay it on the copper at whole-board zoom. Scale errors compress or explode the pattern, origin errors shift it as a block off the pads, and mirror errors only match the board when flipped — all three are obvious visually and nearly invisible in the raw CSV.
Can Gerbv check my bill of materials or programme a placement machine?
No. Gerbv views position data in registration with the board so you can audit it visually. It does not manage BOMs, generate placement programmes or check parts against a library.