Galene

Self-hosted WebRTC conferencing, honestly reviewed. No marketing fluff, just what you get when you compile and run it yourself.

TL;DR

• What it is: A self-hosted WebRTC videoconference server written in Go, MIT-licensed, designed originally for university lectures and academic conferences — then discovered to work fine for small meetings too [website].
• Who it’s for: Sysadmins and technical founders who need reliable, resource-light video calls on infrastructure they control — especially in education, small conferences, or privacy-sensitive contexts. Not for non-technical founders who have never touched a Linux server.
• Cost savings: Zoom charges $15.99–$19.99/mo per host, plus separate webinar licenses for larger events. Galene runs on a modest VPS — the project explicitly says it requires “very moderate server resources” — and costs exactly what your hardware costs [website].
• Key strength: Genuinely lightweight enough to run on OpenWRT (MIPS hardware) and ARM devices. Used in production at two major French universities for lectures, practicals, and seminars [website]. That’s a real track record.
• Key weakness: No end-to-end encryption — traffic is encrypted sender-to-server and server-to-receiver, but a server administrator could in principle access the stream [website]. The community is small (1,274 GitHub stars), third-party ecosystem tooling is still experimental, and the alternative web frontend (Pyrite) is currently on hold and out of date [website].

---

What is Galene

Galene is a videoconference server that compiles to a single Go binary and serves a JavaScript web client to browsers. You run the binary, define groups via JSON config files, and participants join through a URL. No heavy infrastructure dependencies beyond the binary itself.

The project was designed by Juliusz Chroboczek (a researcher at IRIF/Université de Paris) with a specific use case in mind: university lectures with many viewers, a few presenters, and the requirement that the whole thing run without renting Zoom licenses or trusting a SaaS platform with lecture recordings [website][README]. That origin shapes the product in ways that matter. Galene handles the asymmetric “one speaker, many listeners” model well, which is harder to pull off in tools designed around symmetric video calls.

In production terms: Université de Paris and Sorbonne Université have used it for lectures, practicals, seminars, and staff meetings. It’s been deployed for public conferences including SOCS’2020, JFLA’2021, and LibrePlanet 2024 [website]. That’s not a toy project; that’s a server that has handled real academic load.

The server side is Go with the Pion WebRTC implementation. The client is plain JavaScript. The server runs on Linux/amd64, Linux/arm64, Linux/armv7, Linux/mips (OpenWRT), macOS, and Windows. The mips/OpenWRT support is notable — this is a server that can run on consumer routers [website].

Development is currently funded by NLNet’s NGI0Core program, after earlier support from Nexedi [website]. It is not backed by a VC-funded company, which cuts both ways: no pricing pressure to monetize, but also a smaller team and a pace tied to grant funding.

---

Why people choose it

There are no meaningful third-party review articles specifically about Galene available at the time of this writing — the project is too small and too developer-focused to have attracted the usual review-site coverage. What does exist is the project’s own documentation, its production track record in academia, and user conversations in mailing list archives.

The pattern that emerges from available sources points to three reasons people pick Galene over its alternatives:

Resource efficiency. Galene was explicitly designed to be deployable on moderate hardware. The project’s homepage leads with this: “requires very moderate server resources” [website]. If you’re running a self-hosted stack on a small VPS or edge hardware, Jitsi Meet’s default installation (which wants 8GB RAM for anything serious) looks less attractive than a Go binary.

Academic and lecture fit. The group permission model and asymmetric stream design match how lectures work: an operator who can speak and share video, participants who can raise hands and text-chat, and potentially a recording to disk for later distribution [website][README]. This isn’t incidental — it’s what the software was designed for.

License and sovereignty. MIT license means no restrictions on use, modification, or deployment. If you’re running a university, a government agency, or any institution with data residency requirements, a Go binary you compile yourself and run on your own hardware is a cleaner legal position than trusting a third-party SaaS with lecture recordings [website].

