Pokete: a terminal Pokemon-like game in Python

What Pokete actually is, and who it is for

Pokete is a small terminal game in the style of an old Gamefreak title, written in Python and distributed under GPL-3.0-only. The README calls it "a small terminal based game in the style of a very popular and old game by Gamefreak." That sentence is the whole pitch: turn-based creature battles, type matchups, catching, leveling, and a map you walk with W, A, S and D, all rendered as characters in a terminal window.

The audience is narrow and specific. It suits people who already live in a shell, who want a game that starts from a single command, and who are willing to read a wiki page instead of a tutorial overlay. It also suits Python developers looking for a small codebase to read or extend: the repository exposes pokete_classes, pokete_data, util and pokete_general_use_fns as documented modules, and the contributing section points new creature contributions at pokete_data/poketes.py. If you want a game with a window, a mouse, or a controller, this is the wrong project and the README does not pretend otherwise.

How the game loop, types and mods fit together

The runtime dependency is scrap_engine>=1.5.1, declared in pyproject.toml. scrap_engine handles the terminal rendering and input layer; Pokete supplies the game rules, the map data, the creatures and the menu system. That split is why the README's local-run instructions install scrap_engine separately before cloning the repository and running the package from src.

Battles are turn-based and driven by a type table the README prints in full. Stone beats Flying and Fire but is ineffective against Plant; Undead is effective against Normal, Ground, Plant and Water and ineffective against Fire. Attacks have AP, and the README states you can only choose an attack while its AP is above 0. Wild encounters trigger when you step into high grass, marked as ;. Trainer fights, marked as a, cannot be fled; the README says you either win or lose, and that trainer fights give double XP. Healing happens at the Pokete Center, where you can also see creatures beyond the six in your active deck.

Mods are the extension point. The README says a mod must be placed in mods and that mods have to be enabled in the menu, with mods/example.py as the reference. That is a plain file-drop mechanism, not a plugin registry, and it means mod loading depends on the working directory and on the menu toggle rather than on any package metadata.

Installing Pokete and starting a first battle

The fastest path is the published package. The README gives this as the primary install command, and it pulls in scrap_engine as a dependency:

pip install pokete

After that the pyproject.toml entry point registers a pokete console script, so the game starts with no arguments. The README says the game can be run normally without supplying any options, and that non-gameplay options live behind --help:

pokete --help

If you would rather run from source, the README's local instructions install the engine, clone the repository, change into src and run the package as a module:

pip install scrap_engine
git clone https://github.com/lxgr-linux/pokete.git
cd pokete/src
python -m pokete

There are two other distribution routes in the README. Arch users can install from the AUR with buildaur -S pokete-git, and there is an AppImage on the release page, with the caveat that you must create the ~/.cache/pokete/ folder first. On Windows, the README notes that some antivirus software may flag libplaysound.dll as malicious, and that if the game crashes you should confirm the .dll exists and is not quarantined. It also states that pynput has to be installed on Windows.

Once inside, you get a starter creature named Steini. Move with W, A, S and D. Step into high grass and a wild creature may attack. Press 1 to see your attacks, then press the number of the attack or move the * cursor to it and press Enter. Weaken a wild creature and throw a Poketeball to try to catch it. The README is explicit about one piece of state handling: changes are only saved when you quit through the exit function, so closing the terminal window can discard a session.

Where Pokete breaks down

The README's own tips section is the most honest part of the project. It says not to play on full-screen because the game will not run properly. That is a rendering constraint, not a preference, and it tells you the terminal geometry assumptions are narrow. Anyone running a tiling window manager with a maximized terminal will hit it immediately.

Platform packaging is uneven. The pip and source paths are the documented ones; the AppImage requires a cache directory to exist beforehand, which is a manual step that will trip up anyone expecting a self-contained binary. The Windows path carries an antivirus warning about libplaysound.dll, and the README also points at playsound/README.md for rebuilding the audio module when the architecture causes trouble. Audio is the fragile part of the install.

Persistence is coarse. Because the README ties saving to the exit function, an interrupted session loses progress. There is no documented autosave, no save slot command, and no rollback described anywhere in the README. If you want a game you can suspend and resume casually, this design works against you.

Finally, the version story is worth reading carefully. The latest tagged release listed is 0.9.2 from 2024-06-15, while pyproject.toml declares version 0.10.0-rc4. The repository's last push was on 2026-05-22, so work continues on master ahead of a stable release. If you install from pip you are getting a released version; if you clone master you are getting pre-release code. Those are different products, and the README does not spell out the difference.

Pokete against Tuxemon and other terminal creature games

Tuxemon is the obvious comparison and it appears in the related searches for this project. The difference is architecture, not theme. Tuxemon is a full game engine with its own map editor, scripting and asset pipeline, aimed at people building a creature-battler rather than only playing one. Pokete is a game first and an extension surface second: its documented extension points are mod files in mods/ and creature data in pokete_data/poketes.py, both of which assume you are editing or dropping files into an existing game rather than authoring a new one.

That makes Pokete the lighter choice. It installs with one pip command, its dependency list is a single engine module, and the whole thing is meant to be read. Tuxemon asks for more setup and more conceptual overhead. If your goal is to play something in a terminal tonight, Pokete is the shorter path. If your goal is to build a creature-battler of your own with content tools, Pokete's mod system will feel thin, because the README describes exactly one example mod and no tooling around it.

A second comparison worth naming is Pokemon-colorscripts, also in the related searches. That is a display utility, not a game: it prints creature sprites into your terminal. It shares the terminal and the theme and nothing else. Do not treat it as an alternative unless all you wanted was the artwork.

Licence, maintenance and what an upgrade costs you

Pokete is GPL-3.0-only, stated in pyproject.toml and shown as GPL-3.0 in the repository metadata. For anyone redistributing a modified build, that means the usual copyleft obligations attach to the whole combined work. Mods are the interesting case: the README does not state a licence position for mod files, so if you plan to ship a mod alongside the game, the terms are something you would need to clarify with the project rather than assume. This is not legal advice; read the LICENSE file in the repository root.

The dependency floor is Python 3.12 and scrap_engine>=1.5.1. Both are declared in pyproject.toml, and the engine floor is a real constraint: an older scrap_engine will not satisfy the resolver. Upgrading Pokete therefore means checking that your Python and engine versions still line up, and on Arch the AUR package pokete-git tracks the repository rather than a tagged release, so it will move ahead of pip's released version.

Maintenance is ongoing but the release cadence is slow. The last push to the repository was on 2026-05-22. The most recent tagged release is 0.9.2, dated 2024-06-15, while the project metadata already carries 0.10.0-rc4. Practically, that means master is where development happens and tagged releases lag behind it. If you depend on Pokete for anything, pin the version you install and read Changelog.md before moving, because the README does not document a rollback path.

Editorial conclusion

Adopt Pokete if you want a small, moddable, keyboard-driven creature battler that runs in any terminal and you are comfortable with Python 3.12 and scrap_engine. Skip it if you need a graphical client, a packaged Windows build without antivirus friction, or a game whose documentation covers every subsystem; the README itself warns that full-screen terminals misrender the game. Before committing, verify Python 3.12 or newer, install scrap_engine>=1.5.1, and confirm the mods/ loading path works in your environment.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. lxgr-linux/pokete on GitHub
3. Project website
4. README
5. Releases