Model or dataset
jetlinks/jetlinks-community avatar
jetlinks/jetlinks-community

JetLinks Community: a reactive Java IoT platform you can run with Java 17, Redis and TimescaleDB

JetLinks is a fully reactive enterprise IoT platform built on Java, Spring Boot, WebFlux, Netty, Vert.x and Reactor. Supports unified device-model management across multiple device types and vendors, multi-protocol connectivity (TCP, MQTT, UDP, CoAP, HTTP, etc.), real-time data processing, device alerts, notifications, data forwarding, geolocation and data visualization, helping you quickly build IoT business systems.

6,687 stars1,942 forksJavaApache-2.0

At a glance

What is it?
JetLinks Community is an Apache-2.0, Spring Boot 3 and WebFlux based IoT platform that unifies device access across MQTT, TCP, UDP, CoAP and HTTP. It is aimed at Java teams that want the platform source in hand, and it expects you to bring PostgreSQL, Redis and a time-series store.
Who is it for?
Adopt JetLinks Community if your team already writes Java and Spring Boot and you want protocol adapters, a unified thing model and a rule engine in one codebase you can modify. Do not adopt it if you need a managed cloud service, cannot operate PostgreSQL, Redis and TimescaleDB, or expect English documentation to match the Chinese README.
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 6 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

  • jetlinks/jetlinks-community6,687 ★ · +47
Star history
Repository2026-09-232026-11-15
jetlinks/jetlinks-community6.6k6.7k

47 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What JetLinks Community solves, and for whom

Building an IoT backend from scratch means writing the same layers repeatedly: a connection manager that keeps thousands of sockets alive, a decoder per vendor protocol, a model that describes what a device is, storage for the time-series it emits, and something that fires an alarm when a reading crosses a threshold. JetLinks Community packages those layers as one Java application. The README describes it as an enterprise IoT base platform that is ready to use and open to secondary development, covering unified thing model management, multi-vendor and multi-protocol device access, real-time data processing, device alarms, notifications and data forwarding.

The audience is narrow and specific. The README states version 2.1x is built on Java 17, Spring Boot 3.x, WebFlux, Netty, Vert.x and Reactor, and the primary language is Java. If your team does not write Java, the value proposition shrinks to a running product you cannot extend. For Java teams, the source is the point: the README lists full source availability, front-end and back-end separation, and fully open interfaces as core characteristics.

How the reactive pipeline and module split fit together

JetLinks is built as a reactive application end to end, not a servlet app with reactive patches. Spring WebFlux handles HTTP, R2DBC is the database driver, and Project Reactor supplies the programming model. Netty and Vert.x sit underneath the network layer. That matters because device access is long-lived connections and streams of messages, which is the workload reactive backpressure was designed for; a thread-per-request model would spend most of its threads blocked on sockets.

The repository layout shows how the pieces are separated. jetlinks-components holds shared building blocks with one directory per concern, among them common-component, configuration-component, dashboard-component, datasource-component, elasticsearch-component, gateway-component for message gateways and device access, io-component for Excel import and export, and logging-component. jetlinks-manager, jetlinks-standalone and simulator are further top-level directories.

The README states that device alarms and scene linkage are both managed by the unified rule engine rather than by separate subsystems, and that data permission control is non-intrusive and can be applied at menu, button and row level.

Running JetLinks Community with Docker and a first device

The README points at the docker directory as the entry point. Two subdirectories are named in the module listing: docker/dev-env, described as starting the development environment, and docker/run-all, described as starting everything, with the system reachable at http://localhost:8848. The repository also ships run.sh, mvnw, mvnw.cmd and build-and-push-docker.sh at the top level.

The README shows the module tree in a fenced block rather than a set of shell commands, so the layout is the documented artifact:

bash
--jetlinks-community
------|----docker
------|------|----dev-env       # 启动开发环境
------|------|----run-all       # 启动全部,通过http://localhost:8848 访问系统.
------|----jetlinks-components  # 公共组件模块

According to the README, the platform is then available at http://localhost:8848 when run-all is started. Read the contents of docker/run-all before starting it.

The README states the minimum runtime is Java 17, Redis and TimescaleDB, and that no large set of middleware is required. PostgreSQL is listed in the technology stack as the store for business data, and TimescaleDB is listed as optional time-series storage. Inspect docker/run-all to see which of those it provisions rather than assuming.

The repository also has a top-level simulator directory.

Where JetLinks Community is the wrong tool

