Alien Hominid gameplay in a browser Flash release. Representative game image from the Retro Replay media library; it is not a capture from this emulator.

Ruffle

FLASH GAMES EMULATOR

Ruffle

Ruffle is an open-source emulator that runs Adobe Flash (SWF) content by reimplementing the Flash Player runtime in Rust and distributing a WebAssembly-based player for web use plus native desktop builds. It is intended for preserving interactive Flash games and animations and for embedding SWF content in modern browsers without the original Flash plugin.

Jump to download ↓Jump to setup guide ↓

Alien Hominid gameplay in a browser Flash release. Representative game image from the Retro Replay media library; it is not a capture from this emulator.

Flash gamesPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why use Ruffle

Provides a secure, sandboxed runtime for many SWF files without requiring the deprecated Adobe Flash plugin. Web (WASM) builds let sites run Flash content directly in modern browsers; native desktop builds allow running local SWF files. Active community development and source repository are available on GitHub.

BEST FOR

Best for

Preserving and replaying SWF-based games and animations on websites or locally where the SWF does not require unsupported features (complex ActionScript 3 APIs, certain multimedia or networking features). Useful for sites wanting to reinstate archived Flash content without the original plugin.

The people behind Ruffle

History & status

Ruffle is an actively developed open-source reimplementation of the Adobe Flash Player runtime with public source and documentation. The project’s primary distribution targets are a WebAssembly-based web player (ruffle as JS/WASM), browser extensions, and native desktop builds. The project origin, long-term goals, and ongoing work are documented in the GitHub repository and project docs; community contributions and issue tracking are done publicly on the repository. Ruffle does not include commercial Flash Player binaries or any proprietary Adobe firmware; it implements the Flash runtime behavior and continues to expand support for different SWF/ActionScript variants. Current limitations include incomplete coverage of ActionScript 3 and advanced Flash APIs—compatibility varies by SWF. (Sources: official repository, project website, documentation.)

What Ruffle supports

Adobe Flash SWF content (Flash games and animations)
WebAssembly web embedding (ruffle as a JS+WASM player)
Browser extension (Chrome/Edge/Safari/Firefox via extension mechanisms)
Native desktop builds for local SWF playback

Download and availability

OFFICIAL DOWNLOADS

Get Ruffle

Official downloads and distribution instructions are published on the project website and GitHub. The project provides prebuilt web builds, browser extension links, and native desktop binaries; nightly builds and release artifacts are available from the repository’s releases page. For the latest release or nightly builds, consult the official download page or the GitHub releases in the project repository.

Get Ruffle ↗

DOCUMENTATION

Official documentation

Read the official configuration, compatibility, and troubleshooting material before changing advanced options.

Read official documentation ↗

Broken or missing download? Emulator projects move and official links sometimes change. Please contact Retro Replay so the source can be verified and updated.

Ruffle setup guide

Setup note: Practical setup notes — Ruffle can be used in three common ways: embed on a website (WASM/JS), install a browser extension to replace Flash content in-page, or run the native desktop player for local SWF files. Below are setup steps and important practical details for each method.

1) Web embedding (recommended for websites): Use the project’s web distribution (JavaScript + WebAssembly) to run SWF files in modern browsers. Typical steps: 1) Obtain the official ruffle.js and ruffle.wasm files via the project’s CDN instructions or download page rather than third‑party forks. 2) Include the Ruffle script on the page and follow the documented setup API to create a Ruffle Player element and load SWF files or let the polyfill automatically replace embedded Flash. 3) Host SWF files from the same origin or configure URLLoadOptions per the documentation; note that mixed HTTP/HTTPS and cross-origin requests may be blocked by browsers. 4) Test specific SWFs; check the browser console and Ruffle debug output for compatibility notes. Consult the project documentation for embedding API particulars and configuration options.
2) Browser extension (quick site-level enablement): Install an official Ruffle browser extension if available for your browser (links and compatibility listed on the project’s downloads page). The extension will attempt to detect and replace Flash content on pages automatically. Extensions are convenient for end users but still subject to the same SWF compatibility limits as the web player.
3) Native desktop player (local SWF playback): Download the official native build for your platform from the project’s downloads or GitHub releases. Use the desktop application to open local SWF files. Desktop builds are useful for testing or running archived content offline. If a native build is not available for your platform, you can build from source (see next step). The project does not distribute any commercial Flash player binaries or proprietary Adobe files.
4) Building from source (advanced): Ruffle is implemented in Rust; building from source is documented in the repository. Typical steps: 1) Install Rust toolchain (rustup/cargo) per the official Rust instructions. 2) Clone the official repository and follow the repository’s contributor/build instructions to build the core and the frontend(s) you need (WASM target for web player, native target for desktop). 3) For the web player, build the wasm32-unknown-unknown target and generate the JS/WASM artifacts as documented. 4) Run regression tests where provided to validate the build. Follow the repository’s CONTRIBUTING and build docs for exact commands and toolchain versions — do not rely on unofficial build instructions.
5) Practical compatibility and limitations: Ruffle aims to reimplement Flash runtime behavior but does not fully support every SWF. ActionScript 1 and 2 coverage is broader than ActionScript 3; some multimedia, networking, or platform-specific APIs are incomplete or missing. If a SWF uses primitives or APIs not yet implemented, functionality may be degraded or missing. Check the project issue tracker and compatibility notes for specific titles. Ruffle does not include Adobe’s proprietary Flash Player or any game assets.
6) Security and legal notes: Ruffle runs SWF code in a sandboxed environment (WASM/browser sandbox or native process) and is designed to be safer than running the legacy plugin. However, treat untrusted SWF files cautiously. Ruffle does not change the legal status of distributing copyrighted SWF files; ensure you have rights to any commercial games or assets you host or play.

Software reminder: Ruffle is actively developed; consult the official docs/repository for the precise, up-to-date build commands, release artifacts, and compatibility statements before deploying.