You're the OS!: the game where an impatient user reboots you
A game where you are a computer's OS and you have to manage processes, memory and I/O events.
At a glance
- What is it?
- A Python game about processes, memory and I/O events, playable in a browser, on itch.io, or as a desktop build that exposes an API for automation scripts. The entry points, version policy and asset licenses are pinned down tightly enough to read before you clone anything.
- Who is it for?
- Read this one as a small, well documented Python project with two separate delivery paths, not as a systems simulator. Anyone scripting it should decide first whether the flash warning matters for the person watching, because it applies to the bundled example.
- 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 5 days ago.
- What is it written in?
- Mainly Python, 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
- plbrault/youre-the-os2,692 ★ · +7
| Repository | 2026-10-04 | 2026-11-15 |
|---|---|---|
| plbrault/youre-the-os | 2.7k | 2.7k |
7 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The main branch is the one marked unstable
Running Locally opens with a warning that the main branch can be unstable and that you should check out a release tag for a stable version. The tag history backs that up. Three recent releases are on record: v1.10.1 on 2026-02-09, v1.11.0 on 2026-04-11 and v1.11.1 on 2026-07-03, which is a patch line stepping forward every couple of months through the first half of 2026.
The default branch, though, was pushed to on 2026-09-23, more than two months after the newest tag. So the code you get by cloning is not what v1.11.1 users downloaded, and the documented route to a stable build happens to be the route that freezes you on older code. On the dependency side the repository is properly reproducible, with both Pipfile and Pipfile.lock committed at the root, so pipenv sync resolves an exact set. On the application side there is no equivalent pin. Nothing in the documentation says which release the hosted browser build corresponds to either, so the page, the itch.io listing and a source build are three views of a project that ships on its own schedule.
An empty .venv is listed as a prerequisite, not as a step
The prerequisite list asks for three things: Python 3.14, pipenv, and an empty `.venv` directory at the root of the project. It also warns that the project is not guaranteed to work with other Python versions, and suggests pyenv if you need the exact interpreter without changing the system globally. A `.python-version` file sits at the root for that purpose, so anyone already using pyenv gets the right version as a side effect of being in the directory.
The ordering is where it gets odd. The usage section starts directly at dependency installation with a single command:
pipenv sync --devThere is no step anywhere that creates the virtual environment, even though the prerequisites treat an empty `.venv` as something you must have in place first. A fresh clone therefore either works because pipenv creates the directory anyway, or the requirement is stale documentation left over from an older setup flow. The rest of the commands all go through pipenv scripts: desktop and web for the two playable builds, sandbox, auto, pylint and pytest, backed by run-desktop.py, run-web.py, run-sandbox.py and run-auto.py at the repository root.
The browser build and the itch.io archive are two artifacts
You can play in a browser either at plbrault.github.io/youre-the-os or on itch.io, and the source tree builds its own copy of the web version in two steps. `pipenv run web build` produces the build without running it, and `pipenv run web archive` creates web.zip, named explicitly as the archive format for itch.io uploads. So there are three ways to get the game and two of them come out of subcommands of the same pipenv script.
The desktop version is the third path and carries the only documented extension surface. Cloning the repository and following the local instructions gives you a desktop build that also exposes an API for implementing automated scripts, and that API is what the auto entry point drives. Nothing states whether the hosted page and a locally built web version stay in step with each other between releases, so if you care about running the current code rather than the current hosted build, the local web build is the only option the documentation actually supports.
Sandbox stage configs belong in a gitignored directory
Sandbox mode lets you skip the menu and drop straight into a custom stage, and it is described as provided for development purposes. You hand it a Python module path rather than a filename. The shipped example lives at src/sandbox/sample.py, so the command is:
pipenv run sandbox sandbox.sampleA file at src/sandbox/myConfig.py becomes the module path sandbox.myConfig, which is the substitution the instructions spell out. The recommended home for your own configuration is that same src/sandbox directory, and the reason is given: files added there are ignored by Git. That is convenient for iterating on a stage and it has a cost worth naming, since the stage you are building never shows up in a diff, in a review, or in a release tag. If you keep it there, you are relying entirely on your own backups, and anyone who clones your fork gets nothing of it.
Automation carries a warning about the screen
The scripted entry point credits its original implementation to @Wiguwbe and takes a script path plus arguments:
pipenv run auto <script.py> [args]
# to get all the available options
pipenv run auto --helpAbove that block sits a warning that running automation scripts, including the provided example, may cause rapidly changing colors on the screen. That second clause matters: the caveat is not limited to something you write yourself, it covers the example the project ships. The starting point for writing a script is automation/skeleton.py, and the desktop version's API is described in a single sentence, so that skeleton plus `--help` output is effectively the whole interface documentation. The browser and sandbox routes have no documented script hook, which puts every automation attempt on the desktop build.
Pull requests outside bug and help wanted are likely closed
Contributing sets a narrow gate: pull requests that address open issues labeled `bug` or `help wanted` are welcome, and any other pull request is likely to be closed. Before submitting anything, the linter and unit tests have to pass, which the usage section maps to two pipenv scripts, `pipenv run pylint` and `pipenv run pytest`, with a `.pylintrc` committed at the root to hold the rule set.
The policy is enforced in practice by the fact that ideas are routed elsewhere. Anything that is not a fix for a labeled issue is asked for in the Discussions tab instead of the pull request queue, which is why the labels are a gate rather than a formality. There is also an AGENTS.md at the repository root, and the contribution guidance says that if you use AI, your agent must follow all instructions in it. Automated contributors are held to the same two gates as everyone else: pass pylint, pass pytest, and have an open issue with the right label.
An idle process is what gets you rebooted
The premise is that you are the operating system of a computer, and your job is processes, memory and I/O events. The failure condition is stated in the opening lines of the project: processes left idling for too long make the user impatient, and an impatient user reboots you. There is no separate lose state described beyond that reboot, which makes it the central pressure of the loop rather than one failure among several.
What is not documented is as informative as what is. No stage list, no process roster, no memory figures, no scoring rules and no system requirements appear at this level of detail, so the scheduling problem each stage poses cannot be read off the page. For anyone deciding between this and a systems teaching tool, the named mechanics are scheduling, memory and event handling, and that is the full extent of the claim. If you want to know how many processes a stage holds or what the memory pressure curve looks like, the answers are not here, and the sandbox mode exists precisely because stages need to be tried rather than described.
GPL-3.0 code sits on four different asset licenses
The program is GPL-3.0, copyright 2023-present Pier-Luc Brault, with the standard redistribution and warranty paragraphs. The assets are a separate matter and the terms do not match each other. The game icon and logo are a modified version of an image by Muhammat Sukirman under Creative Commons Attribution 3.0. Emojis come from OpenMoji under Attribution-ShareAlike 4.0. The image on the Game Over screen is by Aleksandar Cvetanović, published on Pixabay before January 2019 and therefore treated as CC0 under Pixabay's terms. The two fonts, VT323 by Peter Hull and Victor Mono by Rune Bjørnerås, are under the Open Font License.
So a redistributed build mixes a copyleft code license, a share-alike obligation on the emoji set, a permissive derived logo and two permissive fonts. What the project does not say is whether the share-alike term on the emoji set is meant to reach a combined work of code plus assets, which is the question that matters to anyone forking the game and shipping their own build.
Editorial conclusion
Read this one as a small, well documented Python project with two separate delivery paths, not as a systems simulator. Anyone scripting it should decide first whether the flash warning matters for the person watching, because it applies to the bundled example. Anyone cloning it should pin to a release tag rather than main, confirm Python 3.14 with pipenv and the empty .venv directory the prerequisites demand, and remember that your own sandbox stage stays untracked if you keep it in src/sandbox. The one thing worth checking before forking is the emoji license: the code is GPL-3.0, the OpenMoji set is share-alike, and nobody has written down which obligation reaches a combined build. Latest tag v1.11.1 is dated 2026-07-03; the default branch was pushed to on 2026-09-23.
Frequently asked questions
What do you actually manage in You're the OS!?
Processes, memory and I/O events. You play as the operating system of a computer, and the documented failure condition is leaving processes idle for too long, which makes the in-game user impatient enough to reboot you.
Can You're the OS! be played without installing it locally?
Yes, in a browser at plbrault.github.io/youre-the-os or on itch.io. Building from source is the separate route, where pipenv run web build produces the build and pipenv run web archive creates web.zip for itch.io uploads.
What does running You're the OS! locally require?
Python 3.14, pipenv, and an empty .venv directory at the root of the project, with pyenv suggested for obtaining the exact interpreter version. Other Python versions are not guaranteed to work.
Does You're the OS! have an automation API?
Only the desktop build exposes one, for implementing automated scripts. The entry point is pipenv run auto <script.py> [args], automation/skeleton.py is the starting point, and the documentation warns that the bundled example causes rapidly changing screen colors.
When was You're the OS! last released?
The newest release listed is v1.11.1 on 2026-07-03, following v1.11.0 on 2026-04-11 and v1.10.1 on 2026-02-09. The default branch was pushed to on 2026-09-23, and the local run instructions mark main as potentially unstable and recommend a release tag.
What license covers You're the OS! and its assets?
The program is GPL-3.0. The assets carry their own terms: a logo derived from an image under CC BY 3.0, OpenMoji emojis under CC BY-SA 4.0, a Game Over screen image treated as CC0, and the VT323 and Victor Mono fonts under the Open Font License.
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/plbrault-youre-the-os)Star history chart for your README
[](https://hysenlabs.com/projects/plbrault-youre-the-os)Was this useful?