Galene

Galène is a videoconferencing server that is easy to deploy (just copy a few files and run the binary) and that requires moderate server resources. It was originally designed for lectures and conferences (where a single speaker streams audio and video to hundreds or thousands of users), but later evolved to be useful for student practicals (where users are divided into many small groups), and meetings (where a few dozen users interact with each other).

Galène reached version 1.0 in August 2025 (with 1.1 in development), marking its maturity as a production-ready platform.

Docker

https://github.com/deburau/galene-docker

Alt UI

https://github.com/kaisansoft/pyrite (OLD, unmaintained)

Galene vs. Livekit

Last updated: March 2026

Key Differences and Comparison

Feature	Galene	LiveKit
Primary Focus	Self-hosted video conferencing with low operational overhead	Scalable, production-grade, real-time communication platform
Architecture	Single-server SFU (with integrated TURN server)	Distributed, multi-node architecture
Scalability	Good (single server, UDP multiplexing since 1.0)	Highly scalable (designed for many rooms/participants)
Complexity	Lower (simpler codebase)	Higher (more features, more complex)
Features	- Video conferencing (audio, video, screen sharing) - Text chat with moderation - Group management - Recording to disk (WebM) - Token-based authentication (JWT, stateful, RSA/RS256) - Hierarchical and global tokens - Advanced bandwidth estimation (BWE) - Simulcast and SVC (Scalable Video Coding) - Integrated TURN server - WHIP ingress protocol - Background blur - Peer-to-peer file transfer - Administrative HTTP API - CORS support - galenectl CLI admin tool	All of Galene’s core features, plus: - Scalable Forwarding Unit (SFU) model - Dynamic forwarding and quality adjustments - Load balancing and routing - Egress (recording, streaming) services - Ingress (pre-encoding) services - Webhook events - Extensive SDK support (many languages/platforms) - Client-side adaptive streaming - Advanced server-side configuration options - Prometheus metrics - Advanced logging
Dependencies	Minimal (Pion WebRTC v4)	More dependencies (Redis, routing services, etc.)
Deployment	Easy, single-server setup; galenectl initial-setup for bootstrapping	More complex, requires infrastructure setup (e.g., Redis)
Target User	Self-hosting enthusiasts, small-to-medium organisations, developers needing a lightweight SFU with an admin API	Developers building production applications, businesses needing distributed scalability
Licensing	MIT License	Apache License 2.0

Code-Level Observations

1. Signal Handling (Galene’s main.go, rtpconn/rtpconn.go vs. LiveKit’s service/signal.go):

   • Galene: Uses a custom WebSocket-based signaling protocol. Signal messages are plain JSON. The code directly handles offer/answer and ICE candidate exchange.
   • LiveKit: Uses a dedicated SignalServer and SignalClient with Protocol Buffers (protobuf) for structured messaging. Leverages PSRPC for internal communication. This makes message definitions explicit, versioned, and easier to manage in a distributed system.

2. RTP Handling (Galene’s rtpconn/rtpconn.go vs. LiveKit’s sfu package):

   • Galene: Manages RTP packets with robust jitter buffer management and sophisticated packet reordering/loss handling, comparable to LiveKit. Since 1.0, uses Pion v4 and supports UDP multiplexing for better port utilisation.
   • LiveKit: Has a robust sfu package with:
     • DownTrack: Manages sending RTP to a subscriber, including quality adjustments, bandwidth estimation, and keyframe requests.
     • Buffer: Sophisticated buffering, reordering, and NACK handling for incoming RTP packets.
     • RTPMunger: Handles sequence number and timestamp adjustments needed for forwarding, codec parameters, and other RTP-related operations.
     • StreamTracker: Manages the availability of streams (for simulcast/SVC).

3. Bandwidth Estimation (BWE) (Galene’s rtpconn vs. LiveKit’s sfu/bwe):

   • Galene: Implements advanced BWE, with an estimator that is arguably more refined than LiveKit’s.
   • LiveKit: Uses a combination of sender-side and receiver-side BWE, including:
     • REMB (Receiver Estimated Maximum Bitrate) processing.
     • Transport-Wide Congestion Control (TWCC) feedback handling.
     • Custom congestion control logic based on packet loss, jitter, and RTT.
     • Support for probing to find available bandwidth.

