Network UPS Tools: one C daemon tree that turns a UPS into a state you can poll
The Network UPS Tools repository. UPS management protocol Informational RFC 9271 published by IETF at https://www.rfc-editor.org/info/rfc9271 Please star NUT on GitHub, this helps with sponsorships!
At a glance
- What is it?
- Network UPS Tools splits UPS handling into drivers, a server and command line clients, and the repository also carries the work behind IETF RFC 9271. It suits administrators who want raw device data over a socket instead of a vendor cloud, and the build stays a source build driven by autogen.sh and configure.ac.
- Who is it for?
- Adopt NUT when a rack mixes UPS models and you want one polling interface across all of them, and when you can build from source with autogen.sh and configure.ac rather than wait on a distribution package. Do not adopt it for a single consumer unit your distribution already packages for you, or for an appliance with no shell, because you would inherit a C build and a conf/ entry for a problem you do not have.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- networkupstools/nut4,501 ★ · +133
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| networkupstools/nut | 4.4k | 4.5k |
133 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Drivers, server and clients are three separate trees, not one binary
The repository layout is the architecture. The drivers/ directory holds the per-model code that speaks to a physical unit, server/ holds the daemon that aggregates those connections, and clients/ holds the command line tools that read from it. Between them sit common/, lib/ and include/, which is where shared code and headers live. Nothing in the tree couples a client to a driver. A client asks the server what it knows; the server asks the driver; the driver is the only part that knows the wire protocol of your particular UPS.
That split is the reason NUT scales to a mixed estate. A rack with units from three vendors needs three driver builds, not three monitoring systems, because the server presents one vocabulary to every client on top. The tree also carries conf/ for device definitions, scripts/ for auxiliary programs, tools/ for standalone utilities, tests/, data/, and docs/ for the manual set. GitHub lists C as the primary language.
The repository also authors the UPS management protocol, RFC 9271
The repository description points at an Informational RFC, RFC 9271, published by IETF, as the project's protocol work. An Informational RFC carries no standards-track obligations, which is worth knowing before you design around it: it documents what the community agreed on, not what interoperability testing enforces. NUT is therefore both an implementation and an author of the vocabulary it implements, a situation that gives the project unusual influence over how monitoring systems name UPS states but also means the specification and the daemon can drift together without an external referee.
The project's public face sits at networkupstools.org, and the default branch is master.
The top-level README is a build of the documentation toolchain, not an installation guide
Here is the detail a skim misses. The file you land on first, README.adoc, opens with asciidoc include directives guarded by //GH_MARKUP_1095 markers and pulls in docs/asciidoc-vars.conf, and it opens with a long block of comments explaining that GitHub's Web UI does not process include: requests, and why links on GitHub point at the rendered nut-website pages rather than at neighbouring files in the source browser.
The project homepage is networkupstools.org, and the tree itself shows the path from source. autogen.sh sits at the root next to configure.ac and Makefile.am, which is the autotools route, and ci_build.sh plus ci_build.adoc describe how continuous integration drives that build. The root also carries INSTALL.nut.adoc.
A failed build is usually a missing development dependency, not a NUT bug
NUT ships as source with autotools glue rather than as a self-contained binary, so the first thing an adopter meets is a configure step. Plan for that by reading configure.ac before you start rather than after it fails.
Second failure mode is configuration, not compilation. A device definition in conf/ has to match the unit you own: how NUT addresses it, which driver claims it, and what parameters the driver needs such as a port name or a device node.
Why UPGRADING.adoc outranks your distribution's frozen package
Upgrade cost here is not measured in breaking changes but in how long a fix waits to reach you. This is a project that batches work and cuts a numbered build when a cycle is ready rather than when a patch lands, a defensible choice for a codebase carrying drivers for many vendors, but one that leaves long quiet stretches for operators sitting on an old build.
Because of that, UPGRADING.adoc, which exists in the root specifically to track changes between numbered builds, deserves a read before you move forward rather than after something misbehaves. Distribution packages sit further behind still, so you will be on whatever your vendor froze unless you build.
Licence-wise the root carries COPYING alongside LICENSE-GPL2 and LICENSE-GPL3, plus a separate LICENSE-DCO for contributions. Read those files yourself if you redistribute a build rather than trusting a repository label.
Six build surfaces at the root, from AppVeyor to Open Build Service
Look at what is in the root: .circleci/, .travis.yml, appveyor.yml, Jenkinsfile-dynamatrix, .lgtm.yml and an .obs/ directory. Six build surfaces for a C project that produces a daemon, a set of drivers and command line clients. That spread exists because NUT targets far more than one Linux distribution: AppVeyor covers the Windows side, the .obs/ directory relates to the Open Build Service, and Jenkinsfile-dynamatrix is the name given to the matrix job.
The same spread is the project's real weakness. Every extra build surface is another set of dependency versions, and a change that passes on one can fail on another for reasons that have nothing to do with your UPS.
Where NUT differs from a vendor cloud or a single-purpose apcupsd
The alternative most administrators compare against is a vendor monitoring service, or a single-model daemon written for one UPS family. The difference is architectural rather than a matter of quality. A vendor service moves device data off your premises and answers through an API you did not design and cannot extend; NUT keeps the driver on your host, exposes state locally through its own socket, and lets you build whatever client you need on top of it. A single-purpose daemon does the opposite of generality: it is small and has one code path, and it stops working the day you add a different brand to the rack.
Where NUT loses is breadth of hardware knowledge. Its driver list is finite. If your unit is well supported, NUT gives you a uniform interface across an estate that no single-purpose tool can. If it is not, you are reading driver source and adding parameters yourself.
Editorial conclusion
Adopt NUT when a rack mixes UPS models and you want one polling interface across all of them, and when you can build from source with autogen.sh and configure.ac rather than wait on a distribution package. Do not adopt it for a single consumer unit your distribution already packages for you, or for an appliance with no shell, because you would inherit a C build and a conf/ entry for a problem you do not have. Verify first that a driver exists in drivers/ for your exact model and that the matching conf/ entry matches the unit's address and protocol before any monitoring depends on it.
Frequently asked questions
Which UPS brands are compatible with NUT?
Support is decided per model by the drivers in the drivers/ directory rather than per brand, since one vendor's lineup can need several drivers. Each driver speaks the protocol of a specific unit.
How does NUT work?
A driver in drivers/ talks to the physical unit, the server daemon in server/ collects what the drivers report, and clients in clients/ query that shared state. Clients never speak to the hardware directly, which is what lets one client read a mixed fleet.
What is Network UPS Tools?
Network UPS Tools is a C suite for monitoring and controlling uninterruptible power supplies, split into drivers, a server and command line clients under one repository. The project homepage is https://networkupstools.org/ and the default branch is master.
Can I run the NUT server on Windows?
The repository carries appveyor.yml and .obs/ alongside .circleci/ and .travis.yml, which indicates Windows and distribution packaging are covered by the project's own continuous integration. Check INSTALL.nut.adoc and the docs/ tree before planning a Windows deployment.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/networkupstools-nut)Star history chart for your README
[](https://hysenlabs.com/projects/networkupstools-nut)Was this useful?