244 pixel art effects, and not a single PNG in the repo

Patch's pixelfx ships game VFX as small programs instead of sprite sheets — then teaches Claude Code to author new ones like a picky pixel artist.
There is a quiet convention in game development that visual effects are assets. You buy a pack of PNGs on itch.io — there are 1,013 results under pixel art and VFX alone — you import the frames, and if the fire is the wrong shade of orange, you buy a different pack. The repo patch-gg/pixelfx takes the opposite position: an effect is a small piece of code, and the sprite sheet is something you render on the way out the door, if you want one at all.
The library holds 244 effects across 22 categories — fire, explosions, lightning, arcane, holy, shadow, weather, UI, pickups, transitions, even a critters section with bats and fish schools. Every one is a JavaScript file. There are no images in the source, no atlases, no baked frames. The repo is made by Patch, and it is the rare open-source project where the boring architectural decision is also the whole point.
Effects as programs, not pictures
The core split is between two kinds of effect, and it maps neatly onto two kinds of motion. Pure effects — a campfire, a portal, a coin spin — export a function of time: given t seconds, produce the frame. Because the frame comes from t alone, loops tile with no seam, which is the classic failure mode of hand-drawn looping effects where the last frame almost matches the first. Simulated effects — debris, bouncing sparks, rolling smoke — export a constructor and step real particles at 120 Hz, so the physics lands the same at any frame rate your game runs.
Rendering goes through two buffers. A color buffer takes opaque, dithered, or truly translucent pixels; a light buffer takes additive glow, composited on top. That separation is why hot things look hot — a fireball’s core reads as blinding not because someone painted it white, but because its light is literally added to whatever’s behind it. It’s the same instinct that makes additive blending the default in shader-based VFX, transplanted onto a low-resolution pixel grid where dithering does the work that blur does elsewhere.
Everything is seeded. Every random number in an effect derives from a seed you can pass in, so frame 40 of an explosion is identical every time you render it — which is what makes deterministic export, regression checking, and reproducible bug reports possible. And every effect takes a palette: a dark-to-bright ramp of hex colors. A fire can burn blue and a heal can glow pink without touching the effect’s code, which is the difference between recoloring an asset and re-authoring one.
For engines that want nothing to do with JavaScript — Godot, Unity, GameMaker, Defold, LÖVE, Bevy — the library renders itself out as sprite sheets: a transparent PNG grid plus an Aseprite-style JSON carrying frame rects, durations, and a meta.pixelfx block with fps, loop, columns, and pivot. Phaser’s atlas loader and the Aseprite importers for Godot and Unity read it directly. The sheet is a build artifact, not the source of truth. That distinction is the entire thesis.
The sticker problem, and the dummy who solves it
The more interesting half of the repo is what it calls acting. The README puts its finger on a failure mode every pixel art game has shipped at least once: an effect on its own looks like a sticker. What sells a hit is the body around it — the wind-up that telegraphs the attack, the freeze on contact, the target rocking back, the recovery. Sixty-one of the effects involve a character, and twelve full moves chain effects into complete attacks from wind-up to recovery.
The timing is plain data: a list of poses with timestamps, and hit definitions that say when to freeze the action, how far to shake the camera, how hard to push the target. Negative timestamps mean the character starts moving before the effect’s first frame — the wind-up precedes the flash, the way it does in animation that feels good. The freeze on contact is the detail that separates amateur pixel combat from professional: everything stops for a fraction of a second at the moment of impact, and the library’s update loop holds still by itself during that window.
Crucially, this timing data is exported into the sprite sheet JSON too. If you’re using the effect in Unity with your own character, you can read the wind-up duration and freeze times and drive your own animations from them. The effect alone still works as a plain sprite sheet; the acting is a layer on top, not a lock-in.
The character himself is a piece of engineering worth pausing on. He’s a grey, deliberately neutral dummy — neutral so the eye goes to the move and any effect’s colors read against him. Under the hood he’s a 3D skeleton with fixed-length bones, pelvis to spine to shoulders, rendered down to a few flat tones with one clean ink line. That is the Dead Cells pipeline: Motion Twin’s artists used 3D character models downsampled and aliased at render time to produce sprite sheets that read as hand-drawn pixel art. As the VFX Apprentice interview with 2DFX artist Devlyn Daubenschmidt puts it, the answer to “is Dead Cells pixel art?” is both “absolutely not” and “yes, yes it is.” Pixelfx borrows the trick so the dummy can twist, bend, and actually turn around, with depth deciding which limb is in front — things that are miserable to hand-draw across dozens of poses.
There’s a hybrid frame rate hiding in there too: poses hold on 12 fps steps, the way hand-drawn sprites do, while particles run at full rate. That mix — chunky body motion, fluid effects — is characteristic of the pixel art that people actually praise, and it’s the kind of thing that’s hard to articulate and easy to encode.
Effects drawn on the body, like frost or a scan line, are written against the standing character and follow him wherever he goes: each pixel of a pose knows which pixel of the standing body it came from. The skeleton is exposed too — a function returns every joint of a pose in 3D, so you can hang your own things on it.
The lineage: code is clay
Pixelfx is honest about where its method comes from. The approach is Hugo Duprez’s, laid out in his essay on making pixel art effects with Claude: code is clay, trust your eyes, feed your references. Duprez’s open-source effects at Sprite Fusion set the bar, and pixelfx’s simulation core adapts his MIT-licensed code directly. The frame shape is deliberately identical to Sprite Fusion’s VFX format, so both libraries can draw into a single frame — an unusually gracious interoperability decision in a space where asset packs are typically walled gardens.
Sprite Fusion’s own library has since grown an AI angle: 25 effects with an MCP server so Claude Code or Codex can read the library, build effects into your game, and synthesize new ones from the closest existing pieces. Pixelfx is that idea taken to library scale — 244 effects instead of 25 — plus a Claude Code skill that encodes the authoring loop itself.
The skill is the part that will draw the attention. Installed as a plugin, it teaches Claude Code to find, use, export, and make effects. The examples in the README are telling: “make five takes on a coin pickup sparkle and show me the best two,” or “this hit effect feels floaty, make it punchier.” That is not a code-generation request; it’s a critique request. The skill’s method, per the README, is to work the way a picky pixel artist would: draft, render, look, refine.
What makes this more than a prompt gimmick is that the repo built the instruments first. There’s a checker that flags spills, seams, unseeded randomness, and slow frames. There’s a renderer that produces contact sheets, GIFs, and MP4s, because motion bugs don’t show in still samples. The refine step has something concrete to look at and something concrete to catch. An agent iterating on a visual artifact needs eyes and a quality gate; pixelfx supplies both, which is precisely the infrastructure most “AI makes your art” projects skip.
The market it lands in
Context matters here. The itch.io pixel art VFX tag is a graveyard of good intentions: a thousand packs, most a few dollars, most hand-drawn frames you can recolor only by opening an image editor. The free options are real — PVFX Foundry offers 101 CC0 effects with sprite sheets and JSON — but they’re all the same shape: finished pictures. The particles-and-pixel-art tag skews toward engine-specific particle system packs, which are live but locked to Unity or Godot’s particle paradigms.
Pixelfx occupies the gap: live, parameterized, engine-agnostic at the source level, and exportable to static frames when you need them. MIT licensed, code and effects both, commercial use included — with the small caveat that the Patch Pixel font in the gallery is not covered. For a solo developer, the pitch is essentially: stop buying fire, start compiling it.
One unavoidable annoyance: the name. “Pixel FX” is also an established company making FPGA video scalers and HDMI mods for retro consoles, and searching for this library will surface their shop, their merch, and their Discord before it surfaces a single campfire. The collision is nobody’s fault and mildly everyone’s problem.
The rough edges
The README is candid about the seams, which deserves note. Effects drawn on the body paint the stock dummy — if you ship those, you need to regenerate them against your own character. The browser path is first-class; every other engine gets the baked-sheet path, which trades away the live palette swaps and seeded determinism that make the source library interesting. And the whole authoring skill rests on a model’s ability to actually see — the draft-render-look-refine loop is only as good as the look step, and whether a language model’s judgment of “punchy” matches yours is an empirical question each user answers for themselves.
The deeper open question is whether effects-as-code catches on beyond the Claude Code crowd. Sprite Fusion’s bet on agent-facing VFX libraries suggests the timing is right: as more game work flows through agents, libraries that agents can read, run, and extend have a structural advantage over zip files of PNGs. Pixelfx is early evidence of what that looks like when someone sweats the craft — the 12 fps pose holds, the freeze frames, the ink line on the dummy — instead of just the plumbing.
It’s a library of 244 small programs that draw fire, and a skeleton that knows how to flinch. That’s a strange thing to be excellent at, and it is.
Sources
- Pixel Effects - Pixel Art Meets VFX and Character FX
- Best practice for particle effects in 2D pixel art games
- Pixel FX: Morph 4K Video Scaler and Retro G.E.M. HDMI Kits
- Top game assets tagged Pixel Art and Visual Effects (VFX)
- Top game assets tagged Particles and Pixel Art
- Merch
- Open Source Pixel Art VFX for your game
- Hello guys! What are some good examples of games with ...
- SHOP
- Procedural Pixel Art: Retro VFX with Shaders
- Best practice for particle effects in 2D pixel art games - GIFs
- Pixelfx