Copper layers: the circuitry itself

Copper layers are the board’s wiring: tracks, pads, vias and poured planes, etched from the copper foil. A simple board has two — top and bottom — and multi-layer boards add inner copper layers that you will never see on the finished product but which carry signals and power planes inside the stack. In a viewer, copper is the densest, busiest artwork: fine tracks routing between pads everywhere the design goes. Copper is the reference layer for the whole set — drills must land on its pads, mask openings must expose the right parts of it — which is why alignment checks like loading and aligning Gerber layers always start from copper.

Solder mask: the protective skin

Solder mask is the coloured coating — most often green, but any colour you have seen — that covers the board and insulates the copper, leaving openings only where solder joints belong: pads, vias the design wants exposed, test points. Its Gerber file therefore looks like a near-solid sheet with holes punched in it, the photographic negative of the pad pattern. That inversion confuses first-time viewers: the mask file shows mostly what will be covered, and its information lives in the openings. Every opening should sit over copper that is meant to be solderable; mask accidentally covering pads is a classic assembly disaster that a stacked view exposes instantly, since the pads simply vanish under the sheet.

Silkscreen: the printed legend

Silkscreen — also called legend — is the white (usually) printed text and graphics on the board’s surface: component outlines, reference designators like R12 and U3, polarity marks, logos and revision notes. It carries no electrical function at all, which makes it the easiest layer to recognise: sparse ink floating over empty space, readable as language and symbols rather than circuitry. Its checks are human ones. Text must not print over pads (ink on a solder joint is a defect), designators should sit beside their components rather than under them, and the bottom-side legend, if any, should read correctly for the side it is on — a mirrored silkscreen is a frequent export slip that only a look at the actual layer will catch.

Solder paste: the assembly layer

The paste layer describes where solder paste is deposited through a stencil before surface-mount components are placed and reflowed. In the viewer it is the most minimal of the set: only the surface-mount pads appear, as neat arrays of rectangles and circles matching the footprints — nothing for through-hole parts, nothing for tracks. A board with no surface-mount components legitimately has no paste layer, which is a fact to know before reporting one missing. Where paste exists, its check is correspondence: every surface-mount pad on the copper should have a matching paste opening, in the same place, at a sensible size.

Outline: where the board ends

The outline — also called the profile, edge or board shape layer — is a simple closed line (or set of lines) defining the board’s boundary and any internal cutouts or slots. It looks empty compared to the others, and it is one of the most important files in the package: the fab cuts to it, quotes from its dimensions, and judges whether everything else fits inside it. Check that the profile is truly closed, that it measures to the designed size — the measurement routine is in measuring distances in Gerbv — and that no copper, text or stray shape sits outside it.

Recognising layers in Gerbv

Put together, recognition is a visual skill with reliable tells: copper is dense and everywhere, mask is a solid sheet with pad-shaped holes, silkscreen is sparse readable marks, paste is only footprint pads, outline is a bare closed profile, and the drill file — Excellon, not Gerber — is a field of circles that must register with the copper. Load the set in Gerbv (free from the download page), toggle layers over the top copper one at a time, and each type announces itself. The Gerber viewer hub ties the whole inspection together into a pre-order routine.

Frequently asked questions

How many copper layers does a board have?

At minimum the two outer sides, top and bottom. Multi-layer boards add inner copper layers for signals and power planes — each is its own Gerber file in the package, recognised by dense track-and-pad artwork like the outer copper.

Why does the solder mask file look almost solid?

Because the mask covers nearly everything: the file describes the coating, and its meaningful features are the openings left over pads and other solderable points. It is effectively the negative of the pad pattern, which is normal and correct.

Which layer defines the board’s size and shape?

The outline (profile) layer — a closed line the fab cuts to. Measure it in the viewer against your design dimensions, confirm the profile is closed, and check that no artwork from any other layer falls outside it.

The Gerber model: images plus attributes

