What actually shipped in v2.13.0

The release attaches six assets on GitHub Releases, covering every supported platform:

• Windows installer: gerbv-2.13.0-win64.exe — 15,062,430 bytes — NSIS-packaged, cross-compiled from Fedora — download
• Windows portable ZIP: gerbv_v2.13.0_.Windows.MSYS2.UCRT64.zip — 17,962,489 bytes — built natively with MSYS2 — download
• macOS ZIP: gerbv_v2.13.0_.macOS.zip — 6,795,082 bytes — the first official macOS build in a release (a ZIP, not a DMG) — download
• Ubuntu 22.04 .deb: 4,267,552 bytes — download
• Debian 13 .deb: 4,263,454 bytes — download
• Fedora 43 .rpm: 2,290,118 bytes — download

Every asset carries a published SHA-256 digest in the release metadata; the full table with all six checksums is on the download page. The Windows builds are 64-bit, with Windows 10 as the tested target. The two Windows variants are the release’s signature detail: one build cross-compiled on Fedora and delivered through an NSIS installer for a conventional setup experience, and one built natively on Windows under MSYS2 and delivered as an extract-and-run ZIP for portable use — the subject of our portable build guide. The macOS build had existed in the project’s CI during the previous release cycle, but v2.13.0 is where the macOS files first became part of the public release.

Why 2026? The revival context

To see why this release matters, look at the timeline around it. Gerbv, a GPL-2.0-or-later viewer for Gerber RS-274X, Excellon drill and CSV pick-and-place files from the gEDA project family, had been quiet for a long time: v2.10.0 shipped in August 2023, and then no new release appeared for roughly two and a half years. The project was not formally abandoned, but from the outside it looked dormant. Then, in three weeks in early 2026, four stable releases landed. v2.11.0 (February 28, 2026) was the first release after a rewrite of the build system to CMake, and it already restructured distribution: a .deb for Debian and Ubuntu, an .rpm for Red Hat/Fedora, and a .zip for Windows. v2.11.1 (March 2) followed as a quick stabilisation release. v2.12.0 (March 8) then delivered functional news: DXF export became built in on all platforms (previously it depended on how the build was configured), and a new optimised SVG export arrived with optional Inkscape layers. v2.13.0 capped the sequence by completing the platform story with the native Windows and macOS release builds. The full chronology, including the SourceForge era, is in our version history.

What did not change

Just as important for existing users: v2.13.0 is the same Gerbv underneath. The interface still runs on GTK 2 with Cairo rendering — the GTK 3 port remains on the maintainer’s plan, not in this release. The format story is unchanged: RS-274X is the core format, Excellon drill and CSV pick-and-place files are supported, and legacy RS-274D is explicitly not supported. It remains a 2D viewer with layer stacking, transparency, measurement and report windows — not a PCB editor, with no 3D view and no design-rule or DFM checking. Export covers PNG, PDF, PS, SVG, RS-274X, drill formats and DXF. Saying this plainly matters: the 2026 releases modernised how Gerbv is built and distributed, and added real export improvements in 2.12.0, but they did not turn it into a different kind of tool.

For builders: the CMake foundation underneath

The platform story was possible because of the build-system work that landed first. Since the CMake transition, Gerbv builds with CMake presets and the Ninja build tool; the project’s BUILD.md documents presets including linux-gnu-gcc, macos-clang, mingw-w64-gcc and msys2-ucrt64-gcc — a list that maps almost one-to-one onto the six release assets above. The README’s build requirements are correspondingly concrete: a C compiler, the gtk+-2.0 and glib-2.0 development packages, CMake 3.28 or newer, and Ninja. Most users should never need any of this — the release binaries exist precisely so that viewing a Gerber file does not start with a compile — but the preset list is the clearest evidence that native Windows and macOS output in 2.13.0 is a designed feature of the new build system, not a one-off experiment.

Getting v2.13.0

All six assets are on the official GitHub release, and this site’s download page links each one through its /go/ shortcut with sizes and SHA-256 checksums for verification. Platform guides walk through the details: installing on Windows (including SmartScreen and checksum verification), installing on macOS (the ZIP, Gatekeeper, and the Homebrew option — brew install gerbv, which tracks 2.13.0), and installing on Linux with the .deb and .rpm packages. Activity has continued since the release — the project’s CI binaries were rebuilt in August 2026 — so “revived and between releases” is the fair summary of where Gerbv stands.

Frequently asked questions

When was Gerbv 2.13.0 released?

March 20, 2026. It is the latest stable release, following v2.12.0 (March 8, 2026), v2.11.1 (March 2, 2026) and v2.11.0 (February 28, 2026) in the project’s 2026 revival.

What is new in Gerbv 2.13.0?

