Open-source project
sabre-io/Baikal avatar
sabre-io/Baikal

Baikal: the release archive ships a vendor directory and no manifest

Baïkal is a Calendar+Contacts server

3,374 stars322 forksPHPGPL-3.0

At a glance

What is it?
Baikal is a CalDAV and CardDAV server whose repository is 160 words long and points at its website for everything that matters. The interesting material is in the Makefile, where the version is a PHP constant read by make, the archive is assembled with a fixed PHP platform, and the database schema is copied out of a dependency rather than maintained here.
Who is it for?
Baikal fits a household or small team that wants its own calendar and contacts server with no hosted account in the middle, and the distribution model is the strongest part of it. A single zip containing a resolved vendor directory installs on a Raspberry Pi without a package manager on the target machine, and the upgrade path is a documented page rather than a forum thread.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 12 days ago.
What is it written in?
Mainly PHP, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • sabre-io/Baikal3,374 ★ · +54
Star history
Repository2026-09-242026-11-15
sabre-io/Baikal3.3k3.4k

54 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The repository is the server, and the documentation is four links away

The readme is short by design. It says this is the source repository for the Baikal CalDAV and CardDAV server, and then sends you somewhere else for the parts that matter: the project page for information about installation, upgrading and troubleshooting, and a separate page for the upgrade instructions themselves.

What is left in the repository is identity and credit. The server is described as a calendar and contacts server, it was created by Jérôme Schneider from Net Gusto and fruux, and it is now developed by volunteers. There is also a specific acknowledgement for the project page quality, credited to a contributor by handle.

That structure has a consequence for anyone evaluating it. There is no changelog in the readme, no configuration reference, no list of requirements and no statement of which PHP versions are supported. All of that lives on the website, and the readme's only real content is a set of pointers plus the provenance of the code.

For a project at version 0.12, that is a thin front page, and it is why the rest of this description is largely about the build.

Two community guides exist because the official pages assume experience

The readme links two third-party guides, and the reason it gives for both of them is the same: each is written for people without much IT experience.

The German guide covers installation, using the server together with Thunderbird, Android and DAVx5, sharing calendars between them, database maintenance and security. It is described as very detailed and step by step, with a Raspberry Pi used as the server.

The French guide states the same objective and covers installation on Debian, database maintenance, security and dealing with iOS clients.

Two things follow. First, the client matrix is not hypothetical: three named clients on one platform and iOS on another, which is the practical test of a CalDAV and CardDAV server. Second, and more interesting for an adopter, the project itself links these guides, which is an implicit statement that the official installation and troubleshooting pages do not serve a beginner audience. The security and database maintenance sections in both guides are also the parts the official pages are most likely to leave to an administrator.

If you are deploying this for someone else, those two guides are the more realistic starting point than the project site.

The version number is a PHP constant that make executes

The Makefile asks PHP what the version is, by including a source file and printing a constant:

make
VERSION=$(shell php -r "include 'Core/Distrib.php'; echo BAIKAL_VERSION;")

That single line explains several things about the release process. The version lives in a PHP file inside the Core directory rather than in a manifest field, so a release bump is a code edit. The artifact name follows it, since the archive is written as baikal-$(VERSION).zip.

It also means the build tooling depends on a working PHP command line before it does anything else. Any target that interpolates the variable runs the interpreter, so make on a machine without PHP configured fails at variable expansion rather than at the step that actually needs it.

This is an older pattern than a version field in a package manifest, and it has one practical advantage: there is exactly one place the version can be wrong, and it is a constant the application itself reads.

The archive ships resolved dependencies and deletes the manifest

The dist target is where the project's distribution decisions are visible. After copying the Core directory, the html directory, the licence, the readme and composer.json into a build directory, it does this:

make
	composer config platform.php 8.2 -d $(BUILD_DIR)
	composer install --no-interaction --no-dev -d $(BUILD_DIR)
	rm $(BUILD_DIR)/composer.*

Three things in three lines. The PHP platform version is pinned to 8.2 for the resolution, so a machine with a newer interpreter still resolves dependencies as if it were 8.2. Dev dependencies are excluded, so the archive carries runtime code only. And then both composer files are deleted from the build, which means the released archive contains a fully populated vendor directory and no record of what produced it.

The target continues by replacing every symbolic link with a real copy, so the archive has no links to break when it is unpacked, and by removing two vendored asset packages, a Bootstrap distribution and a Font Awesome package, that the project does not ship. Empty directories are preserved by touching placeholder files, so the per-user database directory and the config directory survive the zip.

The result is a self-contained release you can copy to a Raspberry Pi and serve, at the cost of never being able to update a dependency on that machine.

The database schema is copied out of a dependency at build time

The schema is not maintained in this repository. A separate target, build-assets, produces it by concatenating SQL files that ship inside a dependency:

make
build-assets: vendor/autoload.php
	cat vendor/sabre/dav/examples/sql/mysql.*.sql > Core/Resources/Db/MySQL/db.sql
	cat vendor/sabre/dav/examples/sql/sqlite.*.sql > Core/Resources/Db/SQLite/db.sql

So the statements that create a fresh database come from the example SQL files of the server library the project builds on, one set for MySQL and one for SQLite, and they are written into the Core resources at build time. The wildcard in each path means several files are joined into one.