A Gerber package is a folder, not a document. Each file is a complete, self-contained image of one layer — top copper, bottom copper, mask, legend, paste, outline — drawn with apertures, and the drill data rides alongside as a separate Excellon file. Gerber X2’s contribution to this model is the attribute system: inside each file, structured metadata records the layer’s function and can attach part and net information to the objects drawn. But the model stays plural and image-first. The board is the sum of its layers, and anything the layers do not say — the stackup order and materials, the finish, the assembly data — travels in other documents: a fabrication drawing, a readme, a BOM, a pick-and-place file.

The IPC-2581 model: one XML, whole intent

IPC-2581 starts from the opposite end. It is a single XML file built on an industry standard, designed so that the one document can describe the board comprehensively: the layer images, the stackup that orders and specifies them, the components and bill of materials, and the assembly and test intent alongside fabrication. Where Gerber says “here are the pictures, with labels”, IPC-2581 says “here is the board, described”. The appeal is structural: nothing essential has to live in a side document that can be forgotten, version-skewed or misread, because the format has a place for it inside the file itself.

Why most fabs still ask for Gerber

If one format carries more, why does the industry default remain Gerber? The honest answer is ecosystem, not merit in the abstract. Gerber has decades of installed tooling behind it: every CAD package exports it, every fab imports it, every viewer — including Gerbv — reads it, and every engineer’s checking habits are built around it. A fab’s request is really a statement about its own pipeline: send the format our import, quoting and CAM preparation are proven on. Some fabs accept IPC-2581 as well, and if yours does and your CAD tool exports it well, using it is a legitimate choice. But “supported somewhere” is not “accepted everywhere”, and the safe universal deliverable remains a checked Gerber set. Always follow your specific fab’s stated preference over any general argument — including this one.

What this means for checking your files

Your verification routine follows the model of the files you actually send. Send Gerber, and the check is the familiar one: open the set in Gerbv (from the download page), stack the layers, confirm the drills register, measure the outline, read the aperture and drill statistics — the flow on the Gerber viewer hub and in the pre-order checklist. Gerbv views Gerber RS-274X (including X2 files, whose images it renders) plus Excellon and CSV data; it does not read IPC-2581, because it is a Gerber viewer and the XML model is a different country. If you send both formats to a fab that accepts both, check both — the Gerber pass in a viewer, and the IPC-2581 export by whatever tooling your flow provides — because a correct Gerber set says nothing about a stale XML export sitting beside it.

The practical bottom line

Think of the choice as images-with-labels versus a single structured description, and of your fab’s intake desk as the referee. Gerber X2 is the lingua franca: universally exportable, universally importable, and checkable in free tools on any desktop. IPC-2581 is the more ambitious container, available where the toolchain at both ends supports it. For most readers, most weeks, the winning move is unglamorous: export clean Gerber X2, name the files clearly, include the stackup and finish in your order notes, and verify the exact set in a viewer before it leaves your machine.

Frequently asked questions

Is IPC-2581 better than Gerber X2?

They are different models rather than a ranking. IPC-2581 carries more of the board’s intent — stackup, components, BOM — in one XML file. Gerber X2 is layer images plus attributes, and wins on universality: every CAD tool exports it and every fab accepts it. Your fab’s preference decides.

Can Gerbv open IPC-2581 files?

No. Gerbv is a Gerber viewer: it reads Gerber RS-274X files (including Gerber X2, whose layer images it renders), Excellon drill files and CSV pick-and-place files. IPC-2581’s single-XML model needs tooling built for that format.

If my fab accepts both, which should I send?

Send the one your own workflow can verify best, and check exactly what you send. Many engineers send the Gerber set they have inspected layer by layer in a viewer, since that verification habit is proven; if you send IPC-2581, verify that export through its own tooling.

The 2026 revival (current era)

