EasyDarwin: a Go RTSP streaming server built on lalmax

What EasyDarwin 8.x actually is, and who it is for

EasyDarwin is a streaming media server that accepts RTMP and RTSP pushes and pulls, then redistributes each stream over RTMP, RTSP, HLS, HTTP-FLV, WebSocket-FLV or WebRTC. The repository's README describes the 8.x line as a secondary development built on the original EasyDarwin combined with the lalmax project, which is why go.mod carries both github.com/q191201771/lal and github.com/q191201771/lalmax as dependencies. The audience is fairly narrow: engineers who run cameras or encoders on a private network and want one process to fan a single feed out to browsers, players and recorders without paying per-stream licence fees. The MIT licence removes the commercial restriction that dominates this category. If your problem is "one RTSP camera, six viewers, one of them a browser that cannot speak RTSP," that is exactly the shape this project targets. If your problem is large-scale transcoding, it is not: nothing in the README claims transcoding, and the protocol support is described as playing H264 and H265 rather than converting between them.

Relay, keyframe cache and the protocol fan-out

The core mechanism is relay rather than re-encode. A pushed RTMP stream or a pulled RTSP stream enters the server once, and each output protocol is generated from that single ingest, which is why the description talks about optimization on streaming relay and keyframe cache. The keyframe cache matters for the browser protocols: a client connecting to HTTP-FLV or WebRTC mid-stream needs a decodable starting point, and caching the last keyframe lets the server begin a new subscriber at a frame boundary instead of dropping them into an undecodable stream. The repository layout reflects this split cleanly. cmd/server holds the executable, internal/core holds the business domain, internal/conf holds configuration models, internal/data holds the database and main configuration files, internal/web/api holds the RESTful API, and pkg holds dependency libraries. On the wire side, go.mod shows gortsplib for RTSP, gohlslib for HLS, gosrt for SRT, pion/webrtc for WebRTC and go-mp4 plus mp4ff for MP4 handling. Persistence is gorm over sqlite or postgres, with go-redis available, and the README lists sqlite, gorm and redis among the project dependencies. That stack is conventional and readable; there is no custom transport layer to learn.

Building EasyDarwin from source on Linux and Windows

The README is explicit that only source compilation is supported for generation and that one-click installation packages will be supported later, so there is no installer to download. Prerequisites are Go 1.23.0 installed and the Go bin directory added to the system environment variables. The repository also ships EasyDarwin.exe at the top level, but the documented path is to build. Start by cloning and resolving modules:

git clone https://github.com/EasyDarwin/EasyDarwin.git
cd EasyDarwin
go mod tidy

On Linux, the Makefile target produces a versioned build directory. Run:

make build/linux
cd build
cd EasyDarwin-lin-"version"-"build-time"
easydarwin

On Windows the README asks for the git bash terminal with Mingw installed, and the build command is mingw32-make.exe build/windows followed by running EasyDarwin.exe from the generated folder. Once the process is up, open http://localhost:10086 in a browser; the README gives this as the entry point for the web interface, where you add a streaming protocol. For an RTMP push, the README's example ffmpeg command is:

ffmpeg -re -i ./video.flv -c copy -f flv -y rtmp://localhost:21935/live/stream_1?sign=5F9ZgWP6fN

The sign parameter is the push authentication value the README shows in its example. The equivalent OBS configuration is Service Custom, Server rtmp://localhost:21935/live/, and Stream Key stream_1?sign=5F9ZgWP6fN. For an RTSP pull instead, you add the camera URL directly; the README gives Hikvision's rtsp://username:password@host:port/Streaming/Channels/101 and Dahua's rtsp://username:password@ip:port/cam/realmonitor?channel=1&subtype=0 as formats. The README also notes that EasyDarwin can run as a system service, with easydarwin -service install, -service start, -service restart, -service stop and -service uninstall.

The configuration story is the weakest part of the repository

