Skip to main content
100%

run_rom_in_GA_pages.js

✓ Published0🌍 Public
Aanemochore
Last edited Jan 16, 2023
Created on Jan 16, 2023

This visualization example automatically opens a downloaded ROM file in an emulator. It watches a GitHub Actions artifact page, waits for a ROM link to appear, and then transforms the current GitHub URL into a nightly.link proxy URL before launching the game in WebMSX. The script uses the MutationObserver API to poll for the artifact link and the window.open method to trigger the emulator. It demonstrates a workflow that bridges CI/CD artifact storage with a web-based retro gaming interface.

AI-generated description

Similar vizzes

Loading thumbnail…

SCRIPT-8

This example uses SCRIPT-8, a JavaScript fantasy console for creating retro-style games and visualizations. It renders a colorful, animated scene directly to the canvas using the console’s built-in graphics API. The visualization draws sprites and map data from JSON files, with procedural animation driven by the `requestAnimationFrame` loop. SCRIPT-8’s `pixel` and `sprite` functions handle the drawing, while its input and sound APIs are loaded but unused, focusing purely on visual output. The cassette’s empty chains, songs, and phrases files confirm a minimal, self-contained demonstration of the platform’s rendering capabilities.

FFrozenfire92
54% match
Loading thumbnail…

Gist 2d272134b57b02eb8cdd0c5904249591

This example tests the archival fidelity of a web page by loading a series of images and scripts that mimic dynamic behavior, including DOM manipulation, AJAX requests, and delayed updates. It uses JavaScript’s `XMLHttpRequest` to fetch remote images and replaces them via base64 data URLs, while `setTimeout` and scroll events trigger asynchronous content changes. The page is rendered within an iframe by the pywb web archiving tool, with a banner and rewrite layer applied. The visualization demonstrates how archived sites handle live interactions and resource loading over time.

NN0taN3rd
53% match
Loading thumbnail…

SCRIPT-8

This example is a SCRIPT-8 cassette, a self-contained JavaScript environment for creating retro-style games and animations. It demonstrates a minimal project structure with empty placeholder files for code, sprites, maps, songs, and phrases, along with a `code.js` file that defines `init`, `update`, and `draw` functions. The cassette uses the SCRIPT-8 runtime to provide a Canvas-based drawing API, with the initial state set to an empty object and no user interaction or rendering logic defined yet. The `misc.json` file records the specific iframe version of the SCRIPT-8 editor used to create this project.

TTBD
52% match
Loading thumbnail…

Gist 5c6a2f19f29de1af0c8639efdbccacc9

This visualization maps the structure of a GitHub repository, showing how markdown files link to one another across the NowSquare Landing-Page-Platform project. It uses a force-directed graph with `d3.forceSimulation` to position nodes representing individual pages, while `d3.geoPath` renders a geographic backdrop for context. The code reads landing page files from the repository and constructs the network from their internal links, styling nodes by file type. A Canvas `getImageData` call supports pixel-level analysis for hover interactions, and transitions animate the graph’s layout. The data originates from the linked markdown files, revealing content relationships and navigation paths within the platform.

Aallyraza
52% match
Loading thumbnail…

Still Drinking Gin And Juice

This example plays a trick on the Wayback Machine by loading a hidden iframe that captures the archived page’s React and ReactDOM libraries, then re-mounting a new React component inside that iframe. The visualization itself is not yet defined in the provided snippet, but the code sets up a full-screen canvas-driven animation framework using React and the browser’s native canvas and animation APIs. Images of frogs and a banner are fetched from the Internet Archive’s geocities.com captures, hinting at a playful, retro-themed visual collage. The page also manipulates browser history to disguise its origin and hides the archive’s toolbar.

NN0taN3rd
51% match
Loading thumbnail…

Gist 7232670

This example demonstrates how a single-page application skeleton is transformed from a static document into an interactive, AJAX-driven experience. The visualization shows a list of user-submitted code entries, with each entry dynamically loaded and rendered without a full page refresh. The implementation uses jQuery’s `$.ajax` method to fetch the `lucky_ajax.md` file and other resources, then updates the DOM with the retrieved content. The code also relies on JavaScript’s `Promise` API for handling asynchronous responses, and highlights the use of `XMLHttpRequest` for network communication. The data source is the downloaded application skeleton, whose structure is revealed through the fetched files. The example focuses on the interaction between client-side scripting and server responses.

EElaineYu
51% match
Loading thumbnail…

SCRIPT-8

This example loads a SCRIPT-8 cassette from a gist, using its `init`, `update`, and `draw` functions to define a minimal animation loop. The code initializes an empty state, processes input and elapsed time each frame, and renders to the canvas via the SCRIPT-8 runtime’s built-in drawing API. No external libraries are imported; the visualization relies solely on the cassette’s JavaScript and the runtime’s `canvas` context. The sparse project files (`code.js`, `map.json`, `sprites.json`) indicate a blank or placeholder project, with the `misc.json` specifying an iframe version for playback.

TTBD
50% match
Loading thumbnail…

Gist 7233762

This example shows a JavaScript application skeleton converted to use AJAX, with the updated files provided as a gist. The code demonstrates an asynchronous data-loading pattern, fetching external resources via `XMLHttpRequest` or a similar AJAX mechanism. It relies on standard browser APIs for handling responses and updating the page content dynamically. The visualization aspect is minimal, focusing instead on the structural change from a static app to one that retrieves data on demand. The author lists the modified files and includes instructions for downloading the original skeleton, making the gist a practical exercise in refactoring for asynchronous behavior.

EElaineYu
50% match