palettum.com

Palette matching is the process of remapping every pixel in an image, GIF, or video to the nearest color in a palette you choose. Instead of letting the software decide which colors survive, you supply the exact set of colors — often 4 to 256 of them — and every pixel snaps to its closest match. You'd use it when you need a strict, consistent color identity: pixel art sprites, retro game graphics, a brand-limited GIF, or a video that has to sit inside a fixed set of tones. Browser-based tools such as Palettum run this instantly on images, GIFs, and videos, with import/export of palettes and transparency preservation, so you don't need to install anything.

How palette matching actually works

The core operation is a nearest-color search. For each pixel, the tool measures the distance between that pixel's color and every color in your palette, then replaces the pixel with the closest one. Distance is usually computed in a perceptual color space rather than raw RGB, so the match looks closer to what your eye expects.

A few consequences follow directly from that mechanism:

• Output color count is capped by the palette. A 16-color palette produces an image with at most 16 distinct colors, no matter how many the source had.
• Gradients collapse into bands. Smooth shading becomes visible steps, because intermediate colors get pulled to whichever palette entry is nearest.
• The result is deterministic. The same source and the same palette always produce the same output, which is why it's useful for enforcing a house style across many assets.

Palette matching vs. color quantization vs. dithering

These three get confused because they often appear in the same workflow, but they answer different questions.

Quantization is what you use when you don't have a palette and want the tool to derive one. Palette matching is what you use when you do have a palette and want strict compliance. Dithering is a separate layer: instead of snapping a pixel to one color, it alternates between two nearby palette colors in a checker or noise pattern to suggest the in-between tone. You can combine dithering with palette matching, but it changes the look from clean flat blocks to a textured, grainy surface.

The basic workflow

The steps are the same whether you're working on a still, an animation, or a clip:

1. Import your media. Load the image, GIF, or video you want to convert.
2. Load or build a palette. Import an existing palette file, or define the colors yourself. If you're targeting a known platform or console look, use that system's documented palette.
3. Apply the match. Every pixel is remapped to the nearest palette entry.
4. Preview. Check the result before committing — this is where you catch banding, lost detail, or transparency problems.
5. Resize if needed. Scaling down before or after matching changes how much detail survives; matching a large image and then shrinking tends to look cleaner than the reverse.
6. Export. Save the result in a format that supports your needs — GIF or video for animation, PNG for stills with transparency.

Palettum supports this loop in the browser with instant preview, palette import/export, resizing, and transparency preservation, so you can iterate on the palette without a round trip through desktop software.

Common pitfalls

Transparency loss. Not every tool treats the alpha channel as a first-class citizen. If your source has transparent regions and the tool ignores alpha, those areas may fill with a palette color. Confirm that transparency is preserved before you export, especially for sprites and logos.

Banding. The fewer colors in your palette, the more obvious the steps between them. If a gradient turns into hard stripes, either add intermediate colors to the palette or apply dithering to soften the transition.

Palette size limits. More colors means a closer match but a weaker retro identity. Very small palettes (4–8 colors) give a strong, stylized look but can destroy fine detail; larger palettes (64–256) preserve more but read as less deliberate. Pick the size based on the aesthetic you're after, not the maximum the tool allows.

Wrong palette for the job. A palette tuned for skin tones will mangle a landscape, and vice versa. If the output looks muddy, the problem is often the palette's color distribution rather than the matching itself.

Animation flicker. In GIFs and video, a palette that's too small can make colors shift frame to frame as the nearest match changes. A slightly larger palette, or a palette derived from the whole clip rather than a single frame, usually stabilizes it.

When to reach for it

Use palette matching when the color set is a requirement, not a suggestion — matching an existing sprite sheet, hitting a retro hardware look, keeping a series of GIFs visually uniform, or forcing footage into a brand's limited colors. If you just want a smaller file or a general retro feel and don't care which specific colors remain, quantization is the lighter-touch choice. If you want the in-between tones to survive, add dithering on top.

FliiipBook is a browser-based animation tool for drawing frame-by-frame GIFs. You draw on a 24-frame timeline, use onion skinning to line up motion between frames, and export a looping GIF with one click. It works best on desktop or tablet — the site notes that the full creative experience needs a desktop or tablet, and mobile visitors are prompted to switch to desktop to start creating. If you want a quick, no-install way to make a short hand-drawn loop, this is the workflow.