What pushes people away is equally clear from reading the documentation: Galene doesn’t pretend to be Zoom for enterprise. There’s no meeting scheduling UI, no cloud management dashboard, no participant analytics. You manage groups by editing JSON files. The alternative web frontend (Pyrite, built on Vue) is “currently on hold and out of date” [website]. That leaves the default JavaScript client as the practical UI, and it’s functional rather than polished.

---

Features

Based on the project website and README:

Core conferencing:

• Arbitrary numbers of audio and video streams per group [website]
• Text chat [website]
• Recording to disk [website]
• User status (raise hand, and similar) [website]
• Codec choice: VP8 and VP9 with full functionality; H.264 with partial functionality; AV1 with preliminary support [website]
• Simulcast support [website]
• Scalable Video Coding (SVC) for VP8 and VP9 [website]
• NACK-based packet loss recovery [website]
• Group-based access control via JSON config files [README]
• Administrative REST API for managing groups and users [README]

Deployment and integration:

• Single Go binary, no runtime dependencies [README]
• Runs on Linux (amd64, arm64, armv7, mips/OpenWRT), macOS, Windows [website]
• YunoHost one-click installer for non-technical deployments [website]
• Arch Linux and FreeBSD community packages [website]
• LDAP integration via third-party authorization server [website]

Ecosystem add-ons (varying maturity):

• Galene-stream: RTMP frontend, compatible with OBS Studio — lets you stream from OBS directly into a Galene group [website]
• Android client: chat, audio, screensharing (screensharing not possible in Android browsers) [website]
• galene-stt: speech-to-text transcription and auto-captioning [website]
• SIP bridge: experimental VoIP integration for traditional phone systems [website]
• Command-line file transfer: for large files (web interface handles up to a few GB) [website]
• Galene Manager: WordPress plugin for managing groups from a WordPress admin panel [website]
• Openfire plugin: integrates Galene into the Openfire collaboration server [website]
• JavaScript and Go client SDKs: documented and stable protocol, usable for building custom clients [website]

What it explicitly does not have:

• End-to-end encryption — the server can in principle access media in transit [website]
• A polished management UI for non-technical operators
• A SaaS or hosted tier

---

Pricing: SaaS vs self-hosted math

Galene has no SaaS offering. There is no cloud-hosted version to pay for. The only cost is the infrastructure you run it on.

Self-hosted:

• Software: $0 (MIT license) [README]
• VPS: $5–12/mo on Hetzner, Contabo, or DigitalOcean for entry-level instances
• The project’s claim of “very moderate server resources” suggests a 1–2GB RAM VPS is viable for small groups [website]; larger lecture scenarios would need more

What you’re replacing:

Zoom’s per-host pricing starts at $15.99/mo per licensed host. A team of five with Zoom Pro runs $79.95/mo — nearly $960/year. Zoom Webinars (for lecture-scale events with many viewers and few presenters) start at $149/mo for up to 500 attendees. BigBlueButton’s hosted services from third-party providers run $30–$100/mo depending on concurrent rooms.

For an academic department or small organization running regular video meetings, the math is straightforward: a $6 Hetzner VPS plus an afternoon of setup replaces $960–$1,800/year in per-seat licensing. The caveat is that you’re also buying the maintenance obligation and the expertise to keep the server running.

One realistic scenario: a university department running weekly seminars and occasional larger public talks. Zoom licensing for ten faculty members runs roughly $1,900/year. Galene on a shared department server runs approximately $0 in licensing fees and whatever the sysadmin’s time is worth. Galene’s track record at Université de Paris and Sorbonne Université suggests this isn’t a hypothetical — it’s what some European academic institutions have already decided [website].

Pricing data for direct comparisons with other self-hosted options (Jitsi Meet managed hosting, BigBlueButton managed hosting) is not provided in available sources and not fabricated here.

---

Deployment reality check

The minimal install path is genuinely short:

git clone https://github.com/jech/galene
cd galene
CGO_ENABLED=0 go build -ldflags='-s -w'
mkdir groups
echo '{"users": {"vimes": {"password":"sybil", "permissions":"op"}}}' > groups/night-watch.json
./galene &

That gets you a running server [README]. For a real deployment with HTTPS and a public domain, you additionally need a reverse proxy (Caddy or nginx), a TLS certificate, and a STUN/TURN server if participants are behind symmetric NAT. The documentation covers this in galene-install.md.

The simplest non-technical path is YunoHost, which packages Galene with a one-click installer [website]. For anyone running YunoHost already, this is the obvious route.

What can go sideways:

The default web client is functional but plain. If your users expect a Zoom-like polished interface, they will be disappointed. The Pyrite alternative frontend that would have addressed this is “currently on hold and out of date” [website] — so what you ship to end users is whatever the default client is at the time you deploy.

Group management is JSON files. Adding a new conference group means SSH into the server, create a JSON file, no restart needed. That’s fine for a sysadmin, opaque for a department administrator who wants a UI.

TURN server setup is the most common failure point in WebRTC self-hosting generally, not Galene specifically. Participants behind corporate firewalls or symmetric NAT will fail to connect if you don’t configure a TURN relay. The documentation mentions this; the setup is separate from Galene itself.

The Android client handles chat, audio, and screensharing — but not video. For video from Android, the project recommends the mobile browser, “which works fine on mobile” [website]. Whether that holds in practice across browser versions varies; the FAQ mentions specific caveats [website].

Time estimate for a technical user: 60–90 minutes to a working HTTPS-enabled instance with a STUN server. For YunoHost users who already have the platform running: under 10 minutes. For a non-technical operator without a sysadmin: blocked until they find help.

---

Pros and cons

Pros

• Genuinely lightweight. Runs on OpenWRT (MIPS routers), ARM devices, and low-memory VPS instances [website]. If you’re resource-constrained, this matters.
• MIT licensed, single binary. No runtime dependencies, no licensing restrictions, audit the code yourself, compile it yourself [README].
• Proven academic track record. Université de Paris and Sorbonne Université have used it in production for lectures, practicals, and staff meetings [website]. Real-world load, real institutions.
• Conference experience. SOCS’2020, JFLA’2021, LibrePlanet 2024 [website]. Not just internal tool usage.
• OBS integration via Galene-stream. If you’re doing recorded or streamed events, the RTMP-to-Galene bridge is useful [website].
• SIP bridge (experimental) means existing phone infrastructure can participate [website].
• Speech-to-text and captioning add-on for accessibility [website].
• Documented, stable protocol with JavaScript and Go client SDKs — you can build custom clients [website].
• No per-seat licensing. One server, unlimited groups, unlimited participants within hardware limits.
• Active grant-funded development (NLNet NGI0Core), not dependent on VC or commercial revenue [website].

Cons

• No end-to-end encryption. The server decrypts and re-encrypts. If someone controls the server, they can access the streams [website]. For sensitive meetings this is a meaningful limitation.
• Small community. 1,274 GitHub stars is modest. Jitsi Meet has 20K+. Smaller community means fewer community-written tutorials, integrations, and bug reports surfaced quickly.
• Pyrite (the better UI) is on hold. The Vue-based alternative frontend that would have provided a nicer client experience is “currently on hold and out of date” [website]. The default JavaScript client is functional, not attractive.
• JSON config management. No admin web UI for group management. All configuration is files. Fine for sysadmins, a real barrier for less technical operators.
• No hosted/managed tier. If you want the benefits without the operational overhead, there’s no Galene Cloud to sign up for. You either self-host or don’t use it.
• TURN server is your problem. WebRTC behind NAT requires a TURN relay. Galene doesn’t ship one; you configure it yourself. This is the most common setup failure point.
• Android video via browser only. The Android native client doesn’t do video (screensharing yes, video no) [website].
• No scheduling or calendar integration. Creating a meeting means sharing a URL — that’s it.

