Play Super Mario from emulator state

01 · Role in the system

What Jev does here

Each request asks Jev to select a controller action, estimate whether a forward jump is useful, and score immediate danger. The harness calculates timing facts, parses RAM, advances the emulator, and records outcomes. The repository provides a runnable harness but does not publish a completed-level claim or success rate.

Why emulator RAM becomes object-level JSON first

An NES emulator exposes the game as raw memory: positions, speeds, and timers scattered across RAM addresses that carry no meaning on their own. The harness in this repository does the translation before any judgment happens, parsing RAM into object-centric JSON that names what is actually on screen. Every question sent to the model is therefore grounded in the same vocabulary the rest of the program uses, and every answer can be traced back to a concrete state description.

The translation also keeps the model's job small. Jev never sees the emulator internals or the game binary; it sees a compact state summary and answers three narrow questions: which controller macro to send, whether a forward jump is worth attempting, and how much immediate danger the frame contains. Timing facts such as distances and windows stay in deterministic code, where they can be computed exactly rather than estimated by a model.

Macro actions, and an honest absence of a win claim

The controller acts at the level of macros, such as running right and jumping a pit, rather than individual button frames. That boundary is what makes the typed choice tractable: the set of legal macros is small and enumerable, so choosing the next one is a classification among known options, the exact task shape Jev is designed for. Code still owns frame-level execution, so a wrong macro is visible, replayable, and attributable after the fact.

The record is equally defined by what it does not claim. The repository ships a runnable harness and records the outcome of each run, but publishes no completed-level result and no success rate. The directory's E2 rating reflects the inspected artifact, not a verified win, and the limitations state that plainly. For a control demo this restraint is informative: it shows the decision architecture working without pretending the hard part, a cleared level, has been achieved.

What a reproduction would need

The repository is public source in a bring-your-own-setup arrangement: it includes no game assets, so reproducing it requires a lawful local emulator and a legitimately obtained copy of the game. Once the harness runs, it logs the state summaries, the choices Jev returned, and the resulting emulator advance, which is exactly the trail an independent reviewer needs to check that live decisions, not hardcoded scripts, drove the session. Because the action space is enumerated in code, a reviewer can also list every macro the model was allowed to choose from, a level of introspection that raw-pixel control demos do not offer.

Where this control pattern generalizes

The useful question about a game demo is what transfers outside it. Games are a strict test bed for the control pattern because the state is precise, the action space is enumerable, and mistakes are immediate, which is the same shape as UI automation, machine tending, and robot supervision: anywhere code can describe the world as objects and a model picks the next legal move. This record shows the full pipeline for that shape, from state translation through bounded choice with auxiliary risk scoring to execution that stays entirely in code.

What it does not yet show is endurance. A single-session demo does not test behavior over long runs, recovery after a bad decision, or how the danger score behaves near edge cases the author never met. Those are the questions a future reproduction with logged success rates would answer, and the harness's per-run outcome logging is the mechanism that would make such a comparison possible.

02 · Control boundary

Where Jev sits

Emulator telemetry to bounded controller Choice with companion jump and danger judgments.

Code owns the loop, permissions, thresholds, validation, and side effects. Jev owns only the bounded judgments described above.

03 · Known limits

What this evidence does not prove

• The repository demonstrates the controller architecture but does not report a verified level-completion result.
• Users must provide a lawful local emulator and game setup; no Nintendo assets are included.

04 · Attribution

Public sources

This is a Community record: the project was published by a third-party community author.

• fhshaik ↗Community · github · public · checked 2026-09-18