The default configuration directory is config.toml located in the same directory as the executable file, and that single sentence is close to all the README says about configuration. The Ports subsection is literally a TODO comment. This is a real problem for anyone planning a deployment, because the README's own examples reference at least two ports, 10086 for the web interface and 21935 for RTMP ingest, and there is no documented table of what else the server binds, no description of the keys inside config.toml, and no guidance on changing them. You can read internal/conf and configs to work it out, but that is source archaeology rather than documentation. Treat port planning as a task you must complete before rollout, not something the README hands you. The Dockerfile has a related mismatch: it exposes 8080 and runs ./bin from ./build/linux_amd64/bin, while the README's web entry point is 10086. Whichever port the binary actually listens on inside the container, the Dockerfile as written does not advertise it, so a container deployment needs the port mapping checked against the running process rather than assumed from the Dockerfile.

Where EasyDarwin is the wrong tool

The README itself lists User Authentication under features to be added, which means the current release does not ship it. Push stream authentication does exist, and the sign parameter in the RTMP push URL is the visible part of it, but that is authentication for ingest, not a login system for the management interface or for viewers. The README also states that a camera feed can be viewed through a single stream URL without requiring login or API calls, and presents that as a feature. For a closed LAN that is convenient. For anything reachable from the internet it is a deliberate exposure, and you should not deploy it that way. The second limitation is scale. The README's description mentions distributed load balancing and a simple streaming media cloud platform architecture, but that language comes from the older project description; the 8.x README gives no configuration, no example and no operational guidance for running more than one node. If you need a documented multi-node deployment, this repository does not currently provide one. Third, on-demand playback that automatically disconnects when no viewers are present is described as saving bandwidth, which is useful, but it also means a stream you expected to stay warm may be torn down and re-established, and the README does not document the timeout that governs it.

EasyDarwin compared with ZLMediaKit and Monibuca

The two names that come up alongside EasyDarwin are ZLMediaKit and Monibuca, and the difference is mostly about language and packaging rather than protocol coverage. ZLMediaKit is a C++ media server, which means it ships as a compiled binary you can drop onto a machine without a toolchain, and its build and deployment path is aimed at people who want a running server rather than a Go workspace. EasyDarwin 8.x asks you to install Go 1.23.0 and run make build/linux, and the README says one-click packages will come later, so the barrier to the first running process is higher here. Monibuca is a Go media server built around a plugin architecture, where protocol support is assembled from plugins rather than compiled into one binary; EasyDarwin instead pins its protocol libraries in go.mod and builds a single executable. That makes EasyDarwin's dependency surface easier to audit, since go mod graph shows exactly which RTSP, HLS and WebRTC libraries are in play, but it also means adding a protocol you did not anticipate is a code change rather than a plugin install. The other related name, EasyPlayer, is a player, not a server, and appears in the same searches because the two are used together rather than because they compete.

Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-04-07. The release tags are much older: v7.2.17.0308 dates from 2017-03-07 and v7.0.1 from 2015-07-27, so the tagged releases do not describe the 8.x code on master. If you build from master you are tracking an untagged branch, and there is no release note stream to read before upgrading. The Makefile derives the version from Git tags, falling back to the nearest tag plus a commit count when the current commit is untagged, which means a build from master will carry a version string derived from a 2017 tag. That is worth knowing before you put a version number in a deployment record. On licensing, EasyDarwin is MIT, and the README states it plainly. MIT is permissive, so the practical question is not EasyDarwin's own terms but the terms of what you link against and redistribute. The Dockerfile adds ca-certificates and tzdata to an Alpine base, which is a normal redistribution question, and the frontend in web/ and web-src/ may carry its own notices. Read LICENSE.txt and the dependency licences yourself; this is not legal advice. Upgrade cost is currently low in one sense and high in another: there is no migration path to follow because there are no published 8.x releases, but there is also no compatibility promise, so a pull from master can change behaviour without a version boundary to point at.

Editorial conclusion

Adopt EasyDarwin if you want an MIT-licensed, self-hosted RTSP and RTMP relay with a web interface and no per-stream licence fee, and you are willing to compile it yourself with Go 1.23.0. Do not adopt it if you need a signed installer, a documented port reference, or user authentication today: the README lists user authentication under features still to be added, and the ports section is an empty TODO. Before committing, clone the repository, run go mod tidy, build for your platform, and confirm that config.toml next to the binary exposes the ports you actually need.

Frequently asked questions

Official sources

1. EasyDarwin/EasyDarwin on GitHub
2. License: MIT
3. Project website
4. README
5. Releases