Forem: Egor Sledov

Galene - a Simple Videoconferencing Server. Installation on VPS

Egor Sledov — Wed, 27 Aug 2025 00:30:11 +0000

Today I'll show you how to set up a simple videoconferencing server. You can use it to call relatives or friends.

The server is called Galene (github). It was originally developed during the pandemic at the University of Paris as a tool for online teaching. Over time, its functionality expanded, and now it's closer to Jitsi Meet in terms of features.

Jitsi Meet is the most widely used open-source videoconferencing server. However, it is made up of many components, it is harder to install and needs much more powerful hardware to run. Galene, on the other hand, is written in Go in a minimalist style, and is essentially a single binary file that you can just run on a budget VPS (yes, you'll also need certificates and a couple of configuration files). According to the developers, it can even be run on a Raspberry Pi. I haven't tested that myself, though.

I'll assume you want to make a video call right now, so we'll focus on how to get it working as quickly as possible. Later, we might need to adjust a few things.

Here's the link to the official installation instructions, but they take a different approach to life. So stick with me on this one.

Compiling Galene

As you may have guessed, there is no ready-made binary – we'll build it ourselves now.

I'll do this on a VPS (3 cores, 4GB RAM) with a fresh installation of Ubuntu 24.04.

sudo apt install git golang

This command installs Git and the Go toolchain – compiler, standard library, and utilities.

I'll keep the program and configuration in ~/apps/galene, and the source code in ~/src. So:

mkdir ~/src
cd ~/src
git clone https://github.com/jech/galene.git
cd galene
CGO_ENABLED=0 go build -ldflags='-s -w'

The Go compiler will download additional modules and build a single self-contained executable file in the galene directory without external dependencies.

If everything goes well, you'll get a binary file about 10 MB in size.

ls -lh galene
-rwxrwxr-x 1 sledov sledov 10M Aug 22 02:03 galene

Installation and First Run

Let's move it to another directory and try running it there.

mkdir -p ~/apps/galene
cp galene ~/apps/galene/
cd ~/apps/galene/
./galene
2025/08/22 02:35:16 Group file ./groups/: lstat ./groups/: no such file or directory
2025/08/22 02:35:16 Starting built-in TURN server on :1194
2025/08/22 02:35:16 Relay test successful in 9.964835ms, RTT = 69.67µs
^C2025/08/22 02:35:19 Stopping built-in TURN server

I stopped it with Ctrl-C.

It runs, but clearly expects a "groups" directory. Galene relies on a specific directory structure. What it calls "groups" are really conference rooms, each set up with a small JSON configuration file.

(We're now in ~/apps/galene)

mkdir groups
mkdir data

The source code also includes a "static" directory containing the web interface written in vanilla JavaScript. We'll copy it as-is.

cp -a ~/src/galene/static .

Creating the First Group

The first group we'll create will be called "family", and I'll be the admin there.

nano groups/family.json

{
    "users":
    {
        "sledov":
        {
            "password": "secret",
            "permissions": "op"
        }
    }
}

This is just the initial setup. Galene supports password hashing (e.g., with bcrypt), but for now this will do.

Certificates from Let's Encrypt

Now we need SSL certificates. Galene expects to find them in the "data" directory. We'll obtain them from Let's Encrypt and move them there.

The Ubuntu repositories include certbot, a tool that automatically gets and renews free TLS certificates from Let’s Encrypt. Let's install it:

sudo apt install -y certbot

Check the fully qualified domain name (FQDN) of our server:

hostname -f
galene.sledov.ru

In this case, the FQDN is galene.sledov.ru. Nothing is running at this address - it's just an example. but Galene has a demo server you can try. For your installation, of course, it will be your own server's domain name.

Now create the certificates:

sudo certbot certonly --standalone -d galene.sledov.ru

A short interactive process follows: enter your email, then accept or decline the terms offered.

Here's the key part of the output:

Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/galene.sledov.ru/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/galene.sledov.ru/privkey.pem
This certificate expires on 2025-11-20.

We now have a certificate and key valid for about three months.

Next, copy these files into the "data" directory and change their ownership:

cd data
sudo cp /etc/letsencrypt/live/galene.sledov.ru/fullchain.pem cert.pem
sudo cp /etc/letsencrypt/live/galene.sledov.ru/privkey.pem key.pem
sudo chown sledov:sledov *.pem

Running Galene

cd ~/apps/galene
./galene
2025/08/22 04:00:54 Starting built-in TURN server on :1194
2025/08/22 04:00:54 Relay test successful in 12.505795ms, RTT = 176.18µs

By default, Galene runs on port 8443. I won't show you the landing page where it asks to enter a group name, we'll go straight to the "family" group we created.

xttps://galene.sledov.ru:8443/group/family/

Here you'll need to enter your username and password, then allow the browser access to the camera and microphone. After that, you’ll see your camera feed in the conference window.

How to Invite People?

On the left side, you'll find a panel with the roster and your name. To the right of your name there's a camera icon. Clicking it opens a menu where you need to select "Invite User".

Then enter the name of the person you want to invite. Galene will generate a link that you can send, for example, via email.

The link looks like this:

_https://galene.sledov.ru:8443/group/family/?token=LBwxP4qboLA

When the recipient opens the link in a browser, he or she will not need to enter a username or password (but will still be required to allow camera and microphone access). The person will immediately join your room.

Conference Characteristics

Galene does not actively dial out to participants. They need to join the room/group themselves. You need to get used to this. You can use the text chat and drop a link to the video call there. You can also bookmark the URL or create a desktop shortcut and open it at the agreed time. You can also make an actual phone call and say "Join the group," or ring once and hang up - as long as you've agreed on that beforehand.

JavaScript Client

If you don't like the standard interface or, for example, its layout, you can change it. The interface is written in vanilla JavaScript, and the code is relatively simple and readable, so you can tweak it to your liking.

What's Next?

Hopefully by now you've explored the basic functionality and know how to make calls. I've zipped the "~/apps/galene" directory (without certificates, of course), and you can find it here. You'll need to create your own certificates and run the "galene" binary. I highly recommend compiling Galene yourself. I haven't tested whether the application runs this way on distributions other than Ubuntu 24.04.

If you have a firewall (I didn't in my case), you'll need to open ports TCP 8443, TCP 1194, UDP 1194, and a range of UDP ports, for example, 40000–40500. After that, you'll need to specify this range when starting the program as a command-line parameter, for example:

./galene -udp-range 40000-40500

If you want Galene to run permanently, it's best to create a "systemd" service unit. The installation guide explains how to do this. It's also a good idea to configure it to run on port 443 instead of 8443 (hint: you don't need to proxy it through nginx for that).

We've only covered the basics. The official documentation provides detailed explanations – please explore it and experiment on your own.

Happy videoconferencing! Feel free to ask questions.

Lua scripting in mpv video player

Egor Sledov — Tue, 04 Feb 2025 02:50:57 +0000

Recently, I needed to cut a video fragment without re-encoding. I wasn't happy with how LosslessCut handled it, so I started looking for alternatives.

On Reddit, I came across a post claiming that this could be done using the mpv-cut script. And this approach doesn't require an external GUI or additional programs.

I checked it and the mpv-cut script turned out to be a Lua script that lets you cut a video fragment directly while watching it in the mpv player.

I hadn’t expected that the minimalist mpv player would support scripts that expand its functionality. I decided to check it out and see how it works.

Using mpv-cut

Let's start with the script itself: how to install and use it.

mpv has a configuration folder. On Linux, it's located at ~/.config/mpv, and on Windows at %AppData%\Roaming\mpv. You need to create a scripts directory in this folder (if it doesn't already exist) and clone the Git repository there:

git clone -b release --single-branch "https://github.com/familyfriendlymikey/mpv-cut.git" ~/.config/mpv/scripts/mpv-cut

You also need to have ffmpeg installed and added to your system's PATH variable.

Once this is set up, opening a file in mpv will automatically activate the script. When you reach the fragment you want to extract, press "c" on your keyboard to start copying. Press "c" again to stop copying. The video fragment will be saved in the same directory as the source file with a name like COPY_1_video_FROM_00-00-07-457_TO_00-00-21-332.mkv.

You can play the saved fragment to verify that all streams (audio, video, and subtitles) are intact—nothing was re-encoded; only a section was cut out.

At this point, take a look at the main.lua file in the mpv-cut folder, but it may be too complex for a first script. So let’s start by writing a simple "Hello, World" script for mpv.

Hello, World for the mpv Player

Open your favorite text editor and create a file named hello.lua in the scripts folder. Enter the following code:

function hello_world()
    print("Hello, World!")
end

mp.add_key_binding("h", "hello_world", hello_world)

You don’t need to install Lua separately for mpv. The player has a built-in Lua interpreter.

Since mpv has no graphical menu, you define functions and bind them to key presses. In this case, pressing the "h" key will print "Hello, World!" to the terminal.

Here’s a sample video from the freely distributed Sintel animation by Blender. I’ll later demonstrate how to display a list of subtitles using this video.

You can test the script by playing any video and pressing "h" to check if "Hello, World!" appears in the terminal.

Subtitle List

Now, let's create an example that retrieves information from the currently playing video. Instead of "Hello, World!", we’ll print a list of subtitles to the terminal.

function show_subtitles()
    print("Subtitle List:")
    print("ID Language Format")

    local track_list = mp.get_property_native("track-list")

    for _, track in ipairs(track_list) do
        if track.type == "sub" then
            print(track.id, track.lang, track.codec)
        end
    end
end

mp.add_key_binding("h", "show_subtitles", show_subtitles)

The mp.get_property_native("track-list") function in mpv returns a list of all tracks in the current video file. This includes video, audio, and subtitle tracks, along with their metadata such as ID, language, codec type, and other properties.

This time, we bind the show_subtitles function to the "h" key.

The output looks something like this:

[hello] Subtitle List:
[hello] ID Language Format
[hello] 1 ger subrip
[hello] 2 eng subrip
[hello] 3 spa subrip
[hello] 4 fre subrip

In mpv, the 'j' key (located right next to 'h') cycles through available subtitle tracks and displays information about the current track on screen. Press "h" and "j" several times to compare the output of our script with the built-in subtitle track switching function to make sure that our script works correctly.

Where to Find More Information?

I wanted simply to demonstrate that mpv supports Lua scripting and provide a couple of examples. Here are some resources to learn more about this.

You can read about Lua scripting in mpv in the official documentation.

Examples of Lua scripts included with the mpv package can be found on Linux at: /usr/share/doc/mpv/examples/lua/

These scripts are also available in the mpv Git repository.

A large collection of user-contributed scripts can be found here:
https://github.com/mpv-player/mpv/wiki/User-Scripts

On mpv's Customizability

The flexibility and configurability of mpv are impressive, offering many possibilities for users.

For example, when learning languages, it's convenient to display subtitles in two languages simultaneously (mpv supports this even without scripts). With scripts, you can do much more: create Anki cards from video content, perform simple editing and cropping, automatically switch tracks, and so on.

Take another look at the user script collection - you might find a solution for your needs or inspiration for creating your own script.