What you get before you start

FliiipBook's feature set is built around short loops rather than long scenes:

• 24 frames — described on the site as "24 frames of glory. 2 full seconds of looping bliss," so plan for a roughly two-second loop.
• Onion skinning — see the previous and next frames while you draw.
• Keyboard shortcuts — hotkeys designed for both right-handed and left-handed users.
• Undo/redo history.
• One-click GIF export with unique filenames.
• 5 brush sizes — from 1px details to 50px strokes — plus a paint bucket, a spray can, and a spray-fill.
• Textures you can add to your animation.
• Timeline navigation across the 24 frames.

Step-by-step: draw and export your GIF

1. Open the app on desktop or tablet

Go to fliiipbook.com in your browser. Because the site states it works best on desktop or tablet, use one of those rather than a phone if you want the full toolset.

2. Sketch your key poses across the timeline

Move through the 24 frames and block in the main poses of your motion. You don't need to fill every frame at this stage — establishing the start, middle, and end of the movement first makes the in-between drawing much easier.

3. Turn on onion skinning to align motion

With onion skinning active, the previous and next frames appear as you draw. Use them to keep your character or object moving consistently from one frame to the next instead of jumping around. The site frames this as a way to get "perfect-ish timing and sort of smooth motion" — a realistic expectation for a 24-frame loop.

4. Speed up drawing with shortcuts and tools

• Use the keyboard shortcuts to move between frames and trigger actions without leaving the canvas. The site highlights hotkeys for both right-handers and southpaws.
• Pick from the 5 brush sizes for line work versus fills — 1px for fine detail, up to 50px for bold strokes.
• Use the paint bucket for flat fills, the spray can for soft shading, and the spray-fill for texture-style coverage.
• Add textures if you want a more illustrative look.
• Rely on undo/redo freely while experimenting.

5. Preview the loop and fix timing

Play the animation back before exporting. Watch for frames where the motion stalls or snaps, and redraw those in-betweens using onion skinning as your guide. Since the loop is only about two seconds, small timing errors are very visible — a couple of adjusted frames usually makes the difference.

6. Export the GIF

Use the one-click GIF export. FliiipBook assigns unique filenames to exports, so you can produce multiple versions without overwriting earlier ones. The exported file is ready to share on the web.

Common snags to expect

• Drawing on a phone. The site explicitly says it works best on desktop or tablet and asks mobile visitors to switch to desktop. Don't expect the full experience on a small screen.
• Running out of frames. With a fixed 24-frame timeline, a complex motion won't fit. Simplify the action or loop a shorter movement rather than trying to cram in more poses.
• Motion that looks jittery. This usually means the onion-skin reference wasn't followed closely enough between frames. Redraw the in-betweens with both the previous and next frames visible.
• Losing work. Undo/redo covers in-session mistakes, but the site doesn't describe saved projects — export your GIF when you're happy with it rather than assuming it will persist.

When FliiipBook is the right choice

Choose it if you want a free-feeling, browser-based way to make a short hand-drawn GIF loop without installing software, and you're working on a desktop or tablet. Look elsewhere if you need long animations, precise frame timing controls, or a mobile-first workflow — the 24-frame limit and desktop/tablet recommendation are the main constraints to weigh before you start.

Piskel is a free, open-source, browser-based editor for pixel art and animated sprites — you can design characters, animations, and tiles right in your browser, then export them as animated GIFs or spritesheet PNG/ZIP files. It works best in a desktop browser in landscape orientation, so if you're on a phone or a narrow window, expect a cramped workspace. The workflow below covers starting a sprite, drawing, animating frame by frame, and exporting.

Getting started

Open piskelapp.com and choose one of two paths:

• Start from scratch — create a blank sprite at a size you pick (small canvases like 32×32 or 64×64 are typical for characters and tiles).
• Try an example — the site's Sprite examples gallery includes characters, Gameboy retro graphics, layered backgrounds, and tilesets contributed by users such as CaptainBrosset, Ansimuz, Buch, and Surt. Opening one is the fastest way to see how frames, layers, and palettes are organized before you build your own.

If you're working with children or in a classroom, Piskel for Kids is a child-friendly version of the same editor, designed to be safe and distraction-free.

Drawing your pixel art

