# Best open-source desk booking software in 2026

> Seatsurfing, LibreBooking, MRBS and Roomer for free self-hosted hot desking, plus where free hosted tiers stop (10–25 users). Updated October 2026.

URL: https://opencals.com/blog/open-source-desk-booking-software
Author: Stanislav Tyshchenko
Published: 2026-08-25
Updated: 2026-10-26
Categories: comparison

Hot desking created a software category almost by accident. Once a company stops assigning one desk per person, somebody has to answer a question that used to answer itself: is there anywhere to sit on Tuesday?

Most of the tools that answer it are SaaS, priced per user per month, and they want your occupancy data — which is exactly the data a works council or a privacy officer will ask about. So a lot of teams start where you probably are: looking for something open source they can run themselves.

The good news is that this niche has real, maintained open-source projects. The less good news is that "desk booking" covers four quite different jobs, and most of the projects only do one or two of them well. This is an honest look at what's actually available in August 2026, what each one costs you in maintenance, and — because it would be dishonest not to say it — where Opencals does and doesn't fit.

> **Key takeaway**
>
> If you want a finished desk booking product you can self-host, Seatsurfing is the strongest option and it is GPL-3.0. If you want a general resource scheduler where desks are just one resource type, LibreBooking or MRBS will do it with less polish and more configuration. If you're building desk booking into your own internal tool, none of these are the right answer — you want a booking API, and that's the one case where Opencals is relevant. Opencals is not open source; only our Next.js templates and npm SDK are.

## First, decide which of the four jobs you actually have

Teams conflate these constantly, then get annoyed that the software doesn't fit.

1. **Desk booking (hot desking / hoteling)**: Employees reserve a specific seat for a day or half-day. Needs floor plans, a per-desk inventory, and usually a mobile-friendly interface people will actually open on the way to the office.
2. **Meeting room booking**: Time-slot reservations against a shared calendar, usually with Google Workspace or Microsoft 365 sync and often a tablet outside the door. Time granularity matters much more than floor plans.
3. **General resource scheduling**: Desks, rooms, vehicles, lab equipment, AV kit — anything countable and reservable. Approval workflows and reporting matter more than any particular UI.
4. **Booking as a feature of something you're building**: You already have an intranet, an internal portal or a customer-facing app, and reservations need to live inside it. Here the interface is yours; you need availability logic and a data model.