The first native Windows and macOS builds in a public release: an NSIS-packaged Windows installer, a native MSYS2 Windows ZIP, and an official macOS ZIP, alongside the Ubuntu/Debian .deb and Fedora .rpm packages.

Is there a macOS DMG or a 32-bit Windows build in 2.13.0?

No. The macOS artifact is a .zip, and both Windows builds are 64-bit only. Windows 7 remains supported only up to Gerbv 2.8.0.

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.

Two Windows builds, two build systems

The v2.13.0 release notes describe the pair plainly: the project now makes two Windows variants. One is cross-compiled on Fedora and packaged with the NSIS installer — that is gerbv-2.13.0-win64.exe, the build covered in our Windows installation guide. The other is built natively on Windows with MSYS2, using the UCRT64 toolchain, and shipped as a plain ZIP archive. MSYS2 is a Windows software-building environment, and UCRT64 refers to its build profile targeting the Universal C Runtime on 64-bit Windows. The practical consequence of the ZIP packaging is what matters here: no setup wizard, no registry-driven install step, no uninstaller — just a folder of files that includes the gerbv executable and the libraries it needs.

The file: name, size and checksum

The portable build’s asset name is long but exact: gerbv_v2.13.0_.Windows.MSYS2.UCRT64.zip, at 17,962,489 bytes (about 18 MB — slightly larger than the 15 MB installer, which is typical for a self-contained folder). Download it via /go/gerbv-win-zip, which redirects to the official v2.13.0 asset on GitHub Releases. Before extracting anything, verify the archive in PowerShell:

Get-FileHash .\gerbv_v2.13.0_.Windows.MSYS2.UCRT64.zip -Algorithm SHA256

The result must match the published SHA-256:

bb77865da031df83482196a6f6e9fa98298433979d995c068c4533b9b5a9ee7d

If it does not match, delete the file and download it again from the official release. Verifying matters doubly for a portable build, because a folder that can be copied anywhere can also be copied from anywhere — the checksum is how you know your copy is the project’s build and not a repackaged one.

Extract and run

Right-click the ZIP and choose Extract All (or use your archiver of choice), putting the folder somewhere you can write to — your Documents folder, a tools folder on a second drive, or a USB stick. Then open the extracted folder and run the gerbv executable inside it. That is the whole setup. Gerbv opens with its layer list ready: load your Gerber RS-274X layers, Excellon drill file and CSV pick-and-place file from the File menu, and you are viewing the board. When you are done, closing the program leaves nothing running, and deleting the folder removes the “installation” completely.

One expectation to set: because the ZIP bypasses the installer, Windows SmartScreen may comment on the unsigned executable the first time you run it, just as it can with the installer. The checksum verification above is the step that lets you treat that prompt sensibly — as general guidance, with a verified file you can choose More info, then Run anyway. Both Windows builds are 64-bit and Windows 10 is the tested platform; on Windows 7, neither v2.13.0 build applies — upstream supports Windows 7 only up to v2.8.0, as the version history explains.

When portable beats the installer (and when it doesn’t)

Choose the ZIP build when you cannot install software (no administrator rights, a managed work PC), when you want Gerbv on a USB stick for the lab bench or a client visit, when you are evaluating the program and want a zero-commitment trial, or when you want two side-by-side copies — for example the release build and a fresh download — without them interfering. Choose the NSIS installer for your own main machine: it integrates with the Start menu, associates itself properly in the system, and can be removed through Windows’ normal app management. Feature-wise there is nothing to choose between them: same viewer, same RS-274X/Excellon/CSV support, same layer tools, measurement and report windows, same PNG/PDF/PS/SVG/DXF export, and the same honest limits — 2D only, no RS-274D, no design-rule checking.

Keeping a portable copy current

A portable folder does not update itself, so staying current is a manual habit: when a new release appears, download the new ZIP, verify its checksum, extract it to a fresh folder, and delete the old one once you are happy. The project’s pace makes this easy to follow — after years of quiet it shipped four releases in three weeks in early 2026, a story told in Gerbv 2.13.0: first native Windows and macOS builds. If you later move to a machine where installing is fine, the step-by-step installer guide covers the NSIS route, and the download page keeps every platform’s file, size and SHA-256 in one table.

Frequently asked questions

Is the Gerbv ZIP build really portable — no installation at all?

Yes. The MSYS2 UCRT64 ZIP from the official v2.13.0 release extracts to a self-contained folder; you run the executable from there, including from a USB stick, and deleting the folder removes it.

What is the difference between the ZIP and the .exe installer?

The .exe is an NSIS installer cross-compiled from Fedora that installs Gerbv system-wide with shortcuts and an uninstaller. The ZIP is built natively with MSYS2 and needs no install. The viewer itself is the same.

How do I verify the portable download?

