Skip to content

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).

Docker

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

Alt UI

https://github.com/garage44/pyrite

Galene vs. Livekit

Key Differences and Comparison

Feature Galene LiveKit
Primary Focus Simple, self-hosted video conferencing Scalable, production-grade, real-time communication platform
Architecture Single-server (with optional TURN) Distributed, multi-node architecture
Scalability Good (single server) Highly scalable (designed for many rooms/participants)
Complexity Lower (simpler codebase) Higher (more features, more complex)
Features - Basic video conferencing (audio, video, screen sharing)
- Basic text chat
- Group management
- Recording
- Token-based authentication
- Advanced bandwidth estimation (BWE)
- Simulcast and SVC (Scalable Video Coding)
- Integrated TURN server		 All of Galene’s core features, plus:
- Advanced bandwidth estimation (BWE)
- 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) More dependencies (Redis, routing services, etc.)
Deployment Easy, single-server setup More complex, requires infrastructure setup (e.g., Redis)
Target User Individuals, small teams, self-hosting enthusiasts Developers building production applications, businesses
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.
    • 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.
    • LiveKit: Also provides extensive codec support and dedicated code for handling codec-specific features.

  5. Data Channels (Galene’s approach vs. LiveKit’s sfu/datachannel):

    • Galene: As a strictly videoconferencing server, Galène does not handle file transfers through data channels.
    • 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.
    • 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.
    • LiveKit: Comprehensive metrics collection and reporting with Prometheus, analytics events, and structured logging.

  8. Configuration:

    • Galene: Simpler configuration model.
    • LiveKit: Uses a more complex configuration system (likely YAML-based) for tuning various aspects of the system, reflecting the larger number of features and settings.

  9. Extensibility

    • Galene: There is no interface for user, and all permissions are hardcoded.
    • LiveKit: Provides a flexible model for permissions.

In Summary

The provided code highlights the fundamental difference in scope and design goals:

  • Galene prioritizes simplicity and ease of deployment for small to medium-scale video conferencing, offering sophisticated media handling and BWE within its self-hosted model. It’s likely more approachable for individual developers or small projects.

  • LiveKit is a much 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, optimizing media quality, and handling network conditions, particularly in a distributed environment.

LiveKit’s codebase is clearly more complex due to its broader feature set and distributed nature. The choice between them depends entirely on the project’s requirements. If you need extensive distributed scalability, a wide array of integration features, and a platform for large-scale production applications, LiveKit is a strong contender. If you need a powerful, self-hostable solution with advanced media capabilities and a focus on simplicity for more contained scenarios, Galène is an excellent option.

Page last modified: 2025-03-22 03:46:57