If you're in job 1 or 2, keep reading the tool list. If you're in job 4, skip to [the section on building it yourself](#when-self-hosting-is-the-wrong-answer) — installing someone's finished product and then fighting its UI is the most common way this project goes badly.

## Seatsurfing — the closest thing to a finished open-source desk booking product

[Seatsurfing](https://github.com/seatsurfing/seatsurfing) is purpose-built for desk sharing, free seating and room reservation in organisations. It's the one project on this list that a non-technical employee could be handed without an explanation.

The backend is Go, the two frontends (an admin UI and a self-service booking PWA) are TypeScript and React, and it ships as a Docker image with a Postgres database. The published `docker-compose.yaml` is about twenty lines, and there are Kubernetes docs if you'd rather run it that way.

**Licence:** GPL-3.0. **Activity as of August 2026:** \~300 GitHub stars, 92 forks, 270 releases, most recent v1.115.0 in July 2026. That release cadence is the number that matters — plenty of self-hosted projects in this space have a good README and a last commit from 2021.

What you should know before committing:

- The maintainers also run a hosted SaaS version, free up to 10 users, with servers in Germany and a Microsoft Teams integration. That's a healthy funding model, not a bait-and-switch — the self-hosted code is the same GPL-3.0 backend — but it does mean the roadmap is shaped by the hosted product.
- The booking UI is a PWA, so it installs on phones without an app store. In practice this is the feature that determines whether hot desking gets adopted or quietly abandoned.
- GPL-3.0 means if you modify it and distribute it, you publish your changes. For internal use that's irrelevant. If you're an agency planning to ship a modified version to a client, read the licence properly first.

**Pick it if:** you want desk booking, you want it self-hosted, and you want to spend your time on floor plans rather than on code.

## LibreBooking — a general resource scheduler that treats desks as resources

[LibreBooking](https://github.com/LibreBooking/librebooking) is the community fork of Booked Scheduler, picked up from Booked's last open-source release in 2020 and developed since. It's GPL-3.0, PHP, and deliberately generic: you define resources, and desks are one kind of resource alongside rooms, vehicles and equipment.

That generality is the trade-off in both directions. You get approval workflows, quotas, blackout periods, custom attributes and reporting out of the box — the kind of administrative machinery that a purpose-built desk app usually doesn't have. What you don't get is a floor plan someone can point at.

It's worth knowing the history because the naming is genuinely confusing in search results. **Booked Scheduler** went closed-source after 2020; the commercial product still exists. **LibreBooking** is the open continuation. Several forks of the fork are also indexed on GitHub, so check you're looking at the active repository before you clone something abandoned.

**Pick it if:** desks are one of several things your organisation reserves, and approval rules matter more than a pretty seat map.

## MRBS — the veteran, and you should know its limits

MRBS (Meeting Room Booking System) has been around since the early 2000s. PHP, MySQL or PostgreSQL, GPL, over 100,000 downloads, and still shipping — the most recent release landed in June 2026. If you want something that will install on any LAMP box in twenty minutes and keep working for a decade, this is it.

Be honest about what it isn't. MRBS is a _room_ booking system. It has no native desk booking concept, no floor plans, no Google Workspace or Microsoft 365 calendar sync, and the interface is functional rather than mobile-friendly. People do press it into service for desks by modelling each desk as a room, and it works, but you'll be explaining that decision to colleagues for as long as the system runs.

**Pick it if:** your actual problem is meeting rooms, your constraint is that it must run on existing infrastructure with no containers, and nobody needs it on a phone.

## Roomer — newer, floor-plan-first, smaller community

[Roomer](https://github.com/c0dewhacker/Roomer) is a more recent self-hosted entrant aimed squarely at the thing MRBS lacks: you upload floor plans, place bookable assets on a canvas, and people book by pointing at the map. It covers desks and other assets across multiple offices, buildings and floors, ships pre-built Docker images, and has directory sync from Okta, Entra ID and OneLogin plus signed outbound webhooks.

The feature list reads like a commercial product, which is the appeal. The caution is the same one that applies to any young project: a small contributor base means you are closer to being the maintainer than you might like. Check the commit history and open issues yourself before you standardise on it.

**Pick it if:** the floor plan is non-negotiable and you're comfortable being an early adopter.

## Side by side

|                      | Seatsurfing               | LibreBooking                | MRBS                     | Roomer                   |
| -------------------- | ------------------------- | --------------------------- | ------------------------ | ------------------------ |
| Primary job          | Desk + room booking       | General resource scheduling | Meeting rooms            | Desk + asset booking     |
| Licence              | GPL-3.0                   | GPL-3.0                     | GPL (v2 / PHP dual)      | Open source, self-hosted |
| Stack                | Go + React, Docker/K8s    | PHP + MySQL                 | PHP + MySQL/Postgres     | Docker images            |
| Floor plans          | Yes                       | No                          | No                       | Yes — core feature       |
| Mobile experience    | Installable PWA           | Mobile-friendly web         | Basic                    | Web                      |
| Directory / SSO sync | Yes                       | Via plugins                 | Multiple auth backends   | Okta, Entra ID, OneLogin |
| Maturity signal      | 270 releases, active 2026 | Active fork since 2020      | 20+ years, released 2026 | Newer, small community   |

## Free hot desk booking software: where each free tier stops

A lot of people land here searching for "free hot desking software", and that's not always the same question as "open source". Sometimes you just want twelve people to stop arguing about the window desks without a purchase order. So here is what free actually buys you, checked against the vendors' own pricing pages on 26 October 2026.

**Self-hosted, free with no user cap.** Seatsurfing, LibreBooking and MRBS cost nothing to license at any headcount. The bill is the server and the person who looks after it, which the next section covers. This is the only route where "free" still holds at 300 employees.

**Seatsurfing Cloud Free: up to 10 users.** The same software, hosted by the maintainers in Germany, no credit card. It includes the Teams, Exchange and Confluence integrations. Approvals, recurring bookings, third-party identity providers and kiosk mode are on the Professional plan at €0.90 per user per month. For a ten-person team that wants hot desking this week, this is where I'd start.

**FlexWhere Basic: up to 25 users.** Free with no time limit, one admin, one floor plan at one location, web and mobile apps. People can only book eight days ahead, and there are no recurring or guest bookings, no statistics and no API. The next tier is €1.99 per user per month. If you have a single office and the floor plan matters more than the integrations, this covers more seats than Seatsurfing's free tier.

The pattern is the same everywhere: free tiers stop at user count first, then at recurring bookings and SSO. Recurring bookings are the one people feel. The person who sits in the same spot every Monday and Thursday has to rebook it by hand, and after a month they stop bothering and just sit there. So before you pick a free plan, count two numbers: how many people will book, and how many of them come in on fixed days. If the second number is most of the first, budget for a paid tier or the self-hosted route from day one.

One thing none of these free tiers give you is the data on your own servers. If that's why you're here, the free option is self-hosting, and it isn't free in time.

## The maintenance bill nobody quotes you

Every one of these is free to download. None of them is free to run. The honest cost of self-hosting a desk booking system, from teams who've done it:

- **A server and a database, backed up.** Desk bookings are low-volume, so the hosting is genuinely cheap. Restoring the database at 8:40am on a Monday is the part that isn't.
- **Upgrades, forever.** Seatsurfing shipped 270 releases. You don't have to take all of them, but you can't take none of them — security patches in Go, PHP and Postgres don't wait for your quarter.
- **Authentication integration.** This is where these projects consume the most time. Getting SAML or OIDC working against your identity provider is a day if you're lucky.
- **An owner.** The single biggest predictor of whether a self-hosted internal tool survives two years is whether one named person is responsible for it. "IT" is not a person.

> **Data residency is usually the real reason**
>
> Most teams that end up self-hosting didn't want to become sysadmins — they had a privacy or works-council requirement that ruled out sending occupancy data to a US SaaS. If that's your driver, say so explicitly in the evaluation. It changes which trade-offs are acceptable, and it makes the maintenance cost easier to justify to whoever is signing off.

## When self-hosting is the wrong answer

There's a case that comes up often enough to name it: you already have an internal portal, an intranet, or a product you're building, and desk booking needs to live _inside_ it. Employees shouldn't be sent to a second system with a second login.

Installing Seatsurfing and iframing it is the tempting move, and it's usually a mistake. You inherit its UI, its auth model and its upgrade cycle, and you spend the next year fighting all three to make it look like it belongs.

What you actually need in that case is availability logic behind an API: something that knows what resources exist, what the rules are, whether a given slot is free, and how to hold it while a person makes up their mind — with the interface entirely yours.

That's the shape of [Opencals](https://opencals.com/developers). It's a hosted booking API with an availability engine, resources, locations and staff as first-class concepts, plus [an npm SDK and MIT-licensed Next.js templates](https://opencals.com/blog/booking-sdk) if you want a head start on the frontend.

Two things I should say plainly, because this article would be worth less without them:

**Opencals is not open source.** The templates and the SDK are MIT. The platform itself is a hosted service, and it is not something you can run on your own hardware. If self-hosting is a hard requirement, stop here and go install Seatsurfing — that's the honest recommendation, and we've written [a longer piece on where that line falls](https://opencals.com/blog/open-source-vs-hosted-booking-api).

**Opencals is not a desk booking product.** There's no floor-plan editor and no hot-desking module. It's the booking backend you build one on, with pricing at $0.99 per booking rather than per seat per month — which for internal tooling usually works out cheaper than a per-user SaaS, because desk reservations are low-volume by nature.

- [Open-source booking systems, compared](https://opencals.com/blog/open-source-booking-system): The wider list — appointment and reservation projects beyond desks and rooms.
- [Open-source room booking systems](https://opencals.com/blog/open-source-room-booking-system): The meeting-room version of this comparison, with calendar sync as the deciding factor.
- [Open-source vs hosted booking API](https://opencals.com/blog/open-source-vs-hosted-booking-api): Who runs the backend, and what each choice actually costs you.
- [The Opencals booking API](https://opencals.com/blog/booking-api): Availability, resources, holds and orders — what the endpoints do.
- [Headless booking, explained](https://opencals.com/blog/headless-booking-system): Keeping the booking engine and the interface separate, and why that matters here.

## How to actually choose, in about an hour

1. **Write down the four jobs and cross out three**: Desks, rooms, general resources, or a component of something you're building. Almost every bad outcome in this category traces back to skipping this step.
2. **Check the last release date, not the star count**: Stars measure a good README. A release in the last quarter measures a maintainer. Seatsurfing and MRBS both pass; check the others yourself on the day you evaluate.
3. **Run the auth integration first**: Not the demo, not the floor plan — the SSO connection. It's the step most likely to kill the project, so fail fast on it.
4. **Name an owner before you install anything**: One person, written down. If nobody will accept that, you want a hosted product, and that's a legitimate conclusion.

## Frequently asked questions

### Is there a genuinely free desk booking system for a small team?

Yes. Seatsurfing self-hosted is GPL-3.0 with no user limit, and the maintainers' hosted version is free up to 10 users. FlexWhere's Basic plan is free up to 25 users at one location, with an eight-day booking window. MRBS and LibreBooking are also free to run. Self-hosted, your costs are the server, the backups and the time.

### Can I use a meeting room booking system for desks?

Mechanically, yes — you model each desk as a room. MRBS and LibreBooking both handle it. The friction is in the interface: a list of 60 'rooms' with no floor plan is hard for people to use, and adoption is the thing that usually fails, not the software.

### Is Opencals open source?

No. The Next.js booking templates and the npm SDK are MIT-licensed and you can fork them freely, but the Opencals platform itself is a hosted service. If self-hosting the backend is a requirement, Seatsurfing or LibreBooking are the right answers rather than Opencals.

### What happened to Booked Scheduler?

Booked Scheduler stopped being open source after its 2020 release and continued as a commercial product. LibreBooking is the community fork that carried on from that last open release, and it's the one under active development. Watch out for abandoned forks-of-the-fork in search results.

### Do any of these sync with Google Calendar or Microsoft 365?

Support varies and it's the single most common integration gap. MRBS has no native calendar sync. Check the current documentation of whichever project you shortlist rather than trusting a comparison table — this is the feature most likely to have changed since any article was written, including this one.

### When does a booking API make more sense than installing one of these?

When the interface has to be yours — an existing intranet, an internal portal, or a product you're shipping to customers. Installing a finished product and then reskinning it usually costs more than building the frontend against an availability API.

## The short version

For most organisations asking this question, **Seatsurfing** is the answer: it's the only project here that's purpose-built for desk booking, actively released, and pleasant enough that employees will use it. **LibreBooking** if desks are one of many resources you schedule. **MRBS** if the real problem is meeting rooms and the constraint is legacy infrastructure. **Roomer** if the floor plan is the whole point and you don't mind being early.

And if what you're really building is booking _inside_ something else — that's not a self-hosting question at all. That's an API question, and it's worth [reading the developer docs](https://opencals.com/developers) before you install anything.