• v2.13.0 — March 20, 2026. The current stable release. First release with native Windows and macOS builds: an NSIS Windows installer, a native MSYS2 UCRT64 Windows ZIP, an official macOS ZIP, plus Ubuntu 22.04 / Debian 13 .deb and Fedora 43 .rpm packages. Six assets, each with a published SHA-256. Covered in depth in Gerbv 2.13.0: first native Windows and macOS builds.
• v2.12.0 — March 8, 2026. DXF export became built in on all platforms; new optimised SVG export with optional Inkscape layers. Four assets: Debian, Fedora and Ubuntu packages and a Windows amd64 ZIP. That Windows ZIP (gerbv_v2.12.0_.Windows.amd64.zip, 41,497,359 bytes) does have a published digest — SHA-256 90409c5a92ef885f8dfa2b33112deb4b36122d6110bf5576c6669d151d43d576 — noticeably larger than the slim 2.13.0 Windows builds that replaced it.
• v2.11.1 — March 2, 2026. A quick follow-up release in the same four-asset layout.
• v2.11.0 — February 28, 2026. The comeback release: the first after the project’s CMake rewrite of its build system, introducing the modern packaging pattern (.deb, .rpm, Windows ZIP; Windows build is 64-bit).

The quiet years: 2.10.0 and 2.9.x

• v2.10.0 — August 21, 2023. The last release before the long pause — a single Windows amd64 ZIP asset on GitHub. Roughly two and a half years separate it from v2.11.0, which is why older pages sometimes describe Gerbv as abandoned; that description is outdated.
• v2.9.8 — June 24, 2023, preceded by v2.9.7 (May 25, 2023) and v2.9.6 (January 4, 2023). Each shipped with a single Windows amd64 ZIP on the GitHub repository.

A checksum warning for this era: the older 2.9.x and 2.10.0 Windows ZIPs carry no published SHA-256 digest in the GitHub release metadata. Any website that prints a tidy hash table for those files invented it. If you run an old build, obtain it from the GitHub releases archive itself and treat the source as the verification — and understand that you are running it without a publisher checksum to check against. Current builds do not have this problem: every v2.13.0 asset on the download page lists its real digest.

The SourceForge era

Before GitHub, Gerbv lived on SourceForge, where it was registered in 2001. Its announcements there mark the early milestones — 2.0.0 in January 2008 brought the much more powerful layer-control GUI, Cairo rendering with transparency, report windows and command-line export; 2.1.0 in September 2008 added RS-274X and Excellon export (format translation and file “cleaning”), object selection with deletion, panelisation from the command line, and the libgerbv library split. The SourceForge files area still serves tarballs from that era (up to the 2.3.0-era sources), and the project page shows a 4.6 out of 5 rating from 26 ratings and 1,247,968 all-time downloads — historical figures for the whole project since 2001, not numbers for any current version. SourceForge itself now points visitors to the modern official site, and current releases ship only via GitHub.

Where to get older versions

Every release discussed here is archived on the project’s GitHub Releases page (github.com/gerbv/gerbv/releases), newest first; scroll back or use the tags to reach 2.12.0, 2.11.x, 2.10.0 and the 2.9.x line. That archive is the only source this site recommends for old binaries — it is the project’s own channel, so an old file there is as official as an old file gets. For current use, though, there is rarely a reason to go back: v2.13.0 is the stable release, with per-platform guides for Windows, macOS and Linux, plus the portable Windows ZIP.

The Windows 7 exception

The one deliberate reason to install an old Gerbv is Windows 7. The upstream README is explicit: Windows 7 is supported only up to release 2.8.0. The 2026 Windows builds are 64-bit, tested on Windows 10. So a Windows 7 machine should take 2.8.0 (or older) from the releases archive, accepting that it misses the CMake-era packaging, the built-in DXF export from 2.12.0, and the native-build improvements of 2.13.0. On any supported system, install the current release instead — and if you are not sure which version you have, the timeline above plus the download page will tell you how far behind you are.

Frequently asked questions

What is the latest version of Gerbv?

v2.13.0, released on March 20, 2026. It followed three other releases in three weeks — v2.11.0, v2.11.1 and v2.12.0 — after a quiet period stretching back to v2.10.0 in August 2023.

