Ruffle - Adobe Flash Player emulator

Ruffle is an Adobe Flash Player emulator essential for running legacy Flash content (games, animations, applications, and SWF banners). It operates as a standalone application on all operating systems (including Windows, macOS and Linux) and integrates into browsers via WebAssembly.

Ruffle provides separate builds for Windows, macOS, and Linux that work like regular programs: simply run the executable and open the desired SWF file within it.

Ruffle leverages the memory safety of the Rust language and the sandbox of the modern browser. This allows potentially risky old content to run without the risk of system infection or data leakage.

The emulator combines support for both the older AVM1 (ActionScript 1 and 2, used until 2006) and the more complex AVM2 (ActionScript 3). This is necessary for the correct operation of virtually any Flash content, from early 2000s animations to complex games and applications released just before the technology was discontinued.

Download links:

Windows (64-bit) macOS Linux (x86_64) Linux (ARM64) Flatpak

All links lead to official sources: builds for Windows (x86_64), macOS (universal for Intel and Apple Silicon), Linux (x86_64 and ARM64 for Raspberry Pi and ARM devices) are distributed through the Ruffle project's GitHub repository, while the Linux version in Flatpak format is available through the official Flathub catalog with digital signatures and application isolation.

Contents:

Key Features of Ruffle

Integration via WebAssembly. For browser operation, Ruffle compiles to WebAssembly (Wasm) — a low-level bytecode executed within the browser's isolated sandbox with near-native performance. This allows the emulator to load and process complex Flash graphics and logic without the need to install outdated and insecure NPAPI/PPAPI plugins.

Automatic Detection and Polyfilling of Flash Content. The web version of Ruffle includes a JavaScript detector that scans the page's DOM structure for object, embed, and applet elements, as well as files with the .swf extension. Upon detecting such content, Ruffle automatically replaces it with its own player, transparently fixing the page for the user and restoring Flash element functionality.

Dual Mode of Operation (Desktop Application and Web Extension). Ruffle offers users flexibility: it can be used as a standalone desktop application for local SWF playback (simply associate files with the Ruffle executable) or as a browser extension that integrates into the web browsing environment, providing Flash support on any site.

Support for ActionScript 1.0 and 2.0 (AVM1). Ruffle implements the AVM1 virtual machine, ensuring compatibility with a vast body of content created before 2006 and up until 2013. The current compatibility level for AVM1 language constructs reaches 99%, and for APIs — 81%, guaranteeing the correct operation of the vast majority of early Flash games and animations.

Support for ActionScript 3.0 (AVM2). For content created after 2006, Ruffle includes an implementation of AVM2. Although work on compatibility is actively ongoing, the emulator already provides a sufficient level of support to run many complex games and applications written in ActionScript 3, constantly expanding API coverage and language capabilities.

Safety at the Rust Language Level. One of Ruffle's main architectural advantages is its use of the Rust language. Rust guarantees memory safety at compile time, completely eliminating entire classes of vulnerabilities that plagued the original Adobe Flash Player, such as buffer overflows, double frees, and use-after-free errors.

Isolation within the Browser Sandbox. When operating in a web environment, Ruffle (via WebAssembly) fully complies with the browser's security policy. This adds an extra layer of isolation: the emulator has no direct access to the user's file system or other system processes, making its exploitation extremely difficult compared to the classic Flash plugin.

Efficient Memory Management. Unlike the original Flash Player, which used garbage collection with non-deterministic pauses, Ruffle inherits Rust's strict ownership model. This allows for more predictable memory usage, reducing fragmentation and eliminating memory leaks that often led to unstable browser behavior.

Command Line Support. The desktop version of Ruffle offers a fully functional command-line interface. Users can run the emulator with parameters, for example: ruffle filename.swf for a local file, or ruffle https://example.com/filename.swf to play an SWF from a URL. The command ruffle --help displays a comprehensive list of all available arguments and settings.

Open Source Code and Development Transparency. Ruffle is distributed under the Apache 2.0 and MIT licenses. The complete openness of the source code means any developer can audit the emulator's security, contribute fixes, and participate in its development, eliminating the possibility of hidden features or vulnerabilities that could be introduced by corporate developers.

Compatibility with a Wide Range of Browsers. Thanks to WebAssembly technology, Ruffle is supported by all modern browsers, including Google Chrome, Mozilla Firefox, Microsoft Edge, Safari, Opera, Brave, and Vivaldi. This ensures a consistent experience with Flash content regardless of user preferences for browser engines (Chromium, Gecko, or WebKit).