The editor gives you the standard pixel-art toolset: a pencil for single pixels, an eraser, fill, color picker, and shape/line tools, plus a color palette you can adjust as you work. Because everything is grid-based, zoom in before you draw — at small canvas sizes each pixel is a deliberate decision, and zooming keeps you from accidentally painting the wrong cell.

A practical order of work:

1. Set your canvas size first. Changing it later means redrawing or rescaling.
2. Block in the silhouette with a solid color.
3. Add shading and highlights with a limited palette (3–5 colors per material reads cleanly).
4. Clean up stray pixels with the eraser at high zoom.

Animating frame by frame

Piskel's timeline sits below the canvas. Each frame is a still image; the animation plays by cycling through them.

• Add frames to build a sequence — for a walk cycle, that usually means 4–8 frames.
• Duplicate a frame and edit only what changes, which keeps motion consistent between frames.
• Use layers to separate elements (for example, a character layer and a background layer) so you can edit one without disturbing the other.
• Check the live preview — Piskel shows a real-time preview of your animation as you draw, so you can judge timing without exporting.
• Adjust frame delay on the fly to speed up or slow down playback until the motion feels right.

Exporting your work

Piskel supports several export modes, and the right one depends on what you're doing next:

For game development, the spritesheet export is usually what you want — engines typically expect a single image containing every frame rather than a GIF.

Offline and desktop options

If you need to work without an internet connection, Piskel offers free desktop and offline applications for Windows, OSX, and Linux via its download page. The full source code is also open-source and available on GitHub at github.com/piskelapp/piskel, so you can inspect it, self-host it, or contribute.

Common snags

• Mobile or portrait orientation — the editor warns that it's best used in a desktop browser in landscape orientation. You can open it anyway, but the layout will be tight.
• Canvas size regret — pick your dimensions before drawing; resizing mid-project is the most common source of rework.
• Choppy animation — if motion looks jerky, the fix is usually more frames or a shorter frame delay, not more detail in each frame.

Video processing is any operation that changes a video file's content or format rather than just playing it back: trimming, resizing, changing frame rate, compressing, converting formats, and adjusting color. You need it whenever your footage has to fit a target — a smaller file for the web, a specific resolution for a platform, a limited color palette for pixel art, or a transparent background for an overlay. The right operation depends on whether you can treat the video as one continuous stream or have to touch individual frames.

The core operations

The first five are usually whole-file operations: the tool decodes the stream, applies a uniform rule, and re-encodes. Color and palette matching is often frame-by-frame: each frame is treated as an image, its pixels are remapped, and the frames are reassembled. That distinction drives most tool choices.

Whole-file transcoding vs. frame-by-frame processing

Whole-file transcoding is the right default when the change is uniform — every frame gets the same resize, the same codec, the same frame rate. It's fast, it preserves motion and audio together, and it's what general-purpose converters do.

Frame-by-frame processing is necessary when the operation depends on the content of each frame, or when you need per-frame control. Palette matching is the clearest case: to map every pixel to a custom palette, the tool has to look at each frame's colors individually. The same applies to hand-editing specific frames, drawing overlays, or exporting frames as separate images.

A practical rule: if you can describe the change in one sentence that applies to the whole clip ("make it 480 pixels wide"), use whole-file. If the change depends on what's in each frame ("map these colors to my palette"), expect frame-by-frame.

Practical uses

• Preparing footage for pixel art. Downscale a clip, then match it to a limited palette so the result reads as deliberate pixel art rather than a blurry photo. This is the workflow Palettum is built around — it matches every pixel in images, GIFs, and videos to a custom palette, with import/export of palettes, resizing, and transparency preservation.
• Making GIFs. Export a short clip as frames, apply a palette, and reassemble. GIFs are limited to 256 colors per frame, so palette matching is often mandatory rather than optional.
• Web delivery. Resize and compress so a hero video loads quickly without visible artifacts.
• Consistent branding. Force a clip into a fixed color set so it matches a UI or a sprite sheet.
• Overlays and compositing. Preserve transparency so the processed video drops cleanly onto another layer.

Common pitfalls