Where can I download older Gerbv versions?

From the archive on the project’s official GitHub Releases page, which keeps every release from the current line back through 2.9.x and beyond. SourceForge still hosts only the legacy, 2.3.0-era files.

Which Gerbv version should Windows 7 users install?

2.8.0 or older — upstream supports Windows 7 only up to that release. Also note that old 2.9.x/2.10.0 Windows ZIPs have no published SHA-256 digest, so they cannot be checksum-verified the way 2.13.0 assets can.

Draws and flashes: the two moves

Apertures are used in exactly two ways. A draw sweeps the aperture along a line or arc, like dragging a pen: a round aperture drawn along a path makes a track with rounded ends, of the aperture’s width. A flash stamps the aperture once, at one coordinate, like a rubber stamp: that is how pads are made — the aperture’s shape becomes the pad’s shape exactly. Much of Gerber literacy is seeing a board in these two moves: tracks are draws, pads are flashes, and large copper areas are built either from many draws or from filled outlines the format calls regions. When something renders oddly, asking “is that a draw or a flash, and with what aperture” usually localises the problem.

The standard shapes

The format defines a small family of standard apertures, each described by a few parameters in the file’s aperture definitions. The circle is the workhorse — a diameter, optionally with a hole in the middle — used for round tracks ends, vias and round pads. The rectangle adds width and height and is the natural stamp for rectangular surface-mount pads, again optionally with a hole. The obround — a rectangle with semicircular ends, like a stadium outline — suits oval pads and slot-like features. A regular polygon form exists for the rarer cases that need one. These four cover the overwhelming majority of what real boards contain, and each is a complete, precise description: shape plus dimensions, defined once in the file header and then referenced by number everywhere it is used.

Macros: when standard shapes are not enough

Some shapes refuse to be a circle or a rectangle: a thermal relief pattern in a ground plane, a crosshair target, a pad with a notch. For those, the format provides aperture macros — small recipes that build a custom shape from primitive elements, with parameters the file can set per use. A macro is defined once and instantiated with different sizes, which keeps files compact and shapes consistent. In the viewer, macros are invisible as a mechanism — you simply see the resulting shape — but they explain why a statistics report may list a macro where you expected a simple pad, and why a very old or minimal tool in the chain occasionally renders a custom shape differently from a full viewer. In Gerbv the shapes render as specified; the macro machinery only becomes your concern when a shape on screen does not match the design, and its definition is the first place to look.

Reading the aperture-usage report in Gerbv

Gerbv opens report windows with statistics about the Gerber codes in use, including an aperture-usage view: which apertures a layer uses, and how often each is flashed or drawn. This is a surprisingly practical audit. A pad aperture flashed a plausible number of times agrees with your component count; an aperture used exactly once in a design with no one-off part is a question worth asking. A track-width aperture that appears in the report but not in your design rules points at an export setting. And a layer whose report lists no pad apertures at all is not a copper layer, whatever its filename claims — one of the fastest content checks available when a set arrives with cryptic names. Pair the report with the visual stack from the download page build and the identification routine in loading and aligning layers, and few layer mysteries survive. The Gerber viewer hub puts this in the overall checking flow.

Why apertures matter beyond curiosity

Apertures are where design intent meets manufacturing reality. The fab’s equipment reproduces the shapes your file defines — a pad that is the wrong aperture is the wrong pad on every board in the batch, rendered faithfully. Fine features push the other way: an aperture smaller than the process handles becomes a conversation with the fab, not a viewer problem. You cannot edit your way out of either in a viewer, and Gerbv does not pretend otherwise — but seeing the shapes, and reading the report of how they are used, is how you catch the problem while it is still a file and not a shipment.

Frequently asked questions

What is an aperture in a Gerber file?

An aperture is a named shape — defined once with its dimensions — that the file’s commands use to draw the board: swept along a path to draw a track, or flashed at a point to stamp a pad. Circles, rectangles, obrounds and custom macros are the standard kit.