Support for Mobile Browsers (iOS and Android). Unlike the original Adobe Flash Player, which was never officially supported on iOS and had limited support on Android, Ruffle works on mobile platforms. This allows Flash games and animations to run on smartphones and tablets directly through the mobile browser, opening access to archived content for mobile audiences.

No Configuration Required. Ruffle is designed on a "set and forget" principle. After installing the extension or launching the desktop application, the emulator requires no complex configuration. It automatically detects playback parameters such as stage size, frame rate, and interaction type, applying optimal settings without user intervention.

Protection Against Zero-Day Vulnerabilities. Because Ruffle is not a plugin, does not use outdated APIs, and its code is written in Rust with a focus on security, it is immune to attacks that were characteristic of Adobe Flash Player. This makes it an ideal solution for organizations that must maintain access to legacy content but cannot risk system compromise.

Compatibility with Various Installation Methods. Ruffle offers several deployment methods. Web developers can install it as a static extension in Chromium-based browsers (via developer mode) or as a temporary add-on in Firefox (via about:debugging). Integration via simple JavaScript code insertion on the server side is also available.

Playback of Both Online and Offline Content. The desktop version of Ruffle allows opening and playing SWF files saved locally on the computer. This makes the emulator an indispensable tool for collectors, archivists, and researchers working with local archives of Flash games and animations.

High Rendering Performance. Ruffle uses modern graphics APIs (such as OpenGL, Vulkan, DirectX, or WebGL) through cross-platform libraries. This provides hardware acceleration for rendering vector and raster graphics, enabling smooth playback even on weaker devices where the original Flash Player might have lagged.

Active Development and Frequent Updates. The project is in active development. Releases come out regularly and include both critical bug fixes and expanded ActionScript API support. For example, recent versions have fixed edge cases in String.indexOf and lastIndexOf methods, and correctly handled negative indices in Array.indexOf.

Integration with Major Archives and Platforms. Ruffle has been chosen as the official player for Flash content playback by giants such as the Internet Archive, Newgrounds, Coolmath Games, and Armor Games. This confirms the emulator's high degree of reliability and compatibility, as well as its ability to operate under high loads in real-world conditions.

Support for Game Saves and State. Like the original Flash Player, Ruffle supports Local Shared Objects (LSO), which many games use to save progress. The emulator correctly emulates the mechanisms for reading and writing data to this storage, ensuring save integrity within the application's runtime.

Accurate Emulation of Timings and Frame Rate. Ruffle accurately emulates the Flash Player's internal timer, which is critical for game and animation logic. This ensures proper synchronization of events, sound, and object movement, preventing situations where a game runs slower or faster than the original.

Support for DOM and JavaScript Interaction (ExternalInterface). For complex web applications that used the ExternalInterface API to exchange data between ActionScript and JavaScript, Ruffle implements a compatible bridge. This allows the emulator to correctly handle function calls and data transfer, preserving the interactivity of content with the surrounding web page.

Automatic Scaling and Resolution Adaptation. When playing Flash content created for a specific resolution (e.g., 800x600), Ruffle automatically applies scaling algorithms to adapt to the current window size of the browser or desktop application. It preserves proportions and image quality, and correctly handles mouse interaction areas.

Support for Diverse Media Formats. The emulator supports decoding various media formats that might be embedded in SWF files, including MP3 for audio and video compression used in later versions of Flash. Decoding is performed via high-performance libraries written in Rust, reducing system load.

Advanced Debugging and Logging. For developers and advanced users, Ruffle provides the ability to enable detailed logs of AVM1/AVM2 virtual machine operations. This allows diagnosing compatibility issues, tracking errors in ActionScript code, and understanding the emulation's internal processes for more precise tuning.

Cursor and Interactive Element Emulation. Ruffle correctly handles cursor style changes specified by Flash content. For example, for interactive elements like LoaderDisplay, the emulator automatically changes the standard cursor to a pointer, mimicking the behavior of the original Flash player and providing familiar navigation for the user.

Support for Nightly Builds for Early Access. In addition to stable releases, the Ruffle team provides access to daily experimental Nightly builds. These builds contain the latest fixes and innovations not yet included in the stable version.

Preserving Digital Cultural Heritage. This is not just a technical function, but a fundamental goal of the project. Ruffle was created as a tool to preserve historical internet content. Thanks to its ability to work in modern browsers without compromising security, millions of Flash games, animations, and applications that would have been permanently lost after Adobe Flash Player was discontinued remain accessible for future generations.