The documentation is the first limitation. The README is written in Chinese, and the service support table lists free basic question answering through QQ groups, with system deployment, product usage and secondary development documentation also listed as free self-service.

The second limitation is operational weight. The README calls the minimal runtime Java 17, Redis and TimescaleDB, which is smaller than a full middleware estate but still three moving parts, plus PostgreSQL for business data. If you want a single binary with an embedded store, this is not that. If you want a hosted service where someone else runs the database, this is not that either.

The third is scope. JetLinks is a platform, not a library. The README lists a rule engine, data permission control and a dashboard component. If you only need an MQTT broker with a webhook, adopting a full platform means carrying modules you will never configure, and the reactive stack means debugging requires comfort with Reactor operators and R2DBC rather than JDBC. Size it with your own load testing.

How it differs from ThingsBoard and from rolling your own

The obvious comparison in this category is ThingsBoard, another open source IoT platform with device management, rule chains and dashboards. The difference JetLinks emphasises is the runtime: it is built on WebFlux, R2DBC, Reactor, Netty and Vert.x from the ground up, and its README makes that reactive stack the headline. If your team already thinks in Reactor and wants the device pipeline to share that model, JetLinks is the more natural fit.

The second alternative is writing the ingestion layer yourself. If your requirement is one protocol and one storage target, a Netty or Vert.x service plus a time-series database is a few hundred lines and no platform to learn. JetLinks earns its weight when you have several protocols, several vendors and a need for a shared thing model, alarms and forwarding rules. Below that threshold, the module list in this repository is overhead.

The third alternative is the vendor's own cloud. That trades source access and self-hosting for someone else running the databases. The README's emphasis on full source and open interfaces is a direct argument against that trade, and it is the reason the project exists in this form.

Maintenance, licensing and what an upgrade costs

The repository is not archived, and the last push was on 2026-11-02, so the codebase is being touched. The release history is uneven: 2.2.0 on 2024-09-27, 2.3.0 on 2025-04-27, and 2.10.0 on 2025-10-27, while the default branch is 2.11. The jump from 2.3.0 to 2.10.0 in the release list, with no intermediate tags shown, suggests releases are not cut on a fixed cadence. Plan upgrades around reading the source diff rather than around a predictable release train.

The upgrade cost is tied to the stack. The README pins Java 17 and Spring Boot 3.x, and the components span Netty, Vert.x, Reactor and R2DBC. A Spring Boot major or minor bump ripples through every component module, and the reactive chain means a changed operator signature surfaces at compile time across many files. Because the platform is meant for secondary development, any local modifications to jetlinks-components or jetlinks-manager become merge work on every upgrade. Keeping custom code in separate modules reduces that cost.

Licensing is Apache-2.0, per the LICENSE file at the repository root. That permits commercial use and modification, and it includes a patent grant; it also means you must preserve notices and state changes. The repository carries a licenses/ directory alongside the root LICENSE. Read both before shipping, and treat the licenses/ contents as the authoritative list of what else applies. This is a description of the files, not legal advice.

Editorial conclusion

Adopt JetLinks Community if your team already writes Java and Spring Boot and you want protocol adapters, a unified thing model and a rule engine in one codebase you can modify. Do not adopt it if you need a managed cloud service, cannot operate PostgreSQL, Redis and TimescaleDB, or expect English documentation to match the Chinese README. Before committing, verify the docker/run-all environment starts on your machine, confirm which optional stores your workload needs, and read the Apache-2.0 LICENSE and the licenses/ directory.

Frequently asked questions

What is JetLinks Community and who is it for?

It is an open source, Apache-2.0 enterprise IoT base platform built on Java 17, Spring Boot 3.x, WebFlux, Netty, Vert.x and Reactor. It targets Java teams that want unified device access across MQTT, TCP, UDP, CoAP and HTTP, a unified thing model, a rule engine and data forwarding, with source available for secondary development.

What do I need to run JetLinks Community?

The README states the minimal runtime is Java 17, Redis and TimescaleDB, plus PostgreSQL for business data as listed in the technology stack. The docker directory provides a dev-env setup and a run-all setup that exposes the system at http://localhost:8848.

Which protocols does JetLinks Community support for device access?

The README lists TCP, UDP, MQTT, HTTP, TLS and DTLS under unified device access, and the repository description also names CoAP.

Official sources

  1. jetlinks/jetlinks-community on GitHub
  2. License: Apache-2.0
  3. Project website
  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/jetlinks-jetlinks-community.svg)](https://hysenlabs.com/projects/jetlinks-jetlinks-community)

Star history chart for your README

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

Was this useful?