That is a defensible way to avoid a schema that drifts away from the library, and it has two consequences. A fresh installation's schema is whatever that dependency's examples currently contain, so it changes when the dependency changes rather than when this project decides to. And the generated files are build output: nothing in the repository tells you what the schema will look like until you have installed the dependencies.

For anyone planning a long-lived deployment, the practical question is what happens to an existing database when the schema underneath it moves, and this build says nothing about that.

The lock file is generated, so a clone resolves dependencies fresh

Two rules in the Makefile explain how dependencies arrive:

vendor/autoload.php depends on composer.lock, and composer.lock depends on composer.json, where the second rule runs a composer update to produce the first. A lock file is therefore treated as a generated artefact of this build, not as an input committed to the repository, and the top level of the tree carries a composer.json and no lock file.

The result is that two clones of the same commit can install different dependency versions, resolved on the day each was built. For a library that would be unusual. For a server that ships a zip, it is a deliberate choice with a clear trade: reproducible installs for the person who builds the release, and no reproducibility at all for the person who clones the repository.

The two policies meet in the dist target, which pins the PHP platform to 8.2 for the official archive while leaving a local clone to resolve against whatever the developer's own environment suggests.

If you are building your own archive rather than downloading one, that is the line to read twice.

A PHP server whose test entry point is a Python script

The repository root carries three development tools with three different origins. A PHP static analyser configuration and a code style fixer configuration are both PHP-native and both declarative. The test entry point, run_tests.py, is a Python script.

A Python runner in a PHP project is usually a sign that the harness lives outside the language, which is fine for orchestration and awkward for anything that needs the runtime. What it cannot tell you is how the tests are invoked in continuous integration, since the workflow configuration sits in a directory this repository keeps out of the readme.

The clean target is more revealing about how development happens here. It removes the configuration file and the SQLite database from inside the checkout, with a trailing true so the target succeeds whether or not those files exist. So a developer's working copy carries a live config file and a live database, and resetting means deleting both rather than switching branches.

The four top-level directories follow the same logic. Core and html are what gets shipped, Specific holds the per-user database files, and config holds the settings. The clean target touches the last two.

Eight months between 0.11.1 and 0.12.0, then a patch two days later

Three releases are visible. Version 0.11.1 is dated 2025-11-30. Version 0.12.0 is dated 2026-08-03, about eight months later. Version 0.12.1 is dated 2026-08-05, two days after that. The last recorded push to master is dated 2026-08-13, eight days after the patch.

So the pattern is a long gap, a feature release, and an immediate fix, which is what a volunteer-maintained project with a handful of regular contributors tends to look like. The project is not archived, and the branch tip is eight days past the newest tag in this view, so there is a small amount of unreleased work above 0.12.1.

The licence is GPL at version 3, with the licence file at the root, and there is a security policy file beside the readme. The homepage recorded for the project is the documentation site rather than the repository, which is consistent with a project whose public face is its documentation.

For anyone planning an upgrade, the number that matters is the gap: eight months is how long a fix for a problem you have takes to reach a numbered release.

Editorial conclusion

Baikal fits a household or small team that wants its own calendar and contacts server with no hosted account in the middle, and the distribution model is the strongest part of it. A single zip containing a resolved vendor directory installs on a Raspberry Pi without a package manager on the target machine, and the upgrade path is a documented page rather than a forum thread. Three things to know before you deploy it. The archive contains no composer manifest, so you cannot update a dependency on the server afterwards. The lock file is not committed, so what lands in a release depends on the day it was built. And the initial database schema is generated from files inside a dependency, which means the schema your server creates is that dependency's idea of a starting point, not a migration path. None of that is a reason to avoid it; all of it belongs in your notes.

Frequently asked questions

how to install baikal

The repository itself contains no installation steps. The README sends you to sabre.io/baikal for installation, upgrading and troubleshooting, and to a separate upgrade page, and it also links a German guide using a Raspberry Pi with Thunderbird, Android and DAVx5 and a French guide covering Debian and iOS clients.

What is Baikal?

A CalDAV and CardDAV server for calendars and contacts, and this repository is its source. It was created by Jérôme Schneider from Net Gusto and fruux and is now developed by volunteers under the GPL version 3.

How is the Baikal release archive built?

The dist target copies the Core and html directories with the licence, readme and composer.json into a build directory, pins the PHP platform to 8.2, installs dependencies without dev packages, deletes the composer files, replaces symlinks with real copies, drops two vendored asset packages, and zips the result as baikal-<version>.zip using the version constant from Core/Distrib.php.

Where does the Baikal database schema come from?

From the build-assets target, which concatenates the MySQL and SQLite example SQL files shipped inside the sabre/dav dependency into Core/Resources/Db/MySQL/db.sql and Core/Resources/Db/SQLite/db.sql. The schema is build output rather than something maintained in the repository.

Does the Baikal release archive include a composer.json?

No. The build installs dependencies without dev packages and then deletes the composer files from the build directory, so the archive ships a populated vendor directory with no manifest. The lock file is also generated rather than committed, so it is absent from a fresh clone.

Official sources

  1. License: GPL-3.0
  2. Project website
  3. README
  4. Releases
  5. sabre-io/Baikal on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sabre-io-baikal.svg)](https://hysenlabs.com/projects/sabre-io-baikal)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sabre-io-baikal.svg)](https://hysenlabs.com/projects/sabre-io-baikal)

Was this useful?