NGINX Unit - universal web app server - a lightweight and versatile open source server that simplifies the application stack by natively executing application code across eight different programming language runtimes.
Find a file
Ava Hahn 706ea1a689 tools/unitctl: Enable Multi Socket Support
This commit refactors the CLI code to accept
multiple instances of the control socket flag.
All subcommands except for edit and save now
support being run against multiple specified
instances of unitd.

* control_socket_addresses CLI field is now a vector
* centralize error related logic into the error module
* wait_for_socket now returns a vector of sockets. all
  sockets in vector are waited upon and validated
* extraneous code is removed
* applications, execute, import, listeners, and status
  commands all run against N control sockets now
* edit and save commands return error when run against
  a single control socket

Signed-off-by: Ava Hahn <>
2024-07-08 11:58:09 -07:00
.github ci: tweak unitctl github release 2024-06-18 13:33:15 -07:00
auto auto, wasm-wc: Copy the .so into build/lib/unit/modules/ 2024-07-08 15:43:17 +01:00
docs tools/unitctl: implement application subcommand 2024-06-18 16:21:10 -07:00
fuzzing fuzzing: Add a .gitattributes file 2024-06-14 15:11:38 +01:00
go Go: Add missing +build and go:build comments 2024-01-10 11:15:48 -05:00
pkg Packages: removed CentOS 7 due to EOL 2024-07-03 16:12:36 -07:00
src python: Constify some local static variables 2024-07-03 20:41:00 +01:00
test tests: Add tests for python application factories 2024-07-02 19:13:14 +01:00
tools tools/unitctl: Enable Multi Socket Support 2024-07-08 11:58:09 -07:00
.gitattributes Packages: Move dist target to git archive 2024-02-16 13:14:35 -08:00
.gitignore Added .gitignore. 2022-05-03 12:41:36 +02:00
.hgignore Added .hgignore file. 2020-09-18 19:37:56 +01:00
.hgtags Unit 1.31.1 release. 2023-10-19 11:47:22 +01:00
.mailmap .mailmap: Add an entry for Ava's GitHub address 2024-05-14 23:57:51 +01:00
.rustfmt.toml Add a .rustfmt.toml file 2024-02-21 16:20:32 +00:00
CHANGES Docs: njs (lowercase) is more preferred way to mention 2024-04-10 13:30:02 +01:00 Adding the NGINX Code of Conduct to the repo. 2023-03-07 13:05:41 +00:00
configure auto: Don't install $runstatedir 2024-06-18 22:59:45 +02:00 Docs: replaced the slack community links with GitHub Discussions 2024-01-10 17:12:05 +01:00
LICENSE Added LICENSE and NOTICE files. 2017-09-06 18:26:37 +03:00
NOTICE Updated copyright notice. 2024-02-20 16:08:36 +00:00 Add a GitHub discussions badge to the README 2024-06-10 16:24:09 +01:00
SECURITY.txt Updated security.txt 2024-01-11 11:45:20 -05:00
version Version bump 2024-02-27 12:24:44 +00:00


Project Status: Active – The project has reached a stable, usable state and is being actively developed. CI GitHub Discussions

Universal Web App Server

NGINX Unit Logo

NGINX Unit is a lightweight and versatile open-source server that has two primary capabilities:

  • serves static media assets,
  • runs application code in seven languages.

Unit compresses several layers of the modern application stack into a potent, coherent solution with a focus on performance, low latency, and scalability. It is intended as a universal building block for any web architecture regardless of its complexity, from enterprise-scale deployments to your pet's homepage.

Its native RESTful JSON API enables dynamic updates with zero interruptions and flexible configuration, while its out-of-the-box productivity reliably scales to production-grade workloads. We achieve that with a complex, asynchronous, multithreading architecture comprising multiple processes to ensure security and robustness while getting the most out of today's computing platforms.



Run the following command to install both unitd (the Unit daemon) and unitctl (the control tool).

$ brew install nginx/unit/unit

For details and available language packages, see the docs.


$ docker pull unit:<TAG>
$ mkdir /tmp/unit-control # customize as needed.
$ docker run -d \
      --mount type=bind,src=/tmp/unit-control,dst=/var/run \
      --mount type=bind,src=.,dst=/www \
      --network host \

For a description of image tags, see the docs.

WARNING: latest image tag may not provide support for specific language modules, do check the available image tags from the link above before pulling your image.

Your current working directory will now be mounted to the Unit image at /www. You can reach its socket at /tmp/unit-control/control.unit.sock assuming no further customizations have been made.

Debian, Ubuntu, Amazon Linux, Fedora, Red Hat

This helper script configures the correct package repositories for system.

$ wget && chmod +x setup-unit
# ./setup-unit repo-config

Debian derivatives:

# apt install unit

Fedora derivatives:

# yum install unit

For details and available language packages, see the docs.

Getting Started with unitctl

unitctl streamlines the management of NGINX Unit processes through an easy-to-use command line interface. To get started with unitctl, download it from the official GitHub releases or Homebrew.



If you installed Unit with Homebrew, you can skip this step as unitctl is included by default.

Download the appropriate unitctl binary for your system from the NGINX Unit releases.

$ tar xzvf unitctl-master-x86_64-unknown-linux-gnu.tar.gz
# mv unitctl /usr/local/bin/

Launch Unit using Docker

If you have Docker installed on your machine, and then you can effortlessly spin up one of Unit's official Docker images alongside your application.


How-to and configuration guides are available on for web application frameworks built with Python, PHP, WebAssembly, Node.js, Ruby, and more.

Here's an example using the unit:python Docker image:

$ unitctl instances new /path/to/app 'unit:python'

/path/to/app will mount to /www in the Docker filesystem.

Save this to /path/to/app/

def application(environ, start_response):
    start_response("200 OK", [("Content-Type", "text/plain")])
    return (b"Hello, Python on Unit!")

You can then interactively edit the currently active configuration:

$ unitctl edit
  "listeners": {
    "*:8000": {
      // Point listener to new application
      "pass": "applications/python"

  // Add an application definition
  "applications": {
    "python": {
        "type": "python",
        "path": "/www/",
        "module": "wsgi"

Valid configurations will be applied upon save and close.

$ curl localhost:8000

Hello, Python on Unit!

More Python configuration examples can be found in the Unit docs.

Hello World with PHP and curl

Unit runs apps in a variety of languages. Let's explore the configuration of a simple PHP app on Unit with curl.

Suppose you saved a PHP script as /www/helloworld/index.php:

<?php echo "Hello, PHP on Unit!"; ?>

To run it on Unit with the unit-php module installed, first set up an application object. Let's store our first config snippet in a file called config.json:

    "helloworld": {
        "type": "php",
        "root": "/www/helloworld/"

Saving it as a file isn't necessary, but can come in handy with larger objects.

Now, PUT it into the /config/applications section of Unit's control API, usually available by default via a Unix domain socket:

# curl -X PUT --data-binary @config.json --unix-socket  \
       /path/to/control.unit.sock http://localhost/config/applications
	"success": "Reconfiguration done."

Next, reference the app from a listener object in the /config/listeners section of the API. This time, we pass the config snippet straight from the command line:

# curl -X PUT -d '{"": {"pass": "applications/helloworld"}}'  \
       --unix-socket /path/to/control.unit.sock http://localhost/config/listeners
    "success": "Reconfiguration done."

Now Unit accepts requests at the specified IP and port, passing them to the application process. Your app works!

$ curl

      Hello, PHP on Unit!

Finally, query the entire /config section of the control API:

# curl --unix-socket /path/to/control.unit.sock http://localhost/config/

Unit's output should contain both snippets, neatly organized:

    "listeners": {
        "": {
            "pass": "applications/helloworld"

    "applications": {
        "helloworld": {
            "type": "php",
            "root": "/www/helloworld/"


Unit supports running WebAssembly Components (WASI 0.2). For more information see the Unit Configuration Docs.

OpenAPI Specification

Our OpenAPI specification aims to simplify configuring and integrating NGINX Unit deployments and provide an authoritative source of knowledge about the control API.


  • The go-to place to start asking questions and share your thoughts is GitHub Discussions.

  • Our GitHub issues page offers space for a more technical discussion at your own pace.

  • The project map on GitHub sheds some light on our current work and plans for the future.

  • Our official website may provide answers not easily found otherwise.

  • Get involved with the project by contributing! See the contributing guide for details.

  • To reach the team directly, subscribe to the mailing list.

  • For security issues, email us, mentioning NGINX Unit in the subject and following the CVSS v3.1 spec.