What is the difference between a draw and a flash?

A draw moves the aperture along a line or arc, producing a stroke of the aperture’s width — that is how tracks are made. A flash stamps the aperture once at a coordinate, producing a shape identical to the aperture — that is how pads are made.

What does Gerbv’s aperture-usage report tell me?

It lists which apertures a file uses and how often each appears. That turns into a quick audit: pad counts that match your components, unexpected one-off shapes worth questioning, and missing aperture types that betray a mislabelled layer.

Why drills live in their own file

The split is historical and practical. Drilling is a mechanical operation done by a different machine from the photoplotters Gerber was written for, and its data needs are different: not shapes, but diameters and positions. So while a Gerber layer says “draw this”, the Excellon file says “with tool such-and-such, drill here, here and here”. The fab reads your copper layers from the Gerbers and your holes from the drill file, and the two must agree — in units, in origin and in scale — because they were almost certainly exported in two separate steps of the same CAD session.

Anatomy: the tool table and the hole list

An Excellon file has two parts. First comes a tool table: a numbered list of tools, each with a diameter — T1 might be a small via drill, T2 a mounting-hole drill, and so on. The number of tools and their sizes are the design’s complete hole inventory in miniature. Then comes the body: blocks of coordinates grouped by tool, meaning “every coordinate in this block is drilled with this tool, at this diameter”. Open the file as text and you can read both parts directly — it is one of the most human-legible files in the package, and glancing at the tool table is a fast sanity check: if a diameter you expect is absent, or an absurd one is present, the export deserves a second look before it goes anywhere.

How drill data meets the Gerber layers

On their own, coordinates are just numbers. They become holes in your board only when the drill file is overlaid on the copper layers with matching units and a shared origin — which is why the standard check is visual and comparative. Load the drill file together with the top copper in a viewer and the truth is immediate: holes sit centred on their pads, or they visibly do not. Gerbv views Excellon drill files alongside Gerber layers for exactly this purpose; get it from the download page and follow the checking flow in drill holes the wrong size or offset when something looks off. The viewer also reports drill-code statistics, so the tool inventory in the file can be compared against the design’s expectations.

Why scale and offset errors happen

Drill files fail in families. Size errors usually trace back to the tool table or to units: a diameter interpreted in the wrong unit becomes a hole wildly too big or too small, even though every position is right. Position errors come in two shapes. A uniform offset — every hole shifted by the same amount — points to an origin mismatch between the drill export and the Gerber export. A scale pattern — holes that register at one corner and drift further out of place across the board — points to a format mismatch: drills written with a different number format or zero-suppression convention than the reader assumes, so coordinates are stretched rather than shifted. The diagnostic habit is to separate the two questions early: are the diameters right (a tool-table question) and are the positions right (a units/origin/format question)? Each has a different fix, and both fixes belong in the CAD export settings, not in the viewer.

The 60-second drill check

Before any order: open the drill file’s text and eyeball the tool table against your design’s hole sizes. Then overlay the drill file on the copper in Gerbv, zoom to a corner and to a mounting hole, and measure one known hole or one known board dimension. If sizes, positions and one measurement agree, the file is doing its job. The general context — how drill data fits the rest of the package — is covered in what is a Gerber file and the Gerber viewer hub, and the tools for this check are compared in the best free Gerber viewers roundup.

Frequently asked questions

Is an Excellon file a Gerber file?

No. Gerber files describe printed layers as images; an Excellon file is a separate drill program with a tool table of diameters and coordinate lists per tool. Gerbv views both, stacked together, so holes can be checked against the copper pads they belong to.

What is the tool table in a drill file?

It is the header list that assigns each tool number a diameter. The body of the file then gives coordinates per tool. Reading the tool table is a quick audit: every hole size in your design should appear there, and no unexpected diameter should.

Why are my drill holes scaled wrong when the Gerbers are fine?

