Our sandbox installed pub-street-fighter-ai at commit 64bbf61 in 47 seconds and recorded 5,861 MB on disk. Use it to inspect a supplied Street Fighter reinforcement-learning agent and compare two clearly defined evaluation modes. Players seeking a turnkey game or a documented human opponent should choose something else. The central distinction is practical: winning twelve separately loaded levels and completing one continuous arcade attempt describe different experiments, even when both use the same character and checkpoint.
What you can do with pub-street-fighter-ai
The project supplies a PPO-trained NatureCNN model controlling Ryu in Street Fighter II: Special Champion Edition, together with training logs and evaluation code. The README describes watching the supplied model, evaluating it without a game window and continuing training from its checkpoint. PPO is the learning algorithm; NatureCNN processes game images for the policy. These workflows make the repository useful for studying how observations, actions and rewards fit together in a fighting-game experiment. Ultimate SFighterAI README.
The default evaluation loads a separate opening save state for each of twelve levels and continues to later levels after a loss. Continuous mode loads the first level once, follows the game's own progression and ends the attempt on defeat. Choose the mode according to the question you want answered. Separate starts describe performance from the supplied situations; continuous progression asks whether the policy can finish the sequence in one attempt. Keep that distinction attached to any reported completion figure.
The README also separates policy input from reward calculation. The model receives game images, while the training environment reads both fighters' health from memory to calculate rewards and determine outcomes. That makes image-based decision-making an accurate description of the policy. Health values still play a direct role in training. For someone adapting this design, the observation pipeline and the reward pipeline are separate parts to inspect, rather than one undifferentiated claim about learning from pixels.
What people use pub-street-fighter-ai for
GitNova suggests three uses: watching the agent, comparing evaluation modes and continuing PPO training with TensorBoard logs. Its page labels the description an AI-generated summary and warns that details may be inaccurate. The primary README documents corresponding workflows, so they are sensible starting points for exploring the repository. Read the discovery page as a list of proposed activities, while using the project's instructions for commands and evaluation semantics. GitNova's suggested uses.
| Source | Suggested use | Corresponding project workflow |
|---|---|---|
| GitNova | Watch AI-versus-game demonstrations | Run the supplied checkpoint with rendering |
| GitNova | Compare per-level and continuous completion | Select saved-level evaluation or continuous progression |
| GitNova | Resume PPO training and inspect curves | Continue from the checkpoint and open TensorBoard logs |
The captured social results concern broader Street Fighter AI activity. Chilr357's X post names Street Fighter II Turbo and promotes the Chilr Productions channel; the captured text does not name LYiHub/pub-street-fighter-ai. The supplied YouTube transcript contains character dialogue. These records help explain why a search result needs an entity check before it enters a repository review. The source must identify the relevant project before its gameplay result can be attached to this model. Captured X post, captured video transcript.
What happened when we ran it
Our November 14 sandbox run at commit 64bbf61 completed installation in 47 seconds and the build step in 1 second. It recorded 78 dependencies and 5,861 MB on disk. The configured sandbox had 3 CPUs, 8 GB RAM and the image label ghcr.io/astral-sh/uv:python3.12-bookworm. The checkout contained 25 files, approximately 897 source lines and 65.8 MB. These are our measurements, rather than upstream performance claims.
| November 14 sandbox observation | Recorded result |
|---|---|
| Revision | 64bbf61 |
| Configured resources | 3 CPUs, 8 GB RAM |
| Image label | ghcr.io/astral-sh/uv:python3.12-bookworm |
| Checkout | 25 files, approximately 897 source lines, 65.8 MB |
| Install | Succeeded in 47 seconds; 78 dependencies recorded |
| Disk footprint | 5,861 MB |
| Build | Succeeded in 1 second |
| Automated tests | Skipped: no test script or target |
| Dependency audit | pip-audit reported 0 known vulnerabilities |
| Repository signals | 0 CI workflow files, no Dockerfile, no tests directory |
The separate November 15 attempt failed its safety step because the harness required a Compose file and found none. Its error named compose.yaml, compose.yml, docker-compose.yaml and docker-compose.yml. The run summary nevertheless said the project had deployed with its own Docker Compose and every port bound to 127.0.0.1. Those records conflict. The detailed failure takes precedence here: this attempt stopped at the Compose prerequisite. Upstream documents a local Python workflow, so this was a deployment-harness requirement.
The teardown record reports "teardown: ok" after that attempt. The failed prerequisite and the cleanup outcome both belong in the account; neither should disappear behind the generic deployment summary. Separately, the November 14 footprint gives readers a concrete planning figure: the recorded environment occupied 5,861 MB alongside a 65.8 MB checkout. Budget disk space for the environment as well as the source before arranging repeated experiments.
The harness skipped automated tests because it found no test script or target. Upstream's main/test.py has a different job: it evaluates gameplay. A repository can therefore contain that file while lacking the automated regression target sought by the harness. The table preserves both the successful setup steps and the skipped check, rather than treating the filename as a passing software test. This distinction matters when deciding what a later code change needs to exercise.
Where people get stuck: ROM setup and evaluation modes
The README requires a legally obtained US game ROM and documents SF2_ROM_PATH as the way to specify its absolute path. It also accepts data/street-fighter-ii-special-champion-edition-usa.md or a ROM already imported into Stable-Retro in the active Python environment. The twelve state files and two JSON configuration files live in data/. The program reads those project files directly, so the documented setup keeps them in the checkout. ROM and environment instructions.
| Obstacle | Documented route | What that selects |
|---|---|---|
| Game ROM is absent | Obtain it legally and set SF2_ROM_PATH | Supplies the game asset separately from the code |
| Evaluation should run without a window | Use --no-render with --device cpu | Headless CPU evaluation |
| The question concerns continuous completion | Use --no-load-level-saves | Consecutive progression from the first level |
| An older tutorial asks for library-file replacement | Follow this project's data/ instructions | Direct use of local state and configuration files |
The README documents these two commands for different evaluation questions. The first uses the default saved-level mode; the second requests continuous progression. In saved-level mode, --episodes 1 means one evaluation pass across all twelve levels. In continuous mode, it means one attempt. Preserve the selected command with the checkpoint and result so that another reader can interpret the outcome without guessing which starting conditions were used. Evaluation commands and parameter meanings.
python -m main.test --episodes 1 --no-render --device cpu
python -m main.test --episodes 1 --no-load-level-saves
The older street-fighter-ai instructions describe copying configuration files into the emulator's game directory. The current project's README explicitly says its data files are read directly. Both repositories feature Ryu and share a training lineage, which makes this an easy place to follow the wrong instructions. Match the setup recipe to the repository name and checkout before changing emulator files. The evaluation command alone does not describe those surrounding setup choices. Older setup instructions.
Training defaults use 768 emulators
The README's default training configuration uses 64 environments per level, or 768 emulators in total. It specifies 98,304 samples per update and a total training target of 700 million steps. Its suggested smaller starting command uses one environment per level and a batch size of 256. These figures describe the author's training configuration. They explain why running the bare training command commits to a much larger workload than inspecting the supplied checkpoint. Training defaults.
The documented smaller training example is below. The repository also supplies logs and model weights, so studying an existing policy and training a new policy are separate workflows. Keep changes to the reward calculation, action mapping and saved opening states alongside any new checkpoint. Those settings define the task being learned; changing them can make two results answer different questions even when both outputs are described as Ryu playing the same game.
python -m main.train --envs-per-level 1 --batch-size 256 --log-dir runs/ryu
The implementation description specifies 27 discrete actions, with each action corresponding to four emulator frames of button input. Images are processed into an 84×84×3 model input. Rewards depend on health changes, knockouts and a time penalty. These details give a student concrete components to inspect: what the agent sees, what it can do and what the training process rewards. They also provide a more useful reading path through the code than beginning with an overall success claim.
License and game assets have different sources
The project is published under Apache License 2.0, while its README requires the game ROM to be obtained separately through legal means. Keep the repository's code license and the commercial game asset's provenance separate when sharing an experiment. The published project license is the source for using its code under those terms; the ROM instruction describes an additional asset needed to run the game environment. Project license and ROM guidance.
GitNova's discovery page explicitly says its star-growth assessment does not determine whether a project is safe to run. That distinction helps interpret badges and discovery scores: they describe the thing their methodology measures. Here, the concrete dependency result is the pip-audit outcome recorded in our run table. Preserve its tool name and scope when discussing it, rather than replacing a specific advisory check with a general label about software trustworthiness. GitNova's assessment scope.
Chinese documentation explains the evaluation protocol
The supplied target README is in Chinese and explains both saved-level evaluation and continuous progression. Its command examples and argument tables provide entry points for an English-speaking Python developer, but the surrounding prose determines how to interpret output. In particular, continuing after a saved-level loss and ending a continuous attempt on defeat produce different completion measures. Translate those explanations together with the commands before using the project in a classroom or writing up results. Target README.
The older repository provides an English README describing its own final-boss experiment. It is useful background for that design and its overfitting discussion. The current README establishes the lineage by linking the old project and describing an expansion from the final boss to all twelve levels. Read the two documents together for history, while keeping each repository's commands, checkpoint paths and evaluation task attached to the project they describe. Older English README.
pub-street-fighter-ai vs street-fighter-ai and Stable-Retro
The older street-fighter-ai targets the final boss; Stable-Retro exposes classic games as reinforcement-learning environments. Those roles create a useful choice between studying an existing agent and building an experiment around an environment library. The target project supplies the Ryu checkpoint and twelve-level evaluation structure discussed here. Stable-Retro is also one of its dependencies, so using the library directly moves the policy and experiment design into your own project. Older project README, Stable-Retro README.
| Project | Documented role | Choose it when |
|---|---|---|
| LYiHub/pub-street-fighter-ai | Supplied Ryu model, training logs and twelve-level evaluation modes | You want to examine this policy and its progression tests |
| linyiLYi/street-fighter-ai | Earlier final-boss agent with save-state overfitting discussion | You want the narrower experiment and its English explanation |
| Farama-Foundation/stable-retro | Classic games exposed as Gymnasium environments | You want to supply your own policy and experiment design |
The older README describes checkpoints that increasingly dominate the saved first round while losing generalization. That discussion supplies a concrete reason to record starting conditions and evaluation mode. Its checkpoint descriptions belong to that older experiment. For the target project, the useful comparison is structural: the newer README separates evaluation across supplied level states from one continuous attempt, giving readers two explicit ways to investigate performance rather than a single ambiguous completion label.
How to read discovery summaries and activity records
GitNova labels its description an AI-generated summary, while OpenPulse describes its score as recent activity rather than project quality. The captured OpenPulse period runs from October 11 to November 8, 2026, with 0 commits, 0 merged pull requests and 0 active contributors. GitHub metadata observed November 15 records the last push as October 10, 2026. These dated records describe repository activity during a particular period. GitNova summary, OpenPulse activity snapshot, GitHub repository metadata.
The primary README is the source for the author's twelve-level capability claim and the distinction between evaluation modes. A discovery summary repeating that claim is still describing the same project claim. The current README also resolves the relationship to the older repository directly, through its old-project link and expanded training scope. Keep that primary-source account ahead of search snippets when deciding which setup instructions, model files and results belong together.
Questions people ask
The supplied questions concern a follow-up episode, building Street Fighter AI and playing against humans. The target README answers the implementation question with PPO, NatureCNN, image observations and health-derived rewards. Issue #1 supplies the episode request, while the broader community records supply the other questions. Together they identify useful reader concerns without treating a social question as a performance result or turning an episode request into a development commitment.
Will the creator make another episode about the project?
Issue #1 contains a request for another episode and was captured open with 0 comments. That records audience interest in a follow-up. The practical next step for a developer is to work from the existing README, checkpoint and logs rather than attach a delivery date to the request. The issue's subject is another episode, so it should also stay separate from any assessment of how technical troubleshooting is handled. Captured episode request.
How do developers build AI for Street Fighter games?
This project documents PPO training with a NatureCNN policy, game-image observations, 27 discrete actions and health-based rewards. Its supplied checkpoint and logs make those design choices concrete places to begin reading. A captured Facebook post asks how to build Street Fighter AI; the target README supplies the specific example discussed here. Start by tracing one observation through preprocessing, an action through its button sequence and a health change through reward calculation. Project implementation description, community implementation question.
Can a Street Fighter AI beat a human player?
The target README's evaluation modes run Ryu against game opponents. The broader question about beating a person appears in the research synthesis, but it describes a different evaluation task. For this repository, use the supplied saved-level and continuous modes to study the documented experiment. Human matches would require their own recorded setup and outcomes; the evidence boundary for those matches is included with the other outstanding measurements below. Target evaluation documentation.
What we have not tested yet
The target recommends Python 3.10, while the supplied Stable-Retro README states support for Python 3.11 through 3.14. The target also reports author validation with Python 3.10.20 on macOS Apple Silicon using CPU and MPS. The supplied evidence lacks the dependency pin and runtime logs needed to determine compatibility. Neither version choice has independent validation here. Before choosing an interpreter for reproduction, establish which Stable-Retro version the target environment uses and reconcile its requirements with the target's setup instructions. Target setup guidance, Stable-Retro Python support.
Our recorded work contains no per-level wins, continuous-clear rate, human-match result or training reproduction for commit 64bbf61. It also supplies no measured inference speed, training memory, power consumption or scaling curve. The command examples above are documented upstream examples, not newly executed corrections. The pack contains no screenshot records or hands-on gameplay question-and-answer results. The image label records sandbox configuration rather than the actual Python or operating-system version, and the exact install and build commands require raw toolchain logs.
Windows, Linux and Apple MPS gameplay compatibility are outside the completed measurements. The disk record does not allocate space among packages. The dependency audit does not assess checkpoint provenance, application security or every possible vulnerability. The captured X post and video do not supply a target-specific reproduction, and the supplied issue provides no technical support exchange. These gaps explain why installation, discovery activity and author platform statements cannot be combined into a gameplay reliability judgment.
All four rating dimensions are N/A. Installation completed, but the record stops short of a working ROM-backed game; the full instructions have no end-to-end result; the issue record offers no technical support response; and gameplay reliability has no independent measurement. A useful next result would pair saved-level evaluation with a continuous attempt using the same checkpoint and legally obtained ROM, preserving commands, dependency versions and outcomes together. That would answer the review's central question more directly than assigning numerical scores to missing evidence.


