In 2002, I opened Macromedia Flash for the first time. Back then, I was already making simple cartoons in Paint and Movie Maker, but one day my brother told me: “That’s not serious. If you want to get good at this, use Flash.” Thanks, Vlad.

For me, Flash became a door into the world of design and software development. I started with cartoons, recorded voiceovers with the cheapest microphone I could find, and was completely fascinated by the whole thing. Flash did not come easily to me, but I could spend hours, sometimes entire days, inside it: drawing things, animating them, breaking them, rebuilding them, and trying again. Sometimes the result was complete nonsense, but the simple fact that I could make something on a screen move and react to me felt almost like magic.

Later, I went to university to study software development, finally started to understand ActionScript, and began experimenting with more than just cartoons. I made Matrix-style intros, website headers, websites that pulled data from XML, interfaces, buttons, menus, and all kinds of strange little experiments. I think that is why I fell in love with Flash. It could do a lot, but still felt surprisingly simple: you could draw, animate, and code in one place and see the result almost immediately.

By the end of university, I was making simple arcade games and platformers in Flash. Those projects were also how I earned my first money. Even the first bicycle I bought entirely with my own money existed, in some way, because of Flash.

That is probably why it was so frustrating for me to watch what happened to it later. After Adobe acquired it, the software gradually became heavier and more complicated, and eventually Flash disappeared altogether. I understand the technical reasons: memory leaks, security issues, performance, browser plugins, all of it. But what I still miss is not really the technology itself. I miss the feeling that disappeared with it. Flash was a very simple door into making something of your own.

And now, with AI and vibe coding making it possible for one person to build things that used to feel far too big or complicated, I eventually had a thought: why not try to make Flash again? Not a new Flash, and not a modern version of it. That Flash.

That is how Flosh happened. It runs on HTML5. It has a timeline, symbols, drawing tools, its own player, and even a small, simplified version of ActionScript. In spirit and structure, I tried to keep it as close as possible to Macromedia Flash MX — not as a perfect replica, and not as an attempt to bring the past back, but as a small tribute to the developers, artists, and the huge community that once grew around Flash.

When I open Flosh, I feel something close to the same excitement I felt when I spent my childhood inside Flash. The internet has become much more complicated, and the tools have become much more powerful, but sometimes I still just want to draw a circle, press F6, and make it move.

Maybe that is why Flosh exists. If it brings back even a little bit of that feeling — when there are only a few clicks between an idea and something alive on the screen — then it was worth making.

Have fun. Make weird stuff.

— Andrey Anashkin · anashk.in · iam@anashk.in

Flosh is a vector animation editor in the spirit of Macromedia Flash MX — the one from 2002, with a timeline, keyframes and a library of symbols. It runs in the browser, and there are desktop builds for macOS, Windows and Linux. The movies it makes play on any website without plugins.

Drawing

Shapes work the way they did in Flash, not the way they do in Illustrator. A line cuts a fill in two. Two shapes of the same color touching each other merge into one. A different color punches a hole. The paint bucket fills a closed area even if the outline has small gaps. Pencil, brush, line, oval, rectangle, pen, lasso, eraser, free transform, gradients and gradient transform, bitmap fills — all here.

Animation

Frames and keyframes on a timeline. Motion tweens move, scale, rotate and fade symbol instances between keyframes, with easing and motion guides. Shape tweens morph one drawing into another, with shape hints when the morph needs a nudge. Onion skin, frame-by-frame drawing, layers, folders, masks, guide layers.

Symbols and the library

Graphic symbols, movie clips and buttons. Draw something once, place it as many times as you like, edit the symbol and every instance updates. Nested timelines inside symbols, instance color effects (tint, alpha, brightness).

Sound, bitmaps, text

Import MP3/WAV/OGG and put sounds on frames — event, start, stop or stream. Import PNG/JPEG/GIF/WebP/SVG. Static, dynamic and input text with device fonts or embedded ones.

Code

Frame scripts and instance scripts in a small ActionScript-like language: stop(), gotoAndPlay(), on(release), onClipEvent(enterFrame), trace(), _root, instance names, variables. Test Movie runs the movie in a sandbox with an Output panel.

Files and output

Documents are .flosh files — a zip with a readable JSON inside. Save locally, or sign in with Google and keep projects in the cloud. Export a frame as PNG or SVG, export the movie as an animated GIF or a PNG sequence. Publish the movie as movie.json + a small player and put it on your site.

Flosh is free and will stay free. If anything ever becomes paid, it will only be the cloud — working offline and keeping files on your own computer will always be free.

A Flosh movie on a web page is two files and three lines of HTML. No plugins, no iframe, no build step.

1. Publish the movie

In the editor: File → Publish Settings… → mode Folder → Publish. You get a zip:

index.html          a standalone page with the movie (optional)
movie/movie.json    the movie itself
movie/scripts.js    only if the movie has code

Upload the movie/ folder anywhere your site serves static files, for example /movies/rocket/.

2. Put it on the page

<div id="rocket" style="aspect-ratio: 550 / 400"></div>

<script src="https://cdn.jsdelivr.net/npm/@flosh/player@0/player.js"></script>
<script src="/movies/rocket/scripts.js"></script>   <!-- only if the file exists -->
<script>
  Flosh.embed('#rocket', '/movies/rocket/movie.json', {
    scale: 'showAll', align: 'C', loop: true, play: true, menu: true
  });
</script>

One player.js per page is enough, however many movies you place. If a movie has scripts.js, load it before that movie's Flosh.embed.

The player is about 350 KB (around 100 KB over the network), loads from a CDN and is cached by the browser. movie.json is usually tens of kilobytes; frame-by-frame animation makes it bigger.

3. Options

The background is the stage color from the movie. Size the container with CSS; the stage scales into it.

4. Control it from your code

Flosh.embed returns a player:

const p = Flosh.embed('#rocket', '/movies/rocket/movie.json');
await p.ready;
p.gotoAndPlay(24);     // also: play(), stop(), rewind(), gotoAndStop(n), destroy()
p.on('trace', msg => console.log(msg));   // trace() output from the movie's scripts

Events: ready, error, trace.

5. One file instead of two

Publish Settings → mode Single gives one index.html with the player and the movie inlined. Handy for sending by email or hosting where you only have one file slot. For a page with several movies, Folder mode is lighter.