Because the two were exported separately. A unit, origin or number-format mismatch in the drill export alone produces shifted or stretched holes while the Gerber layers stay correct. Diagnose size and position separately, then fix the drill export settings in your CAD tool.

The generic extensions: .gbr, .ger, .art, .pho

Several extensions simply mean “a Gerber file” without saying which layer. The most common today is .gbr, the plain modern default. .ger is an older generic you will meet in archives and long-lived projects. .art — short for artwork — comes from the Cadence Allegro tradition, where Gerber outputs are artwork films. .pho echoes the photoplotter era and survives in some older toolchains and fab habits. When a set uses one generic extension for everything, the layer identity lives in the rest of the filename: top_copper.gbr, bottom_mask.gbr, outline.gbr and so on. That is perfectly workable — as long as the names are honest and consistent, which is the sender’s job and the checker’s verification.

Layer suffixes: the KiCad-style system

Other toolchains encode the layer in the suffix itself, and KiCad’s scheme is the one you will meet most often. In that system the top copper ends in .gtl and the bottom copper in .gbl — read them as Gerber Top Layer and Gerber Bottom Layer. Inner copper layers use numbered forms such as .g2 and .g3 on multi-layer boards. The solder mask gets .gts (top) and .gbs (bottom), the silkscreen legend .gto (top) and .gbo (bottom), and the solder paste .gtp (top) and .gbp (bottom). The board edge or profile typically appears as .gm1 or a similarly named mechanical layer, and the drill data arrives as a separate Excellon file, often ending in .drl. Other CAD tools use their own suffix dialects — the letters differ, but the pattern is the same: T for top, B for bottom, and a letter for the layer’s job.

Why naming matters more than it should

In a perfect world the extension would be trivia, because Gerber X2 attributes can state each file’s function inside the file itself. In the real world, fab importers, quoting systems and humans all still lean on names. A suffix the importer cannot map becomes a question back to you, or worse, a guess. A set where the bottom mask is named like a copper layer is a defect waiting for a purchase order. Two habits eliminate most of it: export with your tool’s most conventional preset rather than inventing names, and — when ordering — include a brief readme or fabrication note listing which file is which layer. Names are cheap documentation.

When the names are cryptic: identify by content

Sooner or later a ZIP arrives with names like final2.gbr, final2a.gbr and out.pho, and no readme. Do not guess; identify each file by looking at it, which is exactly what a viewer is for. Open the set in Gerbv (get it from the download page) and load files one at a time. Copper layers show dense track work and pads everywhere. Solder mask looks like a near-solid sheet with openings where pads sit. Silkscreen is sparse — outlines, labels and logos floating over empty space. Paste shows only the pads that receive solder paste, typically surface-mount footprints. The outline is just a closed profile line. Drill data, loaded alongside, either registers with the pads or exposes a naming mix-up in the set. Stacking candidates together, as in loading and aligning Gerber layers, confirms roles quickly: the mask that matches the top copper’s pads belongs to the top. Rename your local copies — never the files you will send, unless the fab asks — and note the mapping in your order notes.

A note on extensions that are not Gerber

A fabrication package is not all Gerber. Drill files are Excellon, pick-and-place is typically CSV, and the ZIP may also carry PDFs, drawings and a BOM. Extensions are your first sort, content is your confirmation — Gerbv views the Gerber, drill and pick-and-place files, which between them are the manufacturing core of the set.

Frequently asked questions

What is the difference between .gbr and .gtl?

.gbr is a generic Gerber extension that says nothing about the layer — the rest of the filename carries that information. .gtl is a layer suffix meaning top copper specifically. Both files contain the same RS-274X format; only the naming convention differs.

Which extension is the board outline?

It depends on the toolchain: in KiCad-style naming the profile is usually a mechanical suffix such as .gm1, while other tools name it outline.gbr or place it in a file labelled profile or edge. If unsure, open the candidates in a viewer — the outline is the one that is just a closed profile line.

Can I rename Gerber files to extensions I prefer?