---

Who should use this / who shouldn’t

Use Galene if:

• You’re running an academic institution, open-source conference, or research organization that holds regular public talks or lectures.
• You have a sysadmin or technical co-founder who can handle a Go binary deployment and maintain a server.
• You’re replacing Zoom licensing for a small-to-medium team and want zero per-seat costs.
• You need to run on constrained hardware (ARM, embedded Linux, low-memory VPS).
• You already run YunoHost — the packaged install path is simple.
• Data sovereignty or regulatory requirements mean media can’t transit a third-party server.

Skip it (use Jitsi Meet instead) if:

• You want a more polished default web UI with a larger community behind it.
• You need active development on the web client UI rather than just the server engine.
• Your team needs a scheduling UI and meeting links that look professional to external participants.

Skip it (use BigBlueButton instead) if:

• Your primary use case is formal e-learning with whiteboards, polls, breakout rooms, and LMS integration.
• You need proper non-technical administrator tooling rather than JSON files.

Skip it (use Zoom or Google Meet) if:

• You have fewer than five users and the free tiers cover you.
• You need reliable mobile video across all Android and iOS browsers without caveats.
• No one on your team can or will manage a Linux server.

Skip it (look at Matrix/Element or Janus) if:

• You need federated video across organizations.
• You need deep programmability and plugin architecture over a lighter operational profile.

---

Alternatives worth considering

• Jitsi Meet — the most obvious comparison. Also WebRTC, also self-hosted, also open source (Apache 2.0). More stars, more community, more UI polish, heavier resource requirements. Jitsi’s managed cloud (meet.jit.si) gives you a hosted fallback. Choose Jitsi if you want a larger support community. Choose Galene if you want lighter infrastructure and the academic-lecture model.
• BigBlueButton — education-focused, heavier feature set (whiteboard, polls, LMS plugins), heavier infrastructure requirements. Better fit for formal e-learning than for video meetings.
• Janus — mentioned on the Galene website itself as a high-quality alternative [website]. Janus is a general-purpose WebRTC gateway, more programmable, more complex to deploy. Better fit for developers building custom WebRTC applications.
• Zoom / Google Meet / Teams — the commercial baseline. Easiest onboarding, highest per-seat cost at scale, no data sovereignty.
• Matrix/Element with video rooms — if you want federated text messaging plus video in one protocol. More complex; video call quality varies.

---

Bottom line

Galene is a well-built, minimal, MIT-licensed WebRTC server from an academic researcher who needed something he could actually run on university infrastructure without paying per-seat licensing fees. It does what it advertises: low resource usage, conference-style group management, a stable protocol, and a track record at real universities. It doesn’t do what it doesn’t advertise: there’s no polished management UI, no hosted tier, no end-to-end encryption, and the better web frontend (Pyrite) is on hold.

If you’re a technical founder or sysadmin looking to replace Zoom for small team meetings or recurring public talks, and you’re comfortable with a Go binary and JSON config files, Galene is worth an afternoon of testing. If you’re a non-technical operator who wants a managed service or a UI to hand to a department administrator, look at Jitsi Meet or BigBlueButton instead.

The mismatch to avoid is deploying Galene expecting Jitsi-level community support or Zoom-level UI polish. Deploy it knowing it’s a lean academic tool maintained by a small team, and it will likely serve you reliably for years — as it has at Université de Paris and Sorbonne Université.

If the deployment is the blocker, that’s the kind of one-time setup that upready.dev handles for clients. Single fee, you own the infrastructure.

---

Sources

1. Galene Official Website — features, installation, production use, ecosystem. https://galene.org
2. Galene GitHub README — quick start, documentation links, contributing guide. https://github.com/jech/galene

Note: No substantive third-party reviews of Galene as a videoconference server were available in the sources searched at the time of writing. The article draws exclusively from first-party documentation and the project’s published track record.