Run Get-FileHash on the ZIP in PowerShell and compare it with the published SHA-256 bb77865da031df83482196a6f6e9fa98298433979d995c068c4533b9b5a9ee7d (17,962,489 bytes). Only extract and run it if they match exactly.

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.

The 3-2-1 principle, in plain terms

The 3-2-1 rule is a rule of thumb for keeping data safe: keep three copies of anything important, stored on two different kinds of media or locations, with one copy kept off-site — somewhere a single theft, fire or flood at your desk cannot reach. Makers do not need enterprise tooling to follow it. In practice it usually means: the working copy on your computer, a second copy on a separate drive or home storage, and a third copy in cloud storage. Each layer protects against a different failure — accidental deletion, a dead drive, and losing the building, respectively — and the system only works if making the copies is habitual rather than heroic.

What to keep from every PCB project

Back up the project, not just the design file. A complete, restorable PCB project archive contains: the CAD project sources — schematic, board layout and any local libraries or footprints you created, since a layout without its custom library parts may not open cleanly elsewhere; the exported fabrication set exactly as sent to the fab — Gerber layers, the Excellon drill file and, for assembly, the pick-and-place file; the bill of materials and your sourcing notes, including any substitutions you made during the build; and a short build note recording what the board is, which revision it represents, and anything you would tell your future self — a jumper you always fit, a part that ran hot, the bodge you applied to the first batch. That note is the file most people skip and most wish they had.

Version the exports, not just the sources

Sources evolve continuously, but fabs receive snapshots. Keep each released fabrication set in its own clearly named folder alongside the sources at that moment, so the Gerbers on your disk always answer the question: what exactly did the fab build? This discipline pays off the first time a delivered board misbehaves — you can open the precise Gerber set that produced it in Gerbv, using the opening guide, and check the physical board against the exact data it was made from, rather than against a design that has since been edited three times. It also protects you socially: when you share files with a collaborator or a fab’s support desk, everyone inspects the same snapshot.

A folder habit that survives enthusiasm

Backup systems fail socially before they fail technically. Keep the structure boring and identical for every project: one project folder, with sources at the top level and dated release folders beneath it, each holding the Gerbers, drill and assembly files for that revision plus the BOM and build note. Boring is the point — a structure you can reproduce half-asleep after a long build session is one you will actually maintain. Whatever CAD tool you use, from the workflows covered in our KiCad checking guide to the other export guides on this site, the archive shape stays the same.

The cloud copy, and one honest option

The off-site copy is the layer makers most often postpone, because it needs a decision. Any reputable cloud storage you already use satisfies the principle; what matters is that the project archive lands there automatically or by a routine you trust, not that it uses a particular brand. If you are choosing a service for this role, you can look at pCloud — that is an affiliate link, and purchases through it may earn this site a commission at no extra cost to you, as set out on our Affiliate Disclosure page. Judge any cloud option, including that one, by the same plain criteria: does it sync or accept uploads the way you work, can you restore a whole project folder easily, and will you still be using it in three years? A backup you abandon is not a backup.

Test the restore before you need it

A backup that has never been restored is a hope, not a system. Once per project — and at least once while setting your system up — perform a trial restore: copy the archive to a spare folder or a different machine, open the sources, and load the released Gerber set in the viewer from the download page. Confirm the drill file overlays the copper, the BOM opens, and the build note makes sense to you cold. The test takes minutes and catches the classic silent failures: the library that never got copied, the export folder that was empty, the cloud folder that synced everything except the one subdirectory that mattered.

What this system deliberately leaves out

This is a maker’s system, not an IT department’s. It does not prescribe backup software, schedules measured in hours, or retention policies — for design files that change when you work on them, a copy made at every release and at every work session’s end, in three places, is a proportionate defence. If your boards become a business, graduate the system then; the archive structure above scales with you, because the habit — complete project, versioned exports, one off-site copy, tested restores — is the same at every scale. Start it with your current project, before the story at the top of this guide becomes yours.

Frequently asked questions

What does the 3-2-1 backup rule mean for PCB files?

Keep three copies of each project archive, on two different kinds of storage, with one copy off-site — typically your working computer, a separate local drive, and a cloud copy. Each layer guards against a different loss: deletion, drive failure, and losing everything at one location.

Which files belong in a PCB project backup?

The complete project: CAD sources with any custom libraries, the exact Gerber, drill and pick-and-place sets sent to the fab for each revision, the BOM with sourcing notes and substitutions, and a short build note describing the revision and anything future-you needs to know.

Why keep old Gerber exports if I have the design sources?

Because the fab built a snapshot, not your current sources. Keeping each released Gerber set lets you compare a delivered board against the exact data it was made from, reproduce an order precisely, and debug discrepancies without guessing which edits came later.

Choose the package for your distribution

All three packages are attached to the official release at github.com/gerbv/gerbv. Pick the one that matches your system — the packages are built per-distribution, so do not install the Ubuntu .deb on Debian or vice versa if your exact build is available:

• Ubuntu 22.04: gerbv_v2.13.0_.Ubuntu.22.04.deb — 4,267,552 bytes — via /go/gerbv-linux
• Debian 13: gerbv_v2.13.0_.Debian.13.deb — 4,263,454 bytes — via /go/gerbv-linux-deb
• Fedora 43: gerbv_v2.13.0_.Fedora.43.rpm — 2,290,118 bytes — via /go/gerbv-linux-rpm

The main Linux button on the download page goes to the Ubuntu 22.04 .deb; the full table there lists every package with its size and checksum. Upstream’s README explains that Ubuntu 22.04 is the Ubuntu package target for a build-infrastructure reason (a Docker image UID/GID conflict in the cross-compile toolchain), not because the application itself is limited to that release.

Verify the download with sha256sum

Whichever package you fetched, verify it before installing. Run sha256sum on the file and compare with the published value for your package:

sha256sum gerbv_v2.13.0_.Ubuntu.22.04.deb
# 6c0bb2c58fa6643dfe8e0a9805d30d98429af0d089fce2605263d8245e5550d4

sha256sum gerbv_v2.13.0_.Debian.13.deb
# a18608960be7c7a7f0a732427d6706aa47451ea7d92410eabd3d16a85e08324b

sha256sum gerbv_v2.13.0_.Fedora.43.rpm
# 0571080d01c2686c2ab4201255f07d1b937970e915296da524edb8852640bc7f

The hash printed for your file must match the corresponding line exactly. If it does not, delete the file and download it again from the official release — a mismatch means the file is incomplete or not the published artifact, and it should not be installed.

Install on Ubuntu 22.04 or Debian 13 (.deb)

From the folder containing the .deb, install it with dpkg, then let apt resolve any runtime dependencies:

sudo dpkg -i gerbv_v2.13.0_.Ubuntu.22.04.deb
# On Debian, use gerbv_v2.13.0_.Debian.13.deb instead.
sudo apt-get install -f   # only if dpkg reports missing dependencies

Alternatively, sudo apt install ./gerbv_v2.13.0_.Ubuntu.22.04.deb installs the local file and pulls dependencies in one step on recent apt versions. When the install finishes, launch gerbv from a terminal or find it in your desktop’s application menu.

Install on Fedora 43 (.rpm)

On Fedora, install the RPM with dnf, which handles the package’s dependencies automatically:

sudo dnf install ./gerbv_v2.13.0_.Fedora.43.rpm

Then start Gerbv from the application menu or by running gerbv.

The GTK 2 runtime — and what it means for you

Gerbv’s interface is built on GTK 2 (the Homebrew formula, for comparison, lists gtk+ 2.24.33 among its runtime dependencies, alongside cairo, glib and pango). The maintainer’s GTK 3 port is a stated plan, not a shipped change, so expect a functional, slightly old-school interface rather than a modern GTK 4 look. Practically, the official packages are built against the libraries on their target distributions, so on Ubuntu 22.04, Debian 13 and Fedora 43 the GTK 2 runtime is resolved by the package tools above. If you build from source instead, the README’s dependency list is gcc, gtk+-2.0 and glib-2.0 development packages, CMake 3.28 or newer, and Ninja — but for simply viewing boards, the release packages are the right choice.

A note on distribution repositories

Your distribution’s own repositories may also carry a gerbv package, and installing it that way (for example with a plain sudo apt install gerbv) is convenient — but repository versions often lag upstream, sometimes by a lot. Gerbv went quiet between v2.10.0 in August 2023 and the 2026 revival, then shipped four releases in three weeks, so a repository copy can easily be several versions behind v2.13.0 and miss the built-in DXF export added in v2.12.0 and the current packaging. If you want the version this site documents, install the official release packages above; the version history shows how the releases line up. Other platforms are covered too: see installing on Windows, installing on macOS, and the 2.13.0 release overview. All package details are also collected on the download page.

First run

Open Gerbv and load your board’s files from the File menu: the RS-274X copper and mask layers, the Excellon drill file, and any CSV pick-and-place file. Layers stack in the order you add them; right-click the layer list to change colours, reload a file, or switch on transparency to see through the stack. Remember the honest limits: RS-274D is not supported, the view is 2D only, and Gerbv reports statistics about the files rather than running design-rule checks.

Frequently asked questions

Which Linux package should I download?

The one built for your distribution: the Ubuntu 22.04 .deb on Ubuntu 22.04, the Debian 13 .deb on Debian 13, or the Fedora 43 .rpm on Fedora 43. All are 64-bit builds of v2.13.0 from the official GitHub release.

Does Gerbv need GTK 3 on Linux?

No. Gerbv is a GTK 2 application; a GTK 3 port is planned upstream but has not shipped. The official packages pull in the runtime they need on their target distributions.

Is the gerbv package in my distro’s repository the latest?

Often not. Repository versions can lag upstream by several releases. For v2.13.0, install the official .deb or .rpm from the GitHub release and verify it with sha256sum.

What you are downloading

The macOS asset in the v2.13.0 release is named gerbv_v2.13.0_.macOS.zip and is 6,795,082 bytes (about 6.8 MB). Inside the archive is the Gerbv application, built on the same GTK 2 and Cairo stack as the other platforms — Gerbv is still a GTK 2 application; the GTK 3 port remains a plan, not a shipped change. Gerbv views Gerber RS-274X files, Excellon drill files and CSV pick-and-place files, stacking layers so you can inspect a board design before it goes to fabrication. It is a 2D viewer: no 3D view, no design-rule checking, and no support for legacy RS-274D files.

Step 1: Download the official macOS ZIP

Use the macOS button on the download page, which links to the official file via /go/gerbv-macos. That redirect lands on the v2.13.0 asset at github.com/gerbv/gerbv, the project’s official release channel. Save the ZIP to your Downloads folder. If a third-party site offers you a Gerbv “.dmg”, treat it with suspicion — no such file exists in any 2026 release, so anything packaged as one did not come from the project.

Step 2: Verify the SHA-256 checksum

Before opening the archive, confirm it is exactly the file the project published. Open Terminal, change to the Downloads folder, and run:

shasum -a 256 gerbv_v2.13.0_.macOS.zip

The output must match the published SHA-256 for the macOS build:

7d79adf7556508baa6c9d080949866371cbb49809f2082e0e6639cb62c4dba0f

If the values differ, delete the download and fetch it again from the official release. Only proceed once the checksum matches — this is also the check that makes the Gatekeeper step below a reasonable, informed action rather than a leap of faith.

Step 3: Unzip and run

Double-click the ZIP in Finder (or run unzip gerbv_v2.13.0_.macOS.zip in Terminal) to extract the application. You can run Gerbv from the extracted folder, or drag it into your Applications folder to keep it with your other apps — either works, because the ZIP build is self-contained rather than a disk-image installer. The first time you open it, load a board: use the File menu to open your Gerber RS-274X layers, your Excellon drill file and any CSV pick-and-place file, and Gerbv stacks them in the layer list. From there you can toggle layer visibility and colours, use transparency to see through stacked layers, measure distances on the image, and export views to PNG, PDF, PS, SVG or DXF for documentation.

Gatekeeper: opening an unsigned app

Gerbv’s macOS build is not signed with a paid Apple Developer certificate or notarised, so on first launch macOS Gatekeeper may tell you the app cannot be opened because it is from an unidentified developer, or move to block it entirely. As general guidance for unsigned open-source applications whose checksum you have verified against the official release, the standard workaround is to right-click (Control-click) the app and choose Open, then confirm Open in the dialog. That registers your decision for that copy of the app, and later launches behave normally. Newer macOS versions may instead direct you to the Privacy & Security section of System Settings, where an “Open Anyway” button appears for the blocked app after a first attempt. Either way: only do this for the file whose SHA-256 you verified in Step 2, and never for a copy obtained from an unofficial repackager.

Alternative: install with Homebrew

If you already use Homebrew, you can skip the manual download entirely:

brew install gerbv

The Homebrew formula tracks the same stable release — formulae.brew.sh lists gerbv at 2.13.0, with bottles for Apple Silicon Macs (and Linux). One caveat to be aware of: the formula page currently flags the formula as deprecated, with a disable date of 2027-08-28 shown when this guide was written. The formula still installs the current release, but if Homebrew is your only channel it is worth keeping the official GitHub ZIP method above in mind for the future. Whichever route you take, the application itself is identical: same viewer, same formats, same GPL-2.0-or-later licence.

Where to go next

Release background — why native macOS and Windows builds only arrived in 2026, after a long quiet period — is covered in Gerbv 2.13.0 release notes explained and the full version history. Windows and Linux users have their own guides: installing on Windows and installing on Linux. All filenames, sizes and checksums for every platform are collected on the download page.

Frequently asked questions

Is there a Gerbv DMG for macOS?

No. The first official macOS build, shipped in v2.13.0 on March 20, 2026, is a .zip archive (gerbv_v2.13.0_.macOS.zip). No .dmg exists in the release.

Why does Gatekeeper block Gerbv on first launch?

The build is unsigned and not notarised, so macOS warns about an unidentified developer. After verifying the SHA-256 checksum, the usual guidance is to right-click the app, choose Open, and confirm.

Can I install Gerbv on a Mac with Homebrew?

Yes — brew install gerbv installs the same 2.13.0 stable release. Note the Homebrew formula is flagged deprecated with a disable date of 2027-08-28 shown on formulae.brew.sh.

Before you start: which Windows build should you download?

The v2.13.0 release offers two Windows variants, and picking the right one saves confusion later. The first is gerbv-2.13.0-win64.exe (15,062,430 bytes), an NSIS installer cross-compiled from Fedora. This is the build most people should use: it installs Gerbv like a normal Windows program, with a Start menu entry and an uninstaller. The second is an MSYS2 UCRT64 ZIP archive (17,962,489 bytes), built natively on Windows with MSYS2. The ZIP needs no installation — you extract it and run the executable — which makes it useful on locked-down or shared machines. Both builds are 64-bit only, and Windows 10 is the platform the project builds and tests on. There is no 32-bit build and no Windows ARM64 build in the release.

One important exception: Windows 7 is only supported up to Gerbv 2.8.0. That limit comes from the upstream project itself, not from this site. If you are still running Windows 7, download release 2.8.0 (or older) from the GitHub releases archive instead of v2.13.0, and expect that older build to lack the export improvements and packaging changes described in our version history.

Step 1: Download the installer

Go to the download page and use the Windows installer button, which goes to the official file via /go/gerbv-win-exe. That link redirects to the v2.13.0 asset on github.com/gerbv/gerbv — the project’s own release channel. Save gerbv-2.13.0-win64.exe somewhere easy to find, such as your Downloads folder. The file is about 15 MB, so the download should finish quickly even on a modest connection. Avoid installers offered by random download portals: the project’s README states that official releases are published on GitHub Releases, and that is the only source this guide uses.

Step 2: Verify the SHA-256 checksum

Verifying the checksum takes less than a minute and proves the file you downloaded is byte-for-byte the file the project published — not corrupted in transit and not swapped by a mirror. Open Windows PowerShell, change to your Downloads folder, and run:

Get-FileHash .\gerbv-2.13.0-win64.exe -Algorithm SHA256

Compare the output with the published SHA-256 for the v2.13.0 installer:

2bafa388c485a9bcecef40e8537cd90287e626f29ce20502ab472faf3cd349fb

The two values must match exactly, character for character. If they differ, delete the file and download it again from the official release; do not run an installer whose hash does not match. This check matters most if you ever use a mirror copy, but it is a good habit for the official download too.

Step 3: Run the NSIS installer

Double-click the installer and follow the NSIS setup wizard: accept the GPL licence, choose an install folder (the default is fine for most people), and let the wizard copy the files and create shortcuts. Administrative rights may be requested for a machine-wide install, which is normal for NSIS installers that write to Program Files.

Because Gerbv is a small open-source project, its installer is not code-signed with a commercial certificate. Windows SmartScreen may therefore show a “Windows protected your PC” prompt the first time you run it. As general guidance for unsigned open-source installers whose checksum you have just verified against the official release, you can click More info and then Run anyway to proceed. The checksum verification in Step 2 is what makes that decision a considered one: you already know the file is exactly what the project published. If the hash did not match, do not bypass the warning.

Step 4: First launch and opening your board files

Launch Gerbv from the Start menu. You will see an empty canvas with a layer list on the left. Use the File menu to open your fabrication files: Gerbv’s core format is Gerber RS-274X, and it also opens Excellon / NC drill files and CSV pick-and-place (centroid) files. Open each copper layer, the solder mask, the silkscreen and the drill file for the same board, and Gerbv stacks them so you can inspect the board as a whole. Right-clicking a layer in the list lets you reload it, change its colour and toggle how it is drawn, and the Cairo renderer can show layers with transparency so you can see what lies underneath. A measurement tool lets you check distances on the displayed image, and report windows summarise the Gerber and drill codes in use.

Two limits are worth knowing on day one. Gerbv does not support legacy RS-274D files — the README states this explicitly — and it is a 2D viewer: there is no 3D view and no design-rule or DFM checking. It also exports what you see to PNG, PDF, PS, SVG and (since v2.12.0, built in on all platforms) DXF, which is handy for documentation. For a tour of what changed in this release, see what is new in Gerbv 2.13.0.

Troubleshooting quick notes

If the installer will not start, re-check the SHA-256 value first — a truncated download is the most common cause. If Gerbv opens but a layer looks missing, make sure the file is really RS-274X or Excellon and not an RS-274D or proprietary CAD export. If you are on Windows 7, remember the 2.8.0 ceiling above. And if your workplace forbids installing software altogether, the portable ZIP build runs from an extracted folder or a USB stick with no installer at all. Full file details, sizes and checksums for every platform are collected on the download page.

Frequently asked questions

Is Gerbv free to install on Windows?

Yes. Gerbv is open-source software under GPL-2.0-or-later, and the official Windows builds on GitHub Releases are free to download and use.

Does Gerbv v2.13.0 work on Windows 7?

No. Upstream supports Windows 7 only up to Gerbv 2.8.0. Use that older release on Windows 7; v2.13.0 is a 64-bit build tested on Windows 10.

Why did SmartScreen warn me about the installer?

The installer is not code-signed with a commercial certificate, so Windows may warn on first run. Verify the SHA-256 checksum against the official release first; if it matches, the usual guidance for unsigned open-source installers is to choose More info, then Run anyway.

Why the route goes through PDF

Printers and their software love to help, and their favourite help is rescaling your page to fit their margins. The defence is to give the print path a format that carries an explicit physical size and a viewer that lets you demand it be honoured. That is why this workflow exports the layer view from Gerbv as a PDF, as described in the picture-export tutorial: PDF is a vector format in which the drawing has defined dimensions, and PDF readers offer a true-size printing choice — the setting is commonly labelled as actual size or 100% scale, as opposed to fit-to-page options that silently shrink the drawing by a few percent. Raster formats such as PNG can also be printed, but their physical size depends on DPI metadata being honoured end to end, which is one more assumption than the job needs. Vector PDF, printed at actual size, is the shortest path from Gerber geometry to trustworthy paper. Choose the layer stack for the check before exporting: for footprint and placement checks, top copper with silkscreen reads best; for enclosure checks, the outline layer plus mounting holes is the drawing that matters, cross-referenced with the DXF export if the enclosure work is happening in CAD.

The print settings that must not move

Three settings decide whether the paper is 1:1, and all three live in the print dialog rather than in Gerbv. First, scaling must be actual size / 100% — any “fit”, “shrink to printable area” or percentage other than 100 invalidates the sheet, however good it looks. Second, orientation and paper size must genuinely contain the board: if the board is larger than the printable area, the printer may clip or the software may offer to tile or shrink — shrink is the one answer you must refuse; print the board in sections for a partial check, or use a larger printer for a full one. Third, if your print path offers a choice between printing the document’s size and a paper size, choose the document — the exported PDF’s page is the size authority for this job. Consumer print paths default to making things fit pages; a fit check’s entire point is a page that refuses to flatter the board.

Verify the scale with a known dimension — every time

Never trust the settings; measure the paper. Pick a dimension you already know from the data: the board’s overall width is ideal, or a mounting-hole spacing you verified earlier using measurement in Gerbv. Measure that same feature on the printed sheet with a ruler — callipers are better — and compare. Agreement within ordinary paper-and-printer tolerance (a fraction of a millimetre over a board’s width) means the sheet is a fit-check instrument. A discrepancy with a clean signature — everything uniformly a few percent small — means a fit-to-page setting survived somewhere in the chain: find it, switch it to actual size, reprint, re-measure. A discrepancy in only one direction suggests the printer stretched the feed axis, which happens on some hardware; a second printer is the practical fix. This verification is not pedantry. It takes thirty seconds, and it is the difference between discovering a footprint error on paper and discovering it on a fabricated board with components already bought. Write the measured value on the sheet itself, with the board revision, so the paper’s credentials travel with it around the bench.

What to check on the verified sheet

With a proven 1:1 print, the checks are satisfyingly physical. Place the real connectors, switches, displays and any tall or odd components on their printed footprints: pin alignment, orientation, body overhang and finger access all become obvious. Check the board against its enclosure — holes over standoffs, edges inside walls, connectors centred in their cutouts — or, for a panel-mounted control, hold the sheet against the panel itself. Check human factors: labels readable in place, controls reachable, cables able to bend where they must. The same verified print is the natural companion to layer alignment checking: the paper proves physical fit, the stacked view proves the data.

The hobby context: toner transfer and etch-resist artwork

Home fabricators meet 1:1 printing from the other direction: for toner-transfer and resist-based home etching, the printed artwork is not a check but the manufacturing step itself, the pattern that will be transferred to copper-clad board. Everything in this tutorial applies with doubled force there — the scale verification against a known dimension is what stands between a usable transfer and a board whose IC footprints are uniformly a fraction off, which no amount of careful etching can rescue. Two cautions belong in that context. Orientation matters as much as scale: whether a given layer’s artwork must be mirrored depends on the transfer method and which side of the board is being made, so decide it deliberately for your process and verify the printed result against the design’s text and asymmetric features before transferring. And home printing resolution is the ceiling on fine detail: a verified-scale print can still be a poor transfer master for very fine traces, which is a printer limitation, not a Gerbv one.

Frequently asked questions

Why not print the PNG export instead?

PNG can work, but its printed size depends on DPI metadata being honoured through the whole print path. A vector PDF carries explicit dimensions and PDF readers offer an actual-size (100%) printing option, which makes true 1:1 output far more reliable.

How do I prove my printout is really 1:1?

Measure a known feature on the paper — the board width or a mounting-hole spacing you verified in Gerbv — with a ruler or callipers, and compare it with the data value. A uniform few-percent shortfall means a fit-to-page setting is still active somewhere; fix the setting and reprint.

The board is bigger than my printer’s page. What then?

Never accept the shrink-to-fit offer — that destroys the 1:1 property the check exists for. Print the critical sections at actual size for partial checks, or use a larger-format printer for a full-size sheet.

Plan the panel before touching the command line

Panelization decisions are geometric, and they are much easier to make on paper than at a prompt. Decide how many boards go on the panel and in what arrangement — a grid of identical copies is the common case, with mixed panels for small production runs of related boards. Fix the spacing between boards: your board house publishes a minimum gap for the routed separation it supports, and the panel must respect it everywhere, not just on average. Decide whether the panel needs rails — sacrificial borders that give the assembly process something to hold — and if so, how wide they are and whether they belong in the panel data you generate or are added by the house. Note the finished panel’s overall dimensions, because that is the number you will verify afterwards. All of this is standard panel planning that applies to any tool; what Gerbv contributes is the machinery to produce the panel data from your existing Gerber and drill files once the plan exists.

What the command line gives you

Gerbv’s documented command-line surface, per its man page, is built around viewing, export and transformation. Export is selected with -x followed by the format — the supported export formats include RS-274X and drill formats for data output, plus the picture formats — and the output file is set with -o. For RS-274X and drill export, two options do the geometric work that panel building relies on: -T applies translation and rotation to the exported data, and -O sets the origin of the exported coordinates, with units expressed in inch, millimetre or mil. Those documented primitives are the honest building blocks of command-line panelization: copies of a board’s data placed at planned offsets, written out as new RS-274X and drill files. One honesty note, stated plainly because it matters at a command line: the exact invocation for a full panel build depends on the layout you planned, and this site does not print a panelize command line that the man page does not itself spell out — consult the man page on your system for the precise syntax of the build you have installed, and treat any example you find elsewhere with the same suspicion. The workflow below is the documented level, and it is enough to work with.

The workflow, at the documented level

Start from a verified single-board set: run the stack through loading and aligning the layers and confirm the set aligns before you multiply it — panelizing a misregistered board manufactures the error several times over. Export the panel data layer by layer: for each Gerber layer, produce the panel version by writing the board’s data at each planned position, using the documented translate/rotate and origin options to place copies, and do the same for the drill data so holes multiply with the copper — the commands in exporting to PDF, PNG or SVG show the same -x/-o pattern for picture output. Work in a dedicated panel folder, keep the single-board originals untouched in their own folder, and name panel files unmistakably (panel in the filename, plus the arrangement, such as the copy count) so nobody can confuse a panel file with the single-board file it came from. Repeatability is the quiet prize: once the placements are written down, re-running the same export for revision C of the board produces the same panel, updated.

Verify the panel like any other board

A generated panel is just another fabrication set, and it gets the full inspection. Open the panel files in Gerbv exactly as exported: the copies should appear in the planned grid, every layer present, drill hits multiplied in step with the pads. Then measure — measuring distances and clearances is the tool for this pass: the overall panel width and height against your plan, the spacing between adjacent boards against the board house’s minimum, and the position of a copy in the far corner, because accumulated placement errors, if they exist, show up at the greatest distance from the origin. Check the outline layer especially carefully: rails, separation paths and board edges are the panel’s mechanical definition, and an overlap between two boards’ outlines is a manufacturing problem, not a cosmetic one. If anything is off, fix the placements in your command and regenerate — never edit the generated panel files by hand, or the next revision will silently lose the correction.

When to panelize yourself — and when not to

Do it yourself when you need a specific arrangement the board house will not guess: mixed boards on one panel, your own rails and tooling holes, or a panel that must match an assembly fixture you already own. Let the house do it when the board is simple and the run is a prototype. Either way, someone should view the final panel data before production; if the house panelizes, ask for the panel files back and run them through the same Gerbv check. The panel is the thing being manufactured, so the panel — not the single board — is the thing to approve, a principle the Gerber viewer checklist states for every order.

Frequently asked questions

Does Gerbv really panelize, or is that the board house’s job?

Both are real options. Panelizing boards into a single one through the command line has been a documented Gerbv capability since the 2.1.0 era. Many designers still let the board house panelize simple boards; doing it in Gerbv gives you control of arrangement, spacing and rails.

Which documented options place the copies?

For RS-274X and drill export, the man page documents -T for translate/rotate and -O for the export origin, with units in inch, millimetre or mil; -x selects the export format and -o the output file. Check the man page on your system for the exact invocation syntax of your build.

How do I know the generated panel is correct?

View it like any fabrication set: open the panel files in Gerbv, confirm every copy and layer is present, and measure the overall panel size, the inter-board spacing and a far-corner copy’s position against your plan before ordering.