OpenCloud's Go server backend: filesystem state, OpenID Connect, and one binary from 42 service modules
🌤️ OpenCloud is the open source platform for file management, sharing and collaboration. Simple and sovereign.
At a glance
- What is it?
- This repository is the Go backend of the OpenCloud file management platform, and it makes two architectural bets visible up front: no database at all, with every byte stored under the filesystem root at $HOME/.opencloud, and OpenID Connect for every user, whether the identity provider is Keycloak or the embedded LibreGraph Connect.
- Who is it for?
- Pick OpenCloud when you want a self-hosted file sync and share service with the data left in plain files on disk, and you are prepared to own the identity provider decision and the go-micro service mesh. Before you start, confirm that you can live with a filesystem instead of a database, that you have either Keycloak or LibreGraph Connect available, and that building the assets for the web UI is part of your release pipeline.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Go, 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.
Star history
- opencloud-eu/opencloud6,348 ★ · +293
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| opencloud-eu/opencloud | 6.1k | 6.3k |
293 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
State lives in the filesystem, not in a database
The backend states its storage decision in one sentence: it does not use a database, and it stores all data in the filesystem, with the root directory of the backend at `$HOME/.opencloud/` by default. Everything downstream inherits that choice. The top-level listing carries no schema directory, no migration folder and no connection string, because there is nothing to connect to. The same path also holds the server configuration that the init step writes, so data and configuration sit side by side.
What you give up is a query layer. There is no SQL surface to join against, no place to run an ad hoc aggregate over stored objects, and no transaction boundary spanning several files. Counting, reporting and integrity checks have to be expressed through the service modules or against the files themselves. That suits workloads where the filesystem is the interface you already understand, and it is awkward where you expected to ask the database a question. The webdav, ocs and graph services sit on top of the arrangement rather than beside it.
OpenID Connect with LibreGraph Connect as the built-in provider
Authentication is OpenID Connect, with two sources: an external identity provider such as Keycloak, or the embedded LibreGraph Connect provider, whose code lives in the lico repository. The dependency list shows this is a protocol stack rather than a home-grown session layer:
github.com/coreos/go-oidc/v3 v3.21.0
github.com/Nerzal/gocloak/v13 v13.9.0
github.com/MicahParks/keyfunc/v2 v2.1.0
github.com/golang-jwt/jwt/v5 v5.3.1The module file lists the gocloak Keycloak client, the keyfunc library, go-oidc v3 and a JWT library. The Makefile also has separate modules named `auth-app`, `auth-basic`, `auth-bearer`, `auth-machine` and `auth-service`, sitting next to `services/idp` and `services/idm`. For security problems the project asks you to write to [email protected] immediately.
One binary assembled from 41 service modules
`make -C opencloud build` produces a single executable at `opencloud/bin/opencloud`, and the Makefile shows how much process that one file contains. Its OC_MODULES list names 42 services, from `services/activitylog` and `services/antivirus` through `services/webdav`, `services/webfinger` and `services/users`, plus the `opencloud`, `pkg` and `protogen` trees. The module file targets Go 1.26.0.
The services talk to each other through go-micro plugins:
github.com/go-micro/plugins/v4/client/grpc v1.2.1
github.com/go-micro/plugins/v4/logger/zerolog v1.2.0
github.com/go-micro/plugins/v4/registry/memory v1.2.0
github.com/go-micro/plugins/v4/server/grpc v1.2.0
github.com/go-micro/plugins/v4/server/http v1.2.2
github.com/go-micro/plugins/v4/store/nats-js-kv v0.0.0-20240726082623-6831adfdcdc4
github.com/go-micro/plugins/v4/wrapper/monitoring/prometheus v1.2.0
github.com/go-micro/plugins/v4/wrapper/trace/opentelemetry v1.2.0Storage is split by audience rather than by feature, with separate modules for `storage-users`, `storage-shares` and `storage-publiclink` behind a `gateway` service. The Makefile comment beside the module list asks that any new module also be added to the CI pipeline file, which is how you know the list is load-bearing.
make generate is a prerequisite, not part of the compile
Building the backend is two commands, and the first one is not the Go compiler. `make generate` produces the assets needed by the web UI and by the built-in identity provider, so a bare checkout without them cannot produce a working binary. Then `make -C opencloud build` compiles and drops the result at `opencloud/bin/opencloud`.
Starting it takes one more line, and the binary is its own installer:
opencloud/bin/opencloud init && opencloud/bin/opencloud serverThe init half creates the server configuration, in `$HOME/.opencloud` by default, and the server half starts it. Handy for a local test instance, and it also means the configuration location travels with the process instead of with a service manager. Anything beyond that, including the rest of the setup and installation options, is pushed to the development documentation rather than kept in this file.
The container build is a three-stage chain that ends on Alpine
There are two container routes. `make -C opencloud dev-docker` builds an `opencloud/opencloud:dev` image from your local pnpm and Go caches, which the Dockerfile header says is a lot faster than the manual steps. The manual route is `docker build -t opencloud/opencloud:custom .`, and the header tells you to use it only when you want an image from source without pnpm and Go installed on your machine.
The manual build runs three stages. quay.io/opencloudeu/nodejs-ci:24 runs `make node-generate-prod` to produce the frontend assets, quay.io/opencloudeu/golang-ci:1.26 runs `make go-generate build ENABLE_VIPS=true`, and the runtime layer is alpine:3.24 with this package set:
RUN apk add --no-cache attr ca-certificates curl mailcap tree vips && \
echo 'hosts: files dns' >| /etc/nsswitch.confThe final image carries the Apache-2.0 label, and runs `/usr/bin/opencloud` with `server` as the default command.
Antivirus, search and thumbnails each pull their own engine
Three modules reach out to third-party engines that you can trace straight to the module file:
github.com/dutchcoders/go-clamd v0.0.0-20170520113014-b970184f4d9e
github.com/blevesearch/bleve/v2 v2.6.1
github.com/davidbyttow/govips/v2 v2.20.0
github.com/google/go-tika v0.3.1`services/antivirus` pairs with the go-clamd client, which talks to ClamAV. `services/search` pairs with Bleve 2.6.1. `services/thumbnails` pairs with the govips binding for libvips, and the Dockerfile both installs `vips` in the runtime layer and passes `ENABLE_VIPS=true` at build time, so image preprocessing is compiled into the binary rather than added later. Content extraction runs through Tika, and file type sniffing through mimetype 1.4.15. Because each engine sits behind its own service module, you can reason about the cost of each one separately, and you also inherit everything those engines pull in. `github.com/KimMachineGun/automemlimit` is in the list to keep the Go heap inside a cgroup limit.
This repository is the backend half and sends you elsewhere for the rest
The opening paragraph says what this repository is: the main repository of the OpenCloud server, containing the Go codebase for the backend services. It is not the whole product. A tip box at the top points general information and installation questions to the OpenCloud GitHub organization and to opencloud.eu, and the project documentation lives in a separate opencloud-eu/docs repository. If you are looking for the end-user install path, this file starts at generating assets and compiling a binary and never gets past it.
Two details hint at the wider stack. The Makefile defines PHP_CODESNIFFER and PHP_CODEBEAUTIFIER pointing into vendor-bin/opencloud-codestyle, and the tree carries composer.json and phpcs.xml, so a PHP piece lives next to this Go server. And this group of modules is the one that goes through Transifex for translations:
L10N_MODULES := \
services/activitylog \
services/graph \
services/notifications \
services/userlog \
services/settingsThe community channel is an Element room, #opencloud:matrix.org. Build and lint tooling is pinned with a .golangci.yml, .codacy.yml, a Woodpecker pipeline in .woodpecker.star, and a vendored dependency tree.
Editorial conclusion
Pick OpenCloud when you want a self-hosted file sync and share service with the data left in plain files on disk, and you are prepared to own the identity provider decision and the go-micro service mesh. Before you start, confirm that you can live with a filesystem instead of a database, that you have either Keycloak or LibreGraph Connect available, and that building the assets for the web UI is part of your release pipeline. Version 9.0.0 shipped on 27 October 2026 and the main branch was pushed to on 2 November 2026, so pin your build inputs.
Frequently asked questions
What is OpenCloud used for?
File management, sharing and collaboration. The container image labels describe it as a modern file-sync and share platform, and this repository holds the Go backend services that serve those files.
What does OpenCloud do with its data?
It keeps everything in the filesystem. The backend does not use a database, and the root directory of the backend is $HOME/.opencloud/ by default, which also holds the configuration written by the init step.
How do I install OpenCloud from this repository?
Generate the assets, compile, then run: make generate, make -C opencloud build, and opencloud/bin/opencloud init && opencloud/bin/opencloud server. The server configuration lands in $HOME/.opencloud by default. Further setup options are in the development documentation.
How do I install OpenCloud with Docker?
Use make -C opencloud dev-docker for a dev image that reuses your local pnpm and Go caches, or docker build -t opencloud/opencloud:custom . for a from-source image when pnpm and Go are not installed locally. The image entrypoint is /usr/bin/opencloud with server as the default command.
Is OpenCloud free to use?
The server is released under Apache 2.0, which is the license in the repository LICENSE file and in the container image labels. No paid tier, subscription or support contract is described anywhere in this repository.
Is OpenCloud secure?
Every user authenticates through OpenID Connect, either against an external provider such as Keycloak or the embedded LibreGraph Connect provider, and there is an antivirus service module backed by a ClamAV client. Security issues go to [email protected].
Official sources
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.
[](https://hysenlabs.com/projects/opencloud-eu-opencloud)Star history chart for your README
[](https://hysenlabs.com/projects/opencloud-eu-opencloud)Was this useful?