4. Media Processing (Galene’s codecs package vs. LiveKit’s sfu, buffer, and codec-specific packages):

   • Galene: Extensive codec support (VP8, VP9, H.264, AV1, Opus, etc.), including dedicated code for handling codec-specific features like VP8/VP9/AV1 keyframe detection and H.264 NALU handling. Also supports client-side filters including background blur (using MediaPipe).
   • LiveKit: Also provides extensive codec support and dedicated code for handling codec-specific features.

5. Data Channels and File Transfer:

   • Galene: Supports peer-to-peer file transfer via WebRTC data channels (/sendfile command, since v0.5). The protocol was reworked in v0.6 and v0.95, and since 1.1 uses binaryType=blob to support files larger than available memory.
   • LiveKit: Uses a dedicated datachannel package, with rate limiting and buffer management, showing focus on reliability and scalability for data channels beyond basic conferencing.

6. Scalability (Galene’s single server vs. LiveKit’s routing/multi-node):

   • Galene: All logic is designed for a single instance, but offers good performance within its scope. UDP multiplexing (since 1.0) improves resource usage on a single node.
   • LiveKit: The routing package, LocalRouter, and RedisRouter clearly show a design for distributing load across multiple nodes. The room allocation and node selection strategies are crucial for scaling.

7. Telemetry and Monitoring (LiveKit’s telemetry and prometheus packages):

   • Galene: Limited built-in telemetry. Exports stats as JSON at /stats.html.
   • LiveKit: Comprehensive metrics collection and reporting with Prometheus, analytics events, and structured logging.

8. Configuration and Administration:

   • Galene: JSON-based configuration with config.json for global settings and per-group JSON files. Since 0.9, provides a full administrative HTTP REST API (/galene-api/) for programmatic management. The galenectl CLI (since 0.95, significantly expanded in 1.0/1.1) supports initial setup, user/token management, JSON templates, and group configuration. CORS is configurable via allowOrigin/allowAdminOrigin.
   • LiveKit: Uses a more complex configuration system (YAML-based) for tuning various aspects of the system, reflecting the larger number of features and distributed settings.

9. Authentication and Extensibility:

   • Galene: Supports multiple authentication methods: password-based (bcrypt or plaintext), stateless JWT tokens (with ECDSA and RSA/RS256), stateful tokens (“invitations”), and third-party token-based authentication. Since 1.0/1.1, supports hierarchical tokens (scoped to group hierarchies), global tokens, and include-subgroups capabilities for JWTs. The admin API allows programmatic user and permission management.
   • LiveKit: Provides a flexible, SDK-driven model for permissions and token generation, with broader integration options across languages/platforms.

10. Ingress (WHIP):

    • Galene: Implements the WHIP protocol (since 0.8) for ingesting media from external sources. Since 1.0, supports ETags and ICE restarts for WHIP.
    • LiveKit: Provides dedicated ingress services with broader protocol support and pre-encoding capabilities.

In Summary

The fundamental difference remains one of scope and design goals:

• Galene (now at v1.0) prioritises simplicity and ease of deployment for self-hosted video conferencing, while offering sophisticated media handling, advanced BWE, and — since recent versions — a full admin API, CLI tooling, flexible token-based authentication, and WHIP ingress. It is well-suited for individuals, small-to-medium organisations, and developers who need a capable SFU without the operational complexity of a distributed system.

• LiveKit is a more comprehensive platform aimed at building scalable, production-ready, real-time communication applications. It includes all the necessary components for managing large numbers of rooms and participants, optimising media quality, and handling network conditions in a distributed environment, along with extensive multi-language SDK support.

The feature gap between the two has narrowed significantly. LiveKit’s main advantages are distributed scalability, multi-language SDKs, and richer egress/ingress services. Galene’s main advantages are minimal dependencies, trivial deployment, and a self-contained architecture that is easy to operate and reason about. The choice depends on whether you need distributed scalability and broad SDK integration (LiveKit) or a lightweight, self-hostable solution that covers most conferencing needs out of the box (Galene).

Page last modified: 2026-04-01 19:31:08