You can rename your local working copies freely, and a clear mapping note helps any order. For the set you send a fab, keep the exporter’s conventional names or follow the fab’s own naming guide — their importer maps layers by name, and surprising it helps nobody.

RS-274X: the image, complete in itself

An RS-274X file is self-contained in a way its predecessor was not: the aperture definitions, units and format settings travel inside the file, and the drawing commands that follow describe the layer’s copper, mask, legend or paste pattern exactly. (The older RS-274D needed a separate aperture file, which is why Gerbv — an RS-274X viewer — cannot open it.) What an RS-274X file does not contain is intent. It knows a shape is a filled rectangle of a certain size at a certain place; it does not say whether that rectangle is a pad, a test point or a logo. Humans infer the layer’s role from the filename; machines historically did the same, with the filename chaos that implies.

What X2 adds: attributes

Gerber X2 keeps the RS-274X image exactly as it is and adds attributes — named pieces of metadata attached at three useful levels. File attributes describe the file itself, most importantly its function: this is the top copper layer, this is the solder mask, this is the board outline. Aperture attributes connect drawn shapes to their role, such as being pads for a component. Object attributes go furthest, attaching part and net information to the objects drawn — this flash belongs to this component pin, on this net. Nothing about the picture changes; what changes is that the picture arrives with a caption written in a standard vocabulary, instead of a filename in someone’s personal shorthand.

Why attributes matter in practice

The classic failure attributes prevent is the misidentified layer: a fab importing a set where a file’s role was guessed from its name, guessed wrong, and built. With X2 file-function attributes, software can identify layers by content, flag a missing layer by role rather than by absence from a list, and refuse ambiguity instead of guessing silently. Net and part attributes push further — they let downstream tools reason about connectivity and components rather than treating the board as pure geometry. Even if your own routine is visual, you benefit every time a fab’s importer stops misreading your set. When you receive files, the header of an X2 file tells you what the sender intended each layer to be, which is a far better starting point than deciphering suffixes — although suffixes still matter, as Gerber file extensions explained covers.

Compatibility: X2 files are still Gerber files

Because the image layer of the format is unchanged, an X2 file is still an RS-274X file with extra information embedded in it. Viewers read the drawing as they always have. Gerbv views RS-274X files, and an X2 file’s image renders in Gerbv like any other layer — you can stack it, measure it and export views of it from the download page build. What a plain viewer does not do is exploit the attribute layer: Gerbv will show you the top copper, but identifying it as top copper remains your job, done with the filename and context as the attributes sit unused. That is a viewing limitation to know about, not a rendering problem — the geometry you are checking is complete.

Which should you export?

If your CAD tool offers X2, exporting with attributes is the better default for sending work to a fab: the same image, plus machine-readable intent that reduces misidentification at import. Keep your filenames sensible anyway — humans, archives and checklists still run on names, and attributes complement filenames rather than excusing cryptic ones. If your tool offers only classic RS-274X, your files remain perfectly manufacturable; most of the world’s boards are described exactly that way. The format question to never get wrong is the older one: RS-274X (with or without X2 attributes) is the living standard, and RS-274D is the legacy format modern viewers, Gerbv included, do not support.

Frequently asked questions

Is Gerber X2 a different file format from RS-274X?

Not in its image. X2 is RS-274X with an attribute system added: the layer is drawn exactly as before, and attributes inside the file add the layer’s function plus part and net information. An X2 file is still a Gerber file.

Can Gerbv open Gerber X2 files?

Yes — the RS-274X image in an X2 file renders in Gerbv like any other Gerber layer, so you can stack, measure and export it. Gerbv does not itself use the attribute data, so identifying each layer’s role remains a filename-and-context job for the viewer.

Should I export X2 or plain RS-274X?

If your CAD tool offers X2 attributes, use them when sending files to a fab: the image is identical and the embedded layer-function information reduces the chance of a layer being misidentified. Plain RS-274X remains fully manufacturable everywhere.