Build this website with blocks
Try another way to build: snap together HTML, CSS and behavior blocks, change their fields, and watch your website update. Start with this lesson’s project or try a code example below.
Want to keep what you build? Web Studio holds a drawing, blocks and code in one project that you can share on the class site and publish as your own website.
The Flash Era: What Happened to Browser Games
For roughly fifteen years, most of the games, cartoons, and interactive art on the web ran inside a single browser plugin. Then it was switched off on purpose. This lesson explains why that happened, what the open web built to replace it, and how people keep old interactive work playable.
You will not write code in this lesson. You will read, compare, and take notes. The reason this sits between your project studio and your creative lab is simple: you are about to make things that live in a browser, and browsers change.
By the end you can explain
- What Flash actually was — a tool and a plugin, not one thing.
- Four honest reasons it was retired.
- Which open web technology took over each job.
- The difference between emulating something and having the right to republish it.
Keep a notes file open. You will be asked to write three short answers at the end.
What Flash actually was
People say "Flash" as if it were one program. It was two things that worked together, and you cannot understand the ending without separating them.
1. An authoring tool. A designer opened Macromedia Flash — later Adobe Flash Professional, and still sold today under the name Adobe Animate — and drew artwork on a stage. The artwork was vector: shapes described by points and curves rather than a grid of pixels, so a character stayed sharp at any size and the file stayed small, which mattered enormously on slow home internet. Underneath the stage was a timeline of numbered frames. You drew a pose on frame 1, another on frame 20, and the tool filled in the frames between. Then you attached code written in ActionScript to make things respond to clicks and keys.
2. A browser plugin. The tool exported a single compiled file with a .swf extension. A .swf is not a web page and a browser cannot read it. To play one, a visitor installed Flash Player, a separate piece of software that plugged into the browser and took over a rectangle of the page.
That combination is why the 2000s looked the way they did. One runtime, made by one company, behaved almost identically in every browser — at a time when the browsers themselves disagreed about nearly everything. A creator could ship animation, sound, mouse and keyboard input, and saved game state as one file, and be reasonably confident it would look the same for everyone who had the plugin. Whole genres of work — animated shorts, physics puzzles, tower defense, music toys, school-computer classics — existed because one person could build and distribute all of that alone.
The markup that embedded it looked like this. Notice that the page is only a container; nothing about the actual game is written in HTML.
<!-- A typical 2000s embed. The page hands a rectangle to the plugin. -->
<object type="application/x-shockwave-flash" data="game.swf" width="640" height="480">
<param name="movie" value="game.swf">
<p>You need the Flash Player to view this game.</p>
</object>
Chronology: from FutureSplash to preservation
The story of Flash stretches from the early days of pen computing and dial-up modems to modern WebAssembly emulation. Explore the timeline below to see how a single proprietary tool defined twenty-five years of digital creative culture.
- 1993: FutureWave Software founded. Jonathan Gay and Charlie Jackson found FutureWave Software to build SmartSketch for pen computers. When pen tablets fail to take off commercially, FutureWave pivots toward animation for the emerging World Wide Web.
- 1995: FutureSplash Animator released. FutureWave adds frame-by-frame vector morphing to SmartSketch. Vector curves mean rich animated shorts can transmit over slow dial-up modems in kilobytes rather than megabytes. Early adopters include Disney and MSN.
- December 1996: Macromedia acquires FutureWave. Macromedia purchases FutureWave and rebrands the tool as Macromedia Flash 1.0, accompanied by the freely downloadable Shockwave Flash Player browser plugin.
- 2000: ActionScript 1.0 launches with Flash 5. Scripting turns Flash from an animation stage into a real game engine. Independent web creators gather on portals like Newgrounds, creating an unprecedented wave of user-generated browser games.
- 2004: ActionScript 2.0 and Flash MX 2004. Class-based object-oriented programming brings structured software engineering to browser games. Sites like Armor Games and Kongregate foster an explosive indie developer ecosystem.
- December 2005: Adobe acquires Macromedia for $3.4B. Adobe brings Flash into its Creative Suite and introduces ActionScript 3.0 with the AVM2 virtual machine, delivering a 10x performance boost for complex simulations and physics.
- April 2010: Steve Jobs publishes “Thoughts on Flash.” Apple's CEO explains why iOS will never allow Flash Player, citing unpatched security flaws, severe battery drain, mouse-dependency, and the risk of a proprietary middleman between web authors and the browser.
- November 2011: Adobe ends mobile Flash Player. Adobe ceases development of Flash Player for mobile devices, conceding that open HTML5 standards are the only viable path for universal mobile web experiences.
- July 25, 2017: Joint sunset announcement. Adobe, Apple, Google, Microsoft, and Mozilla jointly announce that Flash Player will reach end-of-life on December 31, 2020, coordinating a three-year migration runway for creators and businesses.
- 2019: Ruffle project begins. An open-source collective begins developing Ruffle, an emulator written in Rust and compiled to WebAssembly. Ruffle runs legacy
.swffiles natively inside modern browsers with no plugins or security risks. - December 31, 2020: Flash Player reaches end of life. Adobe permanently ceases feature updates, security patches, and distribution. Major browser engines begin stripping plugin support completely.
- January 12, 2021: Kill-switch activates. Adobe activates a pre-programmed software lock inside the final versions of Flash Player, preventing SWF playback worldwide and officially closing the plugin era.
- Present: Digital preservation keeps culture alive. The Internet Archive and Flashpoint Archive preserve over 150,000 Flash games and animations, ensuring creative digital history remains accessible and playable for future generations.
Lab: the shutdown, one moment at a time
The end of Flash was not a single day. It was an announcement, a support cutoff, and a block, spread over three and a half years. Press each button and read the result line before you continue.
Flash timeline
Choose a moment to read what happened.
Check: pressing a button changes the sentence below the row, and the button you pressed stays visibly selected while the others do not. Four presses should give you four different sentences.
Repair: if nothing changes, the page's JavaScript did not load. Open your browser's developer console and look for a red error naming web-creative-labs.js.
Copy those three dates into your notes exactly as they appear. Getting a date wrong in a history project is the same kind of mistake as a broken link: small, avoidable, and it costs a reader their trust.
Why it ended
Flash was not cancelled because it was uncool. Four pressures stacked up, and any one of them alone would probably not have been enough.
- Security. Flash Player was one program, installed on almost every desktop computer, that ran code downloaded from strangers. That is an attacker's ideal target. Serious vulnerabilities were found repeatedly, and patching them meant asking hundreds of millions of people to update a plugin — which many never did. Over time, browser makers and security teams treated an out-of-date Flash Player as one of the most reliable ways for a machine to be compromised.
- Mobile. Apple never shipped Flash Player on iOS. In 2010, Steve Jobs published an open letter, "Thoughts on Flash," arguing that the plugin was unreliable, drained batteries, was built for mouse input rather than touch, and put a proprietary layer between developers and the platform. In 2011 Adobe itself announced it would stop developing Flash Player for mobile browsers. From that point on, a Flash-only site was invisible to a growing majority of the people on the web.
- Battery and performance. The plugin did its own drawing and its own decoding, often without the hardware acceleration the browser used for everything else. On a laptop or phone, a single animated advertisement in a background tab could measurably shorten the time until the battery died. Browsers responded by pausing Flash content until you clicked it — which quietly broke the "it just plays" experience the plugin was built for.
- The open web caught up. This is the part students miss. By the mid-2010s the browser itself could do the jobs that only Flash used to do:
<canvas>for drawing and games,<video>and<audio>for media without a plugin, WebGL for hardware-accelerated 3D, Web Audio for real-time sound, SVG for vector art, and CSS animation for movement. Once the standard, no-install path could do the work, a plugin with three other problems had no argument left.
Notice the shape of this story. The replacement was not a better plugin from a different company. It was a set of open standards that any browser maker could implement and nobody had to install. That is the pattern to remember when someone offers you a closed shortcut for your own work.
What replaced each capability
Read this table across, not down. Every row is a job somebody needed done, and the third column is what you will actually use in the next lesson.
| The job | The Flash way | The open web today |
|---|---|---|
| Drawing and games | Stage and timeline compiled into a .swf, played by the plugin | <canvas> with the 2D context, drawn by your own JavaScript loop |
| Vector artwork | Flash vector shapes inside the .swf | SVG — vector graphics written directly into the page and styled with CSS |
| Video | A Flash video player embedded on the page | <video>, a built-in element with real browser controls |
| Sound and music | Audio compiled into the .swf, triggered by ActionScript | <audio> for playback, the Web Audio API for timing and effects |
| Hardware 3D | Stage3D, added late in Flash's life | WebGL, and now WebGPU where it is supported |
| Animation | Frame-by-frame and tweened timelines | CSS animations and transitions, or a JavaScript loop when you need control |
| Programming | ActionScript, which ran only inside Flash Player | JavaScript, which every browser runs natively |
| Getting it to a player | Ask the visitor to install a plugin first | Nothing to install — the browser is already the runtime |
Preservation is a real discipline
When the plugin stopped, millions of finished creative works stopped with it. Not lost files — the files mostly still exist — but files with nothing left that could run them. People took that seriously, and the work of keeping them playable has a name and a set of methods.
Three outcomes, not one
- Emulation. Write new software that imitates the old runtime closely enough to run the original file unchanged. Ruffle is the well-known open-source Flash emulator, and it is why some old animations play in an ordinary browser today. Compatibility varies: some content runs perfectly, some runs with glitches, some does not run at all, and coverage keeps changing as the project develops. The Internet Archive uses this approach to make archived Flash items playable on its site, and the Flashpoint project takes a different route — it collects games and animations along with the software needed to launch them, so they run on your own machine.
- Porting. Rebuild the work with today's technology. A person reads the original, recreates the art and the behavior in HTML, CSS, JavaScript, and canvas, and ships something new that feels like the old thing. This is honest, durable work, and it is expensive: it is a rewrite, not a conversion.
- Loss. The default. Nobody kept the source, nobody archived the file, the host shut down, and it is simply gone. Most of what was made in the Flash era is in this category, and no amount of emulator progress brings back a file that no one saved.
"Just rename it to HTML" is not a thing
A .swf is a compiled binary: the artwork, the timeline, and the ActionScript were packed into a format designed for one specific player to read. HTML is text a browser parses. Changing the letters after the dot changes nothing inside the file — the browser will simply fail to make sense of it. Converting real Flash content means either emulating the old runtime or rebuilding the work by hand. When Adobe announced the end in 2017 and told developers to migrate, migration meant that rebuild.
Running something is not permission to republish it
This distinction matters and people get it wrong constantly. Ruffle is open-source software, and its license covers the emulator. It says nothing about the game, the music, the character art, or the animation you are running through it. Those are somebody else's copyrighted work, and they still belong to whoever made them.
So: running an old file on your own computer to study it is one thing. Copying that file onto your own website, or lifting its art and sound into your project, is republishing someone else's work — and it needs their permission, or a license that clearly allows it, or it should not go up. Archives like the Internet Archive operate under their own policies and take down what rights holders ask them to. If you want an old game on your site, the safe versions are: link to an archive that already hosts it, or rebuild it yourself and credit the original as inspiration.
Write the rule in your notes in your own words: a tool that lets me open something does not give me the right to publish it. That sentence applies to emulators, to fonts, to music, to images you found in a search, and to code you copied from a tutorial.
Reflect: will your work still run in 2046?
Answer these three in your notes. Full sentences. There is no answer key — this is the thinking the rest of the pathway rests on.
- Name something you or your friends are making right now that will probably be unplayable in twenty years. Say specifically what would have to stop existing for it to break — a company, an app, an account, a server, a file format, a login.
- What makes work survivable? Compare a folder of plain HTML, CSS, JavaScript, PNG, and text files against a project that lives only inside one company's editor. Which one can another person open in 2046 with no account and no permission? Why?
- What would a future person need from you to bring your project back? List the files, the instructions, and the credits you would have to keep beside it. Then check your own project folder: is any of that missing today?
Three habits come out of those questions, and they are the whole preservation lesson in practical form. Use open formats that many programs can read. Keep plain files in a folder you control, not just work saved inside a service. Write documentation — a README that says what the project is, how to run it, what the controls are, and what you did not make yourself. You will do exactly that in the next lesson and again when you publish.