Every Effect Is a Small Piece of Code
No sprite assets, no images at all. Each of the 244 effects is a JavaScript module that draws pixels from math, with seeded randomness, so frame 40 is the same every time you render it.
Illustration. Not a screenshot of the library.
On October 30, 2026, developer Patch (patch.gg) released pixelfx on GitHub: 244 pixel art effects and animations, every one a small piece of code. Fire, explosions, magic, weather, UI, pickups, critters, and twelve whole combat moves, all MIT-licensed for personal and commercial use. A live gallery linked from the repo README lets you play every effect before touching a line of code.
The adoption numbers are the reason this made the news cut. The repo was created on October 30, and by the evening of November 1 it sat at roughly 2,500 GitHub stars, with about 1,437 of them arriving in a single day, according to Early Signal’s October 31 brief. That is a remarkable amount of attention for a two-day-old pixel art library, and it says something about how hungry indie game developers are for effects they do not have to draw by hand.
A note on sourcing, stated up front: this is a launch announcement, and the feature claims come from the author’s README and the repo’s tooling, verified on the morning of publication. We found no independent hands-on review yet. Where the article says “according to the author,” it means exactly that.
What Is Actually in the Box
The 244 effects break down into 21 categories, from combat moves and explosions to weather and UI flourishes. The chart below is transcribed directly from the README’s category table.
Self-made chart. Data: github.com/patch-gg/pixelfx README table, retrieved November 2, 2026.
Every effect lives as a file in src/fx/<category>/<name>.js, and you either use the code directly or render it out. Dropping an effect into a browser game (canvas, Phaser, PixiJS, Kaplay, three.js) looks like this, per the README:
import { createFrame, clearFrame, createFx, composite } from "pixelfx";
import * as frostNova from "pixelfx/fx/ice/frost-nova";
const frame = createFrame(320, 180); // your game's pixel resolution
const fx = createFx(frostNova, { x: 160, y: 140 });
function tick(dt) {
fx.update(dt);
clearFrame(frame);
fx.draw(frame, "back"); // behind characters
drawCharacters();
fx.draw(frame, "front");
composite(frame, img.data, backgroundColor); // light added on top
ctx.putImageData(img, 0, 0); // scale up, image-rendering: pixelated
}For engines that do not run JavaScript, the repo ships render tooling: node tools/render.mjs ice/frost-nova --sheet writes a transparent PNG of every frame in a grid plus Aseprite-style JSON (frame rects, durations, fps, loop, columns, pivot), which Phaser’s atlas loader and the Aseprite importers for Godot and Unity can read. Install the code with npm i github:patch-gg/pixelfx, or copy src/core and only the effects you want.
Acted Out: Why the Hits Feel Like Hits
The cleverest part is not the 244 effects but the 73 that involve a character. An effect on its own is a sticker; what sells a hit is the body around it. The 61 character effects and 12 combat moves ship with an act descriptor: poses with wind-up, a freeze of the world on contact, and a recovery, while the target rocks back. The timing is plain data in the effect file:
export const act = {
target: { x: 58 },
poses: [
[-0.55, GUARD], // starts before the effect (t = 0 is the effect's first frame)
[-0.3, WIND_UP],
[0, CUT, "snap"], // freeze for 0.14 s on contact
[0.06, FOLLOW_THROUGH, "snap"],
[0.86, GUARD],
],
hits: [{ t: 0.06, stop: 0.14, shake: 0.18, amp: 2, push: 2.8, straw: 18 }],
};Play the whole thing with createAct instead of createFx, and you get the wind-up, the freeze, the screen shake and the recovery without keyframing any of it. This is genuinely useful design knowledge, not just a library convenience: it encodes the animation principle that impact sells through anticipation and stillness, which is exactly what fighting games have done since Street Fighter II. If you are using your own character art, the sprite-sheet export bakes the effect alone (the stock dummy is separate), and the README documents the JSON timing fields so you can sync your own wind-up and freeze frames.
The Skill: An AI That Makes Effects Like a Pixel Artist
The second headline feature is the pixelfx Claude Code skill, which teaches the agent to find, use, export, and — more interestingly — make new effects. Install it with /plugin install pixelfx@pixelfx, then ask for things like “Export the fire and explosions categories as sprite sheets for Godot” or “This hit effect feels floaty. Make it punchier.”
The method is credited openly in the README: it adapts Hugo Duprez’s approach from Sprite Fusion’s guide on making pixel art effects with Claude — “code is clay, trust your eyes, feed your references.” Duprez’s own open-source effects set the bar, and pixelfx says it is “our take on the idea at library scale, with a skill to keep going.” The generation loop is explicit and testable: draft the effect, render the contact sheet, look at it, refine, and re-render. Quality checks (node tools/check.mjs) look for spills, seams, unseeded randomness and slow frames, and motion bugs are caught by rendering the act as consecutive 12 fps steps, because “motion bugs don’t show in samples.” That sentence is worth stealing for any procedural-art pipeline.
This is part of a visible wave. Independent of pixelfx, three procedural pixel-art projects — SpriteKiln, Pixel Plays, and Jeff FX — were featured the same week in a roundup on how 3D math and AI coding tools are changing 2D game art. The underlying bet is the same one pixelfx makes: a model cannot hold a pencil, but it can edit a text spec, run a renderer, and look at the result. If that bet is right, pixel art pipelines start shipping as reviewable text files instead of opaque PNGs, and a library like pixelfx is the bootstrap.
How It Works Under the Hood
The architecture is worth a minute even if you never ship the library, because it shows how to make code-drawn pixels behave. There are two kinds of effect. Pure effects export draw(p, t, o), drawing the frame at time t from t alone, so loops tile with no seam. Simulated effects step real particles, debris and lights at 120 Hz, so sparks bounce and smoke roll identically at any frame rate. Two buffers keep color (opaque, dithered, or translucent pixels) separate from light (additive glow, composited on top); hot things look hot because of the light buffer.
Every random number comes from the effect’s seed, so frame 40 is the same every time — no flicker between loops. Effects draw in their own local space around their origin; the painter places, mirrors and rotates them. The grey dummy is a 3D skeleton with fixed-length bones rendered in flat tones with one ink line (the README cites Dead Cells’ sprite style as the reference), posed at 12 fps the way hand-drawn sprites are, while particles run at full rate. The frame shape matches Sprite Fusion’s VFX library, so both can draw into one frame.
Verdict: Try the Gallery, Steal the Loop
pixelfx earns its star count. Two hundred and forty-four effects with a consistent architecture, MIT-licensed including commercial use, exportable as code or sprite sheets, plus a documented, testable method for making your own with an AI assistant. The launch-week honesty is refreshing too: parts are adapted from Hugo Duprez’s MIT effects and Hollow Crown’s MIT source, stated in the README rather than buried.
If you are a Godot or browser-game dev, the practical move is simple: open the live gallery in the README, find an effect close to what your game needs, and either drop the module in or export a sheet. And even if you never install it, the draft-render-look-refine loop with a seeded renderer is a pipeline pattern worth copying for any procedural game art.