12 Lesser-Known Technical Capabilities of Ruffle

  1. Using WGPU as the Primary Rendering Backend. Unlike many emulators that rely on legacy OpenGL, Ruffle uses the WGPU library — a modern, safe, and cross-platform graphics API. On desktop, WGPU automatically selects the most optimal low-level backend: Vulkan, DirectX 12, or Metal. In the browser, it can work via WebGPU (where available) or emulate operation through WebGL with minimal performance loss.

  2. WebGPU Support in the Browser for Maximum Performance. For users of modern browsers (e.g., latest versions of Chrome and Edge), Ruffle can use the cutting-edge WebGPU API. This provides significantly reduced shader compilation time and lower overhead compared to the standard WebGL backend, which is critical for complex 3D graphics and Stage3D applications.

  3. Fine-grained Rendering Backend Tuning (canvas, webgl, wgpu-webgl). Few people know that rendering behavior can be manually controlled. Besides the standard wgpu-webgl, there is an option to force-enable:

    • webgl — a classic backend that initializes faster and may be useful for simple content that does not require complex bitmap effects.

    • canvas — the slowest, but most accurate backend. It is the only one that correctly scales hairline strokes in vector graphics, which may appear too thick when using hardware acceleration.

  4. Emulation of Stage3D and Compilation of AGAL to WGSL. Ruffle supports not only 2D graphics but also 3D acceleration via the Stage3D (Context3D) API. Shaders written in AGAL (Adobe Graphics Assembly Language) are compiled "on the fly" into modern WGSL (WebGPU Shading Language) or GLSL. This allows running complex 3D games and applications created for Flash Player 11 and above, utilizing a full pipeline of programmable shaders.

  5. Support for fscommand for Backward Compatibility. Ruffle has retained support for the legacy but important fscommand mechanism. This allows old Flash movies (created before ExternalInterface) to interact with JavaScript on the page, sending arbitrary commands and arguments. In Ruffle's modern implementation, these commands are processed via onFSCommand, enabling functionality even for very old web content.

  6. Double Buffering for Context3D. When working with 3D content, Ruffle uses a sophisticated double buffering mechanism (back buffer / front buffer). This is a standard but critically important performance technique, allowing the next frame to be rendered in the background buffer while the current one is displayed on screen, eliminating visual artifacts (frame tearing) in dynamic games.

  7. Benchmarking Tools: ruffle_scanner and exporter. Within the Ruffle repository, there are utility tools not included in the standard build but available to developers:

    • ruffle_scanner — allows testing the emulator's compatibility with an entire folder of SWF files, generating a CSV report on parsing success.

    • exporter — a tool for batch generating PNG screenshots from SWF files, which can run in headless mode (without a GUI), useful for automated testing and creating previews.

  8. Complete Isolation via Flatpak Sandbox. For Linux users, there is an official Ruffle build in Flatpak format. This is not just an installation method, but an additional layer of security: the application runs in an isolated environment where all saves, configurations, and logs are stored strictly within the Flatpak home directory (~/.var/app/rs.ruffle.Ruffle/), without access to the rest of the system.

  9. Integration Support via Homebrew and Scoop. For experienced users, Ruffle offers advanced installation methods beyond manual download. On macOS, it can be installed via Homebrew (brew install --HEAD ruffle-rs/ruffle/ruffle), allowing automatic updates to the latest nightly build. On Windows, the Scoop package manager serves a similar function.

  10. Transparent Data Storage System (SharedObjects). Ruffle accurately emulates the Flash local storage system (LSO — Local Shared Objects). However, unlike the proprietary player, the location of these files is standardized and transparent to the user. On Windows, they are located in %AppData%\Local\Ruffle\SharedObjects\, on Linux — in ~/.local/share/ruffle/SharedObjects/. This allows manual backup of saves from old games.

  11. Configuration via JavaScript API and Global Settings. For web developers, Ruffle provides a powerful JavaScript API, allowing not just embedding the player but also controlling its state. Methods are available for programmatically loading SWF (load), controlling volume (volume), pausing (suspend/resume), and intercepting trace() outputs from ActionScript for debugging via traceObserver.

  12. Automatic Signing and Notarization of macOS Builds. In the CI/CD process, all nightly builds of Ruffle for macOS undergo code signing and notarization by Apple. This means that even unstable versions of the emulator will not be blocked by Gatekeeper as unsafe software, ensuring trouble-free operation on the latest versions of macOS where security requirements are strict.

Installing the Desktop Version of Ruffle

The desktop version of Ruffle is a native application that allows you to open and play SWF files directly on your computer, without needing a browser. This is an ideal choice for viewing local archives of Flash games and animations.

Windows (10, 11)

Method 1: Graphical Interface (recommended)

  1. Download the file named ruffle-windows-x86_64.zip (for 64-bit systems) or ruffle-windows-x86.zip (for 32-bit systems).

  2. Extract the archive contents to any convenient folder (e.g., C:\Program Files\Ruffle or C:\Users\[Your_Username]\Documents\Ruffle).

  3. To run it, double-click the executable file ruffle.exe. The application's graphical interface will open.

  4. To open an SWF file, click the Open File button in the interface or simply drag and drop the SWF file into the application window.

  5. Alternative method: Set up file association. Right-click any .swf file, select Open with → Choose another app, locate ruffle.exe and check the option Always use this app to open .swf files.

Method 2: Command Line

For experienced users, a command-line interface is available:

  1. Open Command Prompt (CMD) or PowerShell.

  2. Navigate to the folder containing ruffle.exe, or add that folder to your PATH environment variable.

  3. To run a local file, execute the command:

    ruffle.exe C:\path\to\your\file.swf

  4. To run an SWF file from a URL:

    ruffle.exe https://example.com/animation.swf

  5. To view all available command-line parameters:

    ruffle.exe --help

Method 3: Installation via Scoop Package Manager

For those who prefer automated installation:

scoop bucket add extras
scoop install ruffle

macOS

Method 1: Graphical Interface (recommended)

  1. Download the file ruffle-macos-x86_64.dmg or ruffle-macos-aarch64.dmg (for Apple Silicon M1/M2/M3) from the releases page.

  2. Open the downloaded .dmg file.

  3. Drag the Ruffle icon into the Applications folder.

  4. Launch Ruffle from the Applications folder. On first launch, the system may ask for confirmation — click Open.

  5. After the application launches, use the Open File button or drag and drop an SWF file into the window.

Method 2: Installation via Homebrew

For advanced users:

# Install the latest stable version (if available)
brew install ruffle

# Or install the latest nightly build from source
brew install --HEAD ruffle-rs/ruffle/ruffle

Method 3: Command Line

After installation via Homebrew or manually placing ruffle in /usr/local/bin:

ruffle ~/Downloads/game.swf
ruffle https://example.com/game.swf

Linux

Method 1: Installation via Flatpak (recommended for isolation)

Flatpak provides maximum security by running Ruffle in an isolated sandbox:

# Add Flathub repository
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# Install Ruffle
flatpak install flathub rs.ruffle.Ruffle

# Run
flatpak run rs.ruffle.Ruffle

Method 2: Installation via AppImage (no installation required)

  1. Download the file ruffle-x86_64.AppImage from the releases page.

  2. Make the file executable:

    chmod +x ruffle-x86_64.AppImage

  3. Run it by double-clicking or via terminal:

    ./ruffle-x86_64.AppImage

Method 3: Manual Installation (for Debian/Ubuntu based distributions)

  1. Download ruffle-linux-x86_64.tar.gz (or ruffle-linux-armv7.tar.gz for ARM devices like Raspberry Pi).

  2. Extract the archive:

    tar-xzf ruffle-linux-x86_64.tar.gz

  3. Copy the executable file to a system directory:

    sudo cp ruffle /usr/local/bin/

  4. Run from the terminal:

    ruffle

Installing Ruffle as a Browser Extension

The Ruffle extension automatically detects Flash content on any web page and replaces it with the emulator.

Important Note

Currently, the extension is not hosted in official extension stores (Chrome Web Store, Firefox Add-ons) and is under active development. Installation is done manually, via the browser's developer mode.

Installation in Google Chrome and Chromium-based Browsers

Supported browsers: Google Chrome, Microsoft Edge, Brave, Opera, Vivaldi, Arc and others based on Chromium.

Step-by-step instructions:

  1. Go to the Ruffle releases page on GitHub.

  2. Download the archive named ruffle-chromium.zip (or similar containing chromium).

  3. Extract the archive to a permanent folder on your computer. Important: Do not delete this folder after installation, as the browser will access it for the extension to work. Recommended locations:

    • Windows: C:\Users\[Your_Username]\AppData\Local\Ruffle\

    • macOS: ~/Library/Application Support/Ruffle/

    • Linux: ~/.local/share/ruffle/

  4. Open your browser and enter the following in the address bar:

    chrome://extensions/

  5. In the top right corner of the page, enable Developer mode.

  6. Click the Load unpacked button.

  7. In the dialog that opens, select the folder where you extracted the ruffle-chromium.zip archive, and click Select Folder.

  8. The extension is installed. Now, when visiting sites with Flash content, Ruffle will automatically activate.

For Microsoft Edge (Chromium): The process is identical to Chrome. Use edge://extensions/ instead of chrome://extensions/ and enable developer mode.

Installation in Mozilla Firefox

Important: In Firefox, the extension installs only on a temporary basis and will be removed after the browser restarts. This is a limitation of Firefox for unsigned extensions. For permanent use, it is recommended to use the desktop version or wait for publication in the official store.

Step-by-step instructions:

  1. Go to the Ruffle releases page on GitHub.

  2. Download the file named ruffle-firefox.xpi. When downloading, choose Save File.

  3. In Firefox, enter the following in the address bar:

    about:debugging

  4. In the left sidebar, select This Firefox.

  5. Click the Load Temporary Add-on… button.

  6. In the file dialog, select the downloaded ruffle-firefox.xpi file and click Open.

  7. The extension will be loaded and activated. It will work until you close the browser.

Tip: If you use Firefox Nightly or Developer Edition, you can disable extension signature verification via about:config, which allows permanent installation, but this is not recommended for everyday use for security reasons.

Installation in Safari (macOS)

Installing the Ruffle extension in Safari requires additional steps due to Apple's security policy.

  1. Download the ruffle-safari.zip file from the releases page.

  2. Extract the archive.

  3. Run the Ruffle.app file from the extracted folder. This will install the extension on your system.

  4. Open Safari, go to Safari → Settings → Extensions tab.

  5. Ensure the toggle next to Ruffle is set to On.

  6. The extension is activated and will work with Flash content on web pages.

Installing Ruffle on a Website (for Webmasters)

If you own a website that hosts Flash content, you can integrate Ruffle directly into your page code. This will allow your site visitors to automatically play Flash content without installing any extensions.

The Simplest Method: Using the JavaScript Player

  1. Download the file ruffle.js and the resources folder ruffle from the releases page.

  2. Upload these files to your server (e.g., into a folder like /js/ruffle/).

  3. Add the following code to the <head> section of each page where Flash content is present:

<script src="/js/ruffle/ruffle.js"></script>
<script>
    window.RufflePlayer = window.RufflePlayer || {};
    window.RufflePlayer.config = {
        // Player settings
        autoplay: "auto", // "on", "off" or "auto"
        splashScreen: false, // Disable splash screen
    };
</script>

  1. Ruffle will automatically detect all object, embed, and applet elements on the page and replace them with its player.

Advanced Setup via CDN (without downloading files)

For quick testing, you can use a CDN:

<script src="https://unpkg.com/@ruffle-rs/ruffle"></script>
<script>
    window.RufflePlayer = window.RufflePlayer || {};
    window.RufflePlayer.config = {
        autoplay: "on",
    };
</script>

Manual Initialization for Dynamically Loaded Content:

If SWF files are added to the page dynamically (via JavaScript), you can manually initialize the player:

const ruffle = window.RufflePlayer.newest();
const player = ruffle.createPlayer();
player.style.width = "800px";
player.style.height = "600px";
player.load("path/to/your/file.swf");
document.body.appendChild(player);

Verifying Functionality

After installing Ruffle using any method, you can check its operation:

  1. Desktop version: Simply open any SWF file.

  2. Browser extension: Visit the Internet Archive Flash games collection or any site with known Flash content. If the Flash element displays and plays, Ruffle is working correctly.

  3. Diagnostics: In your browser, press F12 to open developer tools. In the console, you will see messages from Ruffle confirming its activation.

Troubleshooting Common Issues

Issue Possible Solution
Extension does not activate on a site Ensure the site is not blocked in extension settings. Verify that developer mode is enabled in chrome://extensions/.
SWF file does not play or shows a white screen The current version of Ruffle may not support this specific SWF file. Check if the content is AVM2 (ActionScript 3), support for which is still being refined.
Cannot open file in desktop version Ensure the file is not corrupted. Try opening it from the command line with the --verbose flag to get detailed error logs.
Extension disappeared after restarting Firefox This is normal behavior for temporary extensions. Use the desktop version or wait for official publication in the add-on store.
Low performance in the browser Try switching the rendering backend in the extension settings. For Chromium browsers, also check if hardware acceleration is enabled in browser settings.