• Quality loss from re-encoding. Every transcode discards some information. Do the heavy operations (resize, color) in one pass where possible, and keep an untouched master.
• Transparency handling. Many codecs and containers don't carry an alpha channel. If your source has transparency, confirm the output format supports it before you commit — otherwise the alpha is flattened, usually to black or white.
• Mismatched frame rates. Dropping or duplicating frames to hit a target rate can produce stutter. Decide whether you want a genuine rate change or just a retimed playback.
• Palette mismatch across frames. A palette that looks right on one frame can band badly on another. Check a few frames spread across the clip, not just the first.
• Color count vs. file size. Reducing colors shrinks GIFs and some video formats, but it can also introduce dithering artifacts. Compare before and after rather than assuming smaller is better.

Choosing a tool

For whole-file work — trimming, resizing, converting, compressing — a general converter or a command-line encoder covers almost everything and handles audio and long clips well.

For palette matching and per-frame color work, you want a tool that treats frames as images. Browser-based options are convenient because there's nothing to install and you can preview the result before exporting; Palettum handles images, GIFs, and videos in one place with palette import/export, resizing, and transparency preservation. If your task is purely "make this file smaller" or "change this container," a general converter is the simpler choice — palette tools add per-frame overhead you don't need.

Start by naming the single change you need. If it's uniform, reach for a converter. If it depends on each frame's pixels, reach for a frame-aware tool and check a few frames before exporting the whole clip.

Image processing is the manipulation of digital images to improve how they look or to extract information from them. You can use it for almost any image task, but the operations and tools differ sharply depending on your goal. General photo editing (brightness, color, retouching) is one branch; scientific and technical imaging is another. Astrophotography sits in the second branch, where the goal is to pull a clean, accurate picture out of noisy, low-signal raw data. PixInsight, described on its site as an "advanced image processing" platform for astrophotography, research, and development, is an example of a specialized tool built for that second branch.

The core idea

Every digital image is a grid of numbers. Each pixel holds one or more values representing brightness and color. Image processing is any operation that reads those numbers and writes new ones — either to make the image more useful to a human viewer or to measure something in it.

That definition covers two broad purposes:

• Enhancement — make an image clearer, cleaner, or more pleasing.
• Analysis — measure, detect, classify, or quantify what is in the image.

Common operations

The operations below appear across photography, astronomy, and research imaging. The names are similar; the intent and settings differ by field.

Each step changes the data. Order matters: calibrating after stacking, or stretching before denoising, usually produces worse results than the standard sequence.

How it applies to astrophotography

Astrophotography is the clearest case where image processing is not optional. A single raw frame from a camera or telescope is dominated by noise, gradients, and sensor artifacts. The signal you want — a galaxy, a nebula — may be a tiny fraction of the total pixel values.

A typical astrophotography workflow runs roughly like this:

1. Capture many raw frames (lights), plus calibration frames (darks, flats, bias).
2. Calibrate each light frame against the calibration frames.
3. Align and stack the calibrated frames into a single high-signal image.
4. Stretch the stacked image to bring faint detail into view.
5. Denoise, sharpen, and color-calibrate to finish.

The input is a folder of raw frames; the output is one processed image. The same logic applies to general photography, but with fewer frames and less emphasis on calibration.

General-purpose vs. specialized tools

The difference is not just features — it is the assumptions each tool makes about your data.

• General-purpose editors (typical photo apps) assume a single, already-reasonable image. They optimize for speed and ease of use on everyday photos.
• Specialized platforms like PixInsight assume many raw frames, linear data, and a need for precise, repeatable, scriptable operations. They expose controls that general editors hide.

If you are processing a handful of snapshots, a general editor is the right choice. If you are stacking dozens or hundreds of frames and need control over calibration and stretching, a specialized platform fits better. PixInsight's site lists it as modular, open-architecture, and portable across FreeBSD, Linux, Mac OS X, and Windows — relevant if you work across systems or want to extend it.

What you can actually do with it

Concretely, image processing lets you:

• Turn a noisy set of exposures into one clean image.
• Reveal faint structures invisible in any single frame.
• Measure brightness, position, or color of objects.
• Prepare images for print, publication, or analysis.
• Automate repetitive steps so results are consistent.

Choosing your starting point

Decide based on your input and goal, not on brand:

• Casual photos, quick edits → general-purpose editor.
• Many raw frames, scientific or astro work → specialized platform such as PixInsight.
• Research or development → check whether the tool supports scripting and reproducible pipelines, since that is where specialized platforms earn their place.

The operations are learnable in any tool. What changes is how much control you get over each step — and for faint, noisy data, that control is usually the difference between a usable image and a discarded one.