A pictionary server small enough to shut down when nobody plays
The free and privacy respecting pictionary game - Play at https://scribblers.bios-marcel.link
At a glance
- What is it?
- scribble.rs is a Go implementation of a skribbl-style drawing game, BSD-3 licensed, built around one static binary, three Dockerfiles for three deployment targets, seven environment settings including a wildcard CORS default and a 75-second player inactivity threshold, and an official instance in Amsterdam that powers itself off when no traffic arrives.
- Who is it for?
- It fits a group that wants a drawing game with no advertisements, no account and no third party holding the player list, and who are willing to run one instance themselves. Three things to set before exposing it.
- Can I use it commercially?
- Yes. BSD-3-Clause 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 last received commits 70 days ago.
- 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
- scribble-rs/scribble.rs672 ★ · +15
| Repository | 2026-09-11 | 2026-11-15 |
|---|---|---|
| scribble-rs/scribble.rs | 657 | 672 |
15 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The official instance sleeps, and two communities host their own
The hosting arrangement is the first thing to understand about this project, because it shapes everything else.
The official instance is described as possibly not responding instantly, with the reason given plainly: it shuts down automatically when no traffic is received. So the canonical server is a machine that exists only while someone is using it.
Two community instances are listed alongside it. One is maintained by a community member, and the other is maintained by someone who put it up specifically for better latency in Asia, which tells you the official instance is in Europe. The project's own notes confirm the geography: the server is located in Amsterdam, and many players appear to be from outside Europe.
That is the whole reason donations are requested, and the reasoning is worth repeating because it is unusually honest. Hosting is described as very minimal, there is no domain, and the money would go toward infrastructure and a domain. The stated goal is a decentralised deployment so the experience is decent for everyone, which is the same thing as saying the project would rather there were ten instances than one slow one.
The repository name suggests the intent. The module path carries an rs suffix, so the canonical home is a version of the game, not the game itself.
CORS defaults to a wildcard and only the port is required
Configuration comes from environment variables or a dotenv file in the working directory, and the table of settings is short enough to memorise.
Only PORT is required, defaulting to 8080. NETWORK_ADDRESS sets the TCP address to listen on, which is how you bind to something other than every interface. ROOT_PATH changes the path after your domain, so the game can live under a subpath on an existing site.
Then CORS_ALLOWED_ORIGINS, which defaults to a wildcard, and CORS_ALLOW_CREDENTIALS, which has no default. The wildcard default is the right call for a game you run for friends and the wrong call the moment the instance is reachable by anyone, since a permissive cross-origin policy is what lets a page on another origin talk to your server.
The last two settings are about lobbies rather than HTTP. LOBBY_CLEANUP_INTERVAL defaults to 90 seconds and is how often the server sweeps, and LOBBY_CLEANUP_PLAYER_INACTIVITY_THRESHOLD defaults to 75 seconds and is how long a player may be idle before being considered gone.
The documentation points at the Go config file as the authoritative list rather than treating the table as current, which is the right way round: the code is the contract and the table is a convenience.
Seventy-five seconds of inactivity is a short fuse
The two cleanup numbers are the most consequential settings in the file and the least explained.
An inactivity threshold of 75 seconds means a player who stops interacting for a minute and a quarter is treated as inactive. The sweep that acts on that runs every 90 seconds. So the worst case between becoming idle and being cleaned up is a little under three minutes.
For a drawing game, that is aggressive. Drawing involves thinking, and a player who pauses to look something up, or whose round has ended while they are still reading the chat, is idle in the technical sense for far longer than 75 seconds without having left.
The reasonable reading is that both values are meant to be raised for a real deployment, and they are optional precisely so that a self-hoster can do it. What the defaults give you is a server that does not accumulate abandoned lobbies, which matters when the machine is small and asleep when unused.
So the choice is between a tidy lobby list and players who get dropped mid-conversation. Both numbers are settable in the environment, and for anyone hosting beyond a group chat they are the first two things to change.
Note also that these are cleanup thresholds and not session lifetimes. Nothing here says what happens to a player's drawing state, only how long they linger in the lobby list.
Three Dockerfiles for three different deployment targets
There are three Dockerfiles at the repository root, and the naming tells you the matrix: a Linux image, a Windows image, and one for the project's own host.
Docker is the recommended way to run the server, with the stated reason that it rules out almost all compatibility issues. That is a stronger recommendation than it sounds, because the alternative is a Go binary that assumes a working network stack and a browser, and the compatibility problems people hit are almost never about Go.
The image tags follow a rule that changed at a specific version. Starting from v0.8.5, images are only built on tagged pushes, so every git tag produces a Docker tag, and the floating latest tag always points to the latest version released through GitHub rather than to the newest commit. That is a deliberate separation between what is built and what is released, and it means an untagged branch never produces a floating image.
docker run --pull always --env PORT=8080 -p 80:8080 biosmarcel/scribble.rs:latestThe port mapping is the part to get right. The container listens on 8080 internally and you map a host port to it, with the documentation noting that the internal port should not need changing under normal circumstances. Always pulling is recommended in the command itself, which keeps a long-lived container from drifting behind the current release.
The Windows tag exists for people who want a native Windows container, and the guidance is to use the Linux variant otherwise since that is the default mode on Windows.
WebSockets mean your reverse proxy needs work first
The game is not request and response, and the documentation is direct about the consequence.
Because the server uses WebSockets, running it behind an nginx reverse proxy requires nginx to be configured to support that. An example configuration lives on a wiki page, and other reverse proxies may need equivalent changes.
This is the single most common way a self-hosted real-time application fails, and it fails in a way that looks like a server problem rather than a proxy problem. The page loads, because that is a plain HTTP request. Then the connection that carries the drawing and the lobby never establishes, and the browser console shows a failed upgrade handshake. People conclude the server is broken.
The project's position on this is that the wiki is the documentation, and that anyone using a well-known reverse proxy is invited to contribute a configuration for it. So the supported set of proxies is whatever the wiki has gained over time, which is a slow and honest way to accumulate coverage.
Two takeaways for a host. Read the proxy page before you install, not after. And if you are behind a load balancer rather than a single proxy, the upgrade headers have to survive that hop too, which the wiki page may not cover.
The metrics endpoint exists and the dashboard is deliberately closed
There is a Prometheus endpoint at a versioned path, and the caveat about it comes before the feature.
It is stated that the endpoint currently does not expose a lot of information, and that if there are requests for specific data the author is willing to extend it, with one condition: it must not expose personal data.
That condition is the interesting part. A Prometheus endpoint on a game server naturally wants player counts, session identifiers, lobby membership and durations, and every one of those is personal data about identifiable people in a small community. So the extension policy is opt-in per request and constrained by a privacy rule rather than by an implementation limit.
A dashboard exists, but it is not public, and the reason given is infrastructural rather than philosophical: the host does not support public dashboards. So the data is collected and stays closed.
For a self-hoster the endpoint is still the way to see whether the instance is alive and how loaded it is, which is exactly what you want given that an idle instance may be powered off.
The Go dependency list confirms the intent: the Prometheus client library is a direct dependency, not an afterthought added to a dashboard.
Translations must start from en_us.go or keys rot
The translation policy is three sentences long and it encodes a lesson learned the hard way.
For any translation work, the instruction is to always use the English source file as the base. The reason given is that other translations might not be up to date, which causes missing keys or keys for behaviour that no longer exists.
So the failure mode is specific and worth stating plainly. A translator who starts from a lagging translation file will produce a file with gaps, and will also carry forward strings for features that were removed or renamed. Both errors are invisible until a player hits a raw key or a label describing a setting that no longer exists.
The base file is named with a locale suffix, so the intent is one source of truth per string rather than a shared default. Translations are evidently a live part of the project rather than an afterthought, since the policy exists at all.
For a contributor, the practical rule is mechanical: update the English file first, then translate from it, and never the other way round. That is what keeps a translated instance from silently diverging from the server it talks to.
Eleven direct dependencies, two of them first-party forks
The module manifest is small enough to read, which is how you tell that this is a server rather than a framework.
The module path is github.com/scribble-rs/scribble.rs and the language version is Go 1.25.0. There are eleven direct dependencies. Two of them are forks maintained by the same author: a Discord emoji map, which is what turns short codes into actual emoji in the chat, and a petname generator, which is presumably where the randomised player names come from.
The rest are infrastructure choices, and each one names a design decision. A struct-tag environment parser for configuration, a CORS middleware matching the permissive default, a UUID library, a WebSocket implementation, the Prometheus client, a testing library, a dotenv loader matching the dotenv file support, and the internationalisation text library.
Two absences are as informative as the eleven. There is no database driver, so game state lives in memory, which is consistent with lobbies that are reaped on a timer and with an instance that powers itself off. And there is no web framework, because the server is doing WebSockets and serving a small set of static files rather than routing requests.
The build produces a single binary from a command directory, and the documentation names it for both platforms, with the Windows extension added there.
Editorial conclusion
It fits a group that wants a drawing game with no advertisements, no account and no third party holding the player list, and who are willing to run one instance themselves. Three things to set before exposing it. CORS_ALLOWED_ORIGINS defaults to a wildcard, which is fine for a local game and wrong for anything on a shared domain, so narrow it. The inactivity threshold is 75 seconds, which is short for a human who puts the keyboard down mid-round. And the game uses WebSockets, so a reverse proxy in front of it needs WebSocket support configured by hand, which is the step most self-hosting guides skip. Building from source needs Go 1.25 or later and produces a single portable binary.
Frequently asked questions
What is scribble.rs?
It is a free, privacy-respecting pictionary drawing game written in Go and licensed BSD-3-Clause, positioned as an alternative to the web-based game skribbl.io. It has no advertisements and needs no account to play, builds to a single portable binary, and is deployed with Docker on Linux, Windows or the maintainer's own host.
How do I run scribble.rs with Docker?
Pull the Linux image with docker pull biosmarcel/scribble.rs:latest and run it with a port mapping, passing PORT=8080 as an environment variable. The Windows image is tagged windows-latest and is only for native Windows containers. Since v0.8.5, images are built only on tagged pushes, and the latest tag always points to the newest GitHub release.
What environment variables does scribble.rs read?
Settings come from environment variables or a .env file in the working directory. PORT is the only required one and defaults to 8080. The others are NETWORK_ADDRESS, ROOT_PATH, CORS_ALLOWED_ORIGINS which defaults to a wildcard, CORS_ALLOW_CREDENTIALS, LOBBY_CLEANUP_INTERVAL at 90 seconds, and LOBBY_CLEANUP_PLAYER_INACTIVITY_THRESHOLD at 75 seconds.
Does scribble.rs need a database or a reverse proxy configuration?
No database: the Go dependency list contains no database driver, so game state is held in memory. It does need proxy help if you run one, because the game uses WebSockets, so nginx or another reverse proxy must be configured to support them. An example configuration is on the project wiki, and contributions for other well-known proxies are invited.
How do I build scribble.rs from source?
You need Go 1.25.0 or later and git. Clone the repository, change into the directory, and run go build ./cmd/scribblers, which produces a portable binary named scribblers, or scribblers.exe on Windows. Pre-compiled binaries are also published in the releases section, though the documentation warns they may not be compatible with your system.
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/scribble-rs-scribble-rs)Star history chart for your README
[](https://hysenlabs.com/projects/scribble-rs-scribble-rs)Was this useful?