Open-source project
reactor/reactor-netty avatar
reactor/reactor-netty

Reactor Netty: a dependency snippet pinned to a milestone, a JDK 1.8 build line and two samples that stop mid-call

TCP/HTTP/UDP/QUIC client/server with Reactor over Netty

2,775 stars716 forksJavaApache-2.0

At a glance

What is it?
The Reactor project wrapper around Netty for non-blocking TCP, HTTP, UDP and QUIC clients and servers. Its getting-it snippet uses the retired compile configuration and pins milestone coordinates inside a block that says stable releases only, the build instructions ask for JDK 1.8, and the repository tree carries four artifacts the snippet never names.
Who is it for?
Use it when you are already working with Project Reactor and want a non-blocking client or server with backpressure handled by the framework, and read the release notes for the 1.4.0 line before upgrading, because the current stable artifact is 1.3.7 while two milestones have shipped since.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Java, 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.

From daily snapshots

Star history

  • reactor/reactor-netty2,775 ★ · -1
Star history
Repository2026-09-282026-11-15
reactor/reactor-netty2.8k2.8k

-1 Stars in the last 48 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The dependency snippet pins a milestone inside a stable-releases-only block

The getting-it section is short, and two details in it do not agree with each other. The prose says the artifact comes from Gradle against repo.spring.io or from Maven Central, stable releases only. The repositories block that follows leaves the snapshot repository commented out and calls mavenCentral. Then the dependencies block pins milestone coordinates:

groovy
    dependencies {
      //compile "io.projectreactor.netty:reactor-netty-core:1.4.0-SNAPSHOT"
      compile "io.projectreactor.netty:reactor-netty-core:1.4.0-M2"

So the example a reader copies declares 1.4.0-M2, a milestone build, in a repository block labelled for stable releases, with the snapshot line commented out directly above it. The configuration name compounds the problem: compile is the dependency configuration that later Gradle versions replaced, so the snippet is written for an older Gradle than the wrapper shipped in this repository. The badge at the top of the page points at the artifact entry in a public Maven index under io.projectreactor.netty, which is where the set of published versions can be compared, and the section closes by sending readers to the reference documentation for Maven, milestone and snapshot retrieval. The snippet is best read as an illustration of the naming scheme rather than as something to paste.

Java 8 to run, JDK 1.8 to build

The runtime floor and the build toolchain are stated in two different places, and they are not the same claim. Near the top, the library is said to require Java 8 or newer to run. In the building-from-source section the requirement is repeated as JDK 1.8 after the gradle wrapper, with no upper bound and no mention of a newer JDK for building. Building is otherwise a three command exercise:

shell
$ git clone https://github.com/reactor/reactor-netty.git
$ cd reactor-netty
$ ./gradlew build

The wrapper is what makes that work, so a contributor never installs Gradle, and the wrapper ships for both platforms with gradlew and gradlew.bat side by side, next to gradle.properties, settings.gradle, build.gradle and a gradle/ directory. Publishing locally has its own target, ./gradlew publishToMavenLocal, for the case where you want the artifacts in a local Maven repository to test against. The section opens by saying you do not need to build from source at all, because binaries are available from repo.spring.io, which puts building in the contributor's column rather than the user's.

Both getting-started samples stop mid-call

The getting-started code is presented as a very simple HTTP server and its client, and both listings end before the expression they start is finished. The server sample begins with HttpServer.create(), described inline as preparing a server ready for configuration, then .port(0), where the comment explains that zero lets the system pick up an ephemeral port when binding. It then routes a single POST path with a path parameter, routes.post("/test/{param}", and its last printed line is response.sendString(request.receive(). The client sample reads the other way round: it takes the port from the server object, .port(server.port()), selects POST, sets the path /test/World, sends a body with ByteBufFlux.fromString(Flux.just("Hello")), aggregates the response, converts it with asString and ends at .log("http-client". Neither sample shows the terminal step that would start the work, so the pair demonstrates the shape of the fluent builder rather than a program you can run top to bottom. The port comment is the part worth keeping: it is why the client asks the server for its port instead of hard-coding one.

The tree ships four artifacts the dependency snippet never names

The page claims non-blocking, backpressure-ready TCP, HTTP, UDP and QUIC clients and servers, and the repository description phrases it as a client and server with Reactor over Netty. The coordinate example, however, names two artifacts, reactor-netty-core and reactor-netty-http, and the tree is wider than that. Alongside those two sit reactor-netty-quic/ for QUIC, reactor-netty-http-brave/ for the Brave tracing integration, reactor-netty-examples/, and reactor-netty-graalvm-smoke-tests/, a module whose name says its whole job: check that the library still works against a native image toolchain. There is also a reactor-netty/ directory beside them, which reads as the aggregator project rather than another protocol, so the TCP and UDP families live inside core while HTTP lives in its own module. None of the four extra directories appears in the getting-it section or in the guides list, so the set of published artifacts has to be read off the repository layout rather than off the documentation.

The stable line and the 1.4.0 milestone line move in parallel

The release history shows two tracks running at once. v1.3.7 was published on 2026-08-24 at 02:42:52Z and v1.4.0-M1 was published the same morning at 03:03:47Z, twenty one minutes later, and v1.4.0-M2 followed on 2026-09-24. The last commit on the default branch main is dated 2026-10-01, a week after that second milestone, so commits have landed since the newest tag. That gives a reader two different answers to what the current version is, and the getting-it snippet resolves the ambiguity by pinning M2 while the prose says stable releases only. The upgrade guidance acknowledges that this happens: the help section sends anyone upgrading to the release notes first, for upgrade instructions and for new and noteworthy features, which is where a milestone-only change would be described. No release note is reproduced on this page, so nothing here says which line to use in production.

Getting help means two channels for questions and one for bugs

Support is spread across more than one place, and the page is explicit about the order to try. Questions are monitored on a Stack Overflow tag called reactor-netty, and a Gitter room is offered for chat; bugs go to the issue tracker on GitHub, and the project uses GitHub's integrated issue tracking for both bugs and feature requests. Before filing anything, the page asks you to search the issue tracker, and then to give as much information as possible: the version of Reactor Netty in use, the operating system, and the JVM version. Two documents sit above that, one for support and deprecation policies maintained across the wider Reactor organisation and one security policy specific to this repository, which is where a vulnerability report belongs instead of the public tracker. The contribution guide is maintained the same way, hosted outside this repository, so all three links point at shared files rather than at local policy. Note what that arrangement means for a reader: an upgrade question and a bug travel to three different places.

Two workflow badges, a codequality directory and no test instructions

The badge row is short and it names the two pipelines that run for the project: a publish workflow and a CodeQL analysis workflow. Both are referenced through the actions directory rather than described, and the repository root shows no other visible build or test entry point, so what runs in CI beyond publishing and static analysis is not stated on this page. A codequality/ directory sits beside the modules, holding quality configuration for a project whose Java sources live in the reactor-netty-* directories, and .editorconfig and .gitattributes sit at the root beside .github/. The contributor surface is thin by design, since building is delegated to the wrapper and the contribution guide is hosted elsewhere. What the page does not offer is any local test command: there is no mention of running a test suite, running an integration test or pointing the build at a local server, which for a networking library that ships an examples module and a native image smoke test module is the largest documented gap here.

Documentation lives on projectreactor.io and on a workshop site

Everything the page does not explain is delegated to two external places. The reference documentation on projectreactor.io is where Maven usage, milestone retrieval and snapshot retrieval are described, and it is linked three times: once as the place to read about getting it, once as the general reference, and again in the guides list at the bottom. The second place is a workshop hosted on a personal site, linked both as a getting-started suggestion for newcomers and again in the guides, and it exists in part because the code samples on this page stop mid-call. API documentation has its own address under its own heading, generated per release rather than from a branch, and the project home is projectreactor.io itself. The repository is Apache License 2.0 with the licence text at the root. The practical consequence is that this page is a signpost: the questions it cannot answer, including version choice, Maven setup and how to test a change, are answered one hop away.

Editorial conclusion

Use it when you are already working with Project Reactor and want a non-blocking client or server with backpressure handled by the framework, and read the release notes for the 1.4.0 line before upgrading, because the current stable artifact is 1.3.7 while two milestones have shipped since. Take coordinates from the reference documentation rather than from the README snippet, which pins a milestone, uses a configuration name current Gradle no longer has, and mixes it with a stable-releases-only repository block. Whatever you build against, decide the JDK deliberately: the documented runtime floor is Java 8 and the documented build toolchain is JDK 1.8, and neither line is a claim about newer JDKs.

Frequently asked questions

What is reactor netty?

A set of non-blocking, backpressure-ready TCP, HTTP, UDP and QUIC clients and servers built on the Netty framework, published by the Reactor project under the io.projectreactor.netty group, with reactor-netty-core and reactor-netty-http as the two artifacts named in the getting-it section. It requires Java 8 or newer to run.

What does reactor netty http give me?

The HTTP side ships as the reactor-netty-http artifact, separate from reactor-netty-core. The getting-started pair builds an HttpServer with port(0) so the system picks an ephemeral port, and an HttpClient that asks the server object for that port before posting to a path with a parameter.

Is reactor netty better than Tomcat or Jetty?

This repository does not compare itself to Tomcat or Jetty, so there is no comparison to draw from it. The structural facts it does state are that Reactor Netty is a non-blocking, backpressure-ready layer over Netty for TCP, HTTP, UDP and QUIC, and that it requires Java 8 or newer.

How does reactor netty relate to plain Netty?

It is built on Netty rather than replacing it, offering clients and servers in the TCP, HTTP, UDP and QUIC families with non-blocking behaviour and backpressure. The repository also contains modules beyond core and HTTP, including reactor-netty-quic, reactor-netty-http-brave and reactor-netty-graalvm-smoke-tests.

How do I get milestone or snapshot builds of Reactor Netty?

The reference documentation covers Maven usage and how to retrieve milestones and snapshots. The getting-it snippet shows a commented snapshot repository line at repo.spring.io and mavenCentral for stable releases, while its own coordinates are pinned to the 1.4.0-M2 milestone.

Does Reactor Netty work with Spring Boot?

Nothing on this repository page addresses Spring Boot, and its dependency and build instructions are Gradle and Maven only. What it does state is that the artifacts live under the io.projectreactor.netty group and that reference documentation, release notes and a support and deprecation policy are published under the wider Reactor organisation.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. reactor/reactor-netty on GitHub
  4. README
  5. Releases
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/reactor-reactor-netty.svg)](https://hysenlabs.com/projects/reactor-reactor-netty)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/reactor-reactor-netty.svg)](https://hysenlabs.com/projects/reactor-reactor-netty)

Was this useful?