# OpenPnP: pick and place for people who would rather own the machine

> The reference open source SMT pick and place project, a Java application that controls a gantry you can build from motion control parts, plus a documentation culture that treats contributors unusually well.

**openpnp/openpnp** — Open Source SMT Pick and Place Hardware and Software

- Repository: https://github.com/openpnp/openpnp
- Website: http://openpnp.org
- Stars: 2,248 · Forks: 697
- Language: Java
- License: GPL-3.0
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/openpnp-openpnp

## A software project first, a machine project second

The introduction states the ambition in one paragraph: create the plans, prototype and software for a completely open source SMT pick and place machine that anyone can afford, using the ubiquity of cheap precise motion control hardware. The target price given is under $1000 for a fully functional machine. That number describes the bill of materials for the machine, not the cost of the software, which is free and GPL-3.0.

SMT pick and place means the machine that takes components out of tape feeders and trays and puts them on a printed circuit board. It is the step between a design that exists as a file and a board that exists in the physical world, and it is where hobbyist electronics projects usually stall, because the machines that do it well are expensive. The pitch here is that a machine assembled from stepper motors, linear rails and an open source controller can be built for a fraction of the commercial price, and the software to drive it is the same software a commercial machine would use.

The project status section makes a claim worth reading carefully: OpenPnP is stable and in wide use, and it is still under heavy development with new features added continuously. Both halves of that sentence are doing work. Stability means existing setups keep working, and heavy development means the thing you configure today may gain options tomorrow.

## What the repository actually contains

The tree tells you this is a mature Maven project rather than a hobby script. There is a `pom.xml`, a `CHANGES.md`, a `CONTRIBUTING.md`, an `ISSUE_TEMPLATE.md` and a `PULL_REQUEST_TEMPLATE.md`. Two launch scripts, `openpnp.bat` and `openpnp.sh`, sit at the root for Windows and Unix. `src/` holds the application, `samples/` holds machine and feeder definitions, `support/` holds supporting material, and `git-hooks/` suggests the project installs its own hooks rather than relying on everyone to configure them.

Two files carry more weight than their size suggests. `OpenPnP_2_0.md` is a forward-looking document about the next major version, and `VERSION.txt` is a plain text version marker, which is the kind of detail that matters when you are reporting a bug against a specific build. `TRANSLATIONS.md` indicates the user interface has been localized, which is unusual for a project of this size and tells you something about who is using it.

The language is Java and the releases are numbered 2.2, 2.4 and 2.6, with 2.6 published on 2026-03-01. The fork count of 694 against 2238 stars is a ratio that tells you a lot: people who care about this enough to run their own copy. For a machine that has to be adjusted to individual hardware, having many independent installations is a feature.

## Windows, macOS and Linux through an installer

The root of the tree contains `OpenPnP.install4j`, which is the installer definition. The README explains the arrangement in its acknowledgements: many thanks to ej-technologies for providing a complimentary license of install4j, which creates professional installers for Java applications. That sentence is a small masterclass in open source funding, because the tool that produces the actual downloadable builds was licensed for free rather than being reimplemented.

What that buys a user is a normal installation experience. Someone who wants to try OpenPnP downloads a build from the openpnp.org downloads page and runs an installer, rather than checking out the repository, resolving Maven dependencies and fighting a headless environment. The application window is a Java application, so the visual designer and the machine control run in the same process, which is what makes the interactive setup experience possible.

For contributors the picture is different and closer to the source. The README instructs you to read the developers guide before starting a pull request, and the summary guidelines are unusually concrete: one pull request per issue, describe the change, follow the coding style, include tests and documentation, and think of the big picture. The repository also carries `OpenPnP_Eclipse_Formatter.xml`, which is a formatting configuration for the Eclipse IDE. That file existing means the project enforces a consistent style automatically rather than arguing about it in review.

## Labels that show where the work is

The README embeds four issue labels as badges: help-wanted, bugs, feature requests and enhancements. Read together they map the project onto how open source maintenance actually goes. Bugs and feature requests are the ordinary intake channels. Help wanted is the one that matters for anyone arriving cold, because it marks work a maintainer has already scoped and would accept. Enhancements is a separate channel from feature requests, which suggests a distinction between adding something new and improving something that exists.

The label split also hints at the shape of the application. A pick and place machine has axes to calibrate, feeders to define, vision systems to align, and a board or panel layout to place components onto. Each of those is a place where behaviour differs between installations, which is why a `samples/` directory matters. Anyone evaluating the project should look there first: sample machine definitions are a more honest picture of what configuring a machine involves than any feature list.

The `SPONSORS.md` file at the root is worth noting too. Hardware projects rarely have a business model, and a sponsors file is the usual compromise between accepting money and keeping the project non-commercial. The `CONTRIBUTING.md` and `CODE_OF_CONDUCT.md` files round out a repository that has thought about how it wants people to arrive and behave.

## The community channels and what they are worth

The README lists four ways to follow the project: watch it on GitHub, the Twitter account, a Google Groups discussion group, and Discord. Listing a Google Group alongside Discord is a detail that dates the project's history, since Google Groups is not where new communities get started. Both are still linked, which suggests the older one retains an archive that people still search.

For anyone setting up a machine, the practical order is worth stating. The downloads page gets you a running application. The wiki's developer guide matters if you are contributing. Everything else, from the forum to the chat, is where the real configuration knowledge lives, because a pick and place machine that will not place parts reliably is a mechanical problem that experienced owners diagnose faster than documentation can describe.

The issue tracker is busy at 212 open issues, and that number should be read correctly. For hardware software where each installation is slightly different, a high open issue count is partly a sign of many active users rather than purely neglect. The last push was on 2026-09-26, well within the current development window, so the project is being worked on now.

## What building your own machine still costs

The $1000 target is real but it is a target, and the README is careful about the framing: with cheap precise motion control hardware, some ingenuity and plenty of open source software it should be possible to build one. Three conditions are named, and the middle one, ingenuity, is doing a lot of work. Nobody sells you a turnkey assembly of this machine, so the electrical design, the mechanical fabrication and the calibration all fall to the person building it.

The software side is where the repository removes essentially all of that risk. Once a machine is built and its axes are configured, the application handles the parts of the job that commercial machines are expensive for: place planning, feeder management, vision alignment, board setup and the nozzle handling. Those are features you would otherwise buy, and they are the reason the software is worth studying.

The honest framing for a reader is that this is a software project with a machine attached, not the other way around. Judge it on the application, the sample configurations and the contributor activity, then separately decide whether you are the kind of person who will enjoy commissioning a gantry. If you are, this is one of the few projects where both halves are genuinely open.

## Conclusion

OpenPnP is unusual among hardware projects because the software is the durable asset. The repository is a large, well tested Java application with a real contributor culture and 694 forks, and the machine it drives is deliberately assembled from commodity parts so the software does not age out from under you. What the project does not do is sell you a turnkey machine, which means the electrical and mechanical work is still yours. Read the developer guide before your first pull request, install a release from the downloads page rather than building from source, and budget real time for the machine even though the software will not demand it.

## FAQ

### Is there an open source pick and place machine available?

There is open source software that runs one, and the OpenPnP project is built around the idea that you can assemble the machine yourself. The stated goal is a functional SMT pick and place machine for under $1000 using commodity motion hardware. What is available to download today is the application, not a turnkey machine.

### What does OpenPnP do once the machine is built?

It is a Java application that drives the pick and place machine: it plans placements, manages feeders and trays, handles vision alignment, and controls the axes and nozzle. Once your hardware is built and calibrated, this is the part that replaces what you would otherwise pay a commercial machine to do.

### Is OpenPnP free software or also free hardware?

The software is free and licensed under GPL-3.0. The hardware is not a product anyone sells you. The project provides plans and the software for a machine you build yourself, which is why the README names ingenuity as one of the three conditions alongside cheap hardware and open source software.

### How do I install OpenPnP?

Download a build from the openpnp.org downloads page. The project ships installers produced with install4j, so on Windows and other platforms you run an installer rather than building from source. The repository also carries openpnp.bat and openpnp.sh launch scripts, which cover the case where you have cloned the source instead.

### Do I need to write code to contribute to OpenPnP?

Not necessarily. The README links a help-wanted issue label, which marks work a maintainer has already scoped and is willing to accept. The contributing guidelines ask for one pull request per issue, a description of the change, matching coding style, and tests and documentation alongside the code.

## Sources

- [License: GPL-3.0](https://github.com/openpnp/openpnp/blob/main/LICENSE)
- [openpnp/openpnp on GitHub](https://github.com/openpnp/openpnp)
- [Project website](http://openpnp.org)
- [README](https://github.com/openpnp/openpnp/blob/main/README.md)
- [Releases](https://github.com/openpnp/openpnp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openpnp-openpnp