Pixel Art Upscaling Done Right

Summary

The video explains how pixel upscaling filters—especially SNES-style emulator filters—can dramatically change the look of pixel art. Some upscalers (for example, HQX-like filters) can turn crisp pixel art into a more “painterly” or clay-like blended style, potentially losing some of the original pixel “charm.”

Rather than treating upscaling as a purely technical afterthought, the creator proposes using it as art direction: design pixel art with the chosen upscaler’s behavior in mind to intentionally achieve a target aesthetic.

Core idea: upscaling as art direction

Use the upscaler as part of the creative process:

• Pick a desired visual outcome (sharper pixels vs. smoother painterly blending).
• Design source pixel art to encourage (or avoid) the upscaler’s characteristic transformations.

Artistic techniques / creative concepts shown

• Upscaling as art direction: design pixel art for the upscaler’s characteristic output instead of preserving the original look.
• Algorithm-aware asset design: intentionally use patterns/gradients and constraints that will sharpen or blend as desired.
• Texture style experimentation: create multiple tile categories (e.g., divided bricks, wood, carpet/rug, grass, water, sand, rocks/obsidian, stone/granite) and compare output styles.
• Context testing in tile scenes: evaluate results in grid-based, game-like layouts to judge artifacts, blur, and edge behavior.
• Sprite/palette design for upscaling: add black borders and check how each algorithm treats silhouettes and internal color transitions.
• Variant algorithm comparison: introduce ScaleFX/SFX to reduce artifacts by considering more neighbors (including corners), trading off some smoothness.
• Iterative prototyping: generate assets quickly, upscale, review, and refine—rather than committing early to deep production.

Algorithms and visual behaviors discussed

• Nearest neighbor

  • Keeps the original pixel-art look.
  • Serves as the baseline “no style change” reference.

• Scale2X

  • (Credited to LucasArts.)
  • Simpler; tends to preserve clearer pixel-based structure.
  • Can introduce banding/noise depending on details.

• HQX (in ZSNES/SNES emulator context)

  • More complex.
  • Often produces a painterly/vector-ish blend/curvature effect.
  • Can become too blurry when colors don’t separate well.

• ScaleFX / SFX

  • Checks more neighbors (8-way, including corners).
  • Reduces artifacts, but may change the characteristic “zigzag” feel.

Steps / workflow (as described)

1. Observe upscaler behavior

• Test emulator filter settings and record how pixels blend/round (notably HQX-like behavior).

2. Set constraints for source pixel art

• Use small, manageable dimensions for predictable iteration (experimenting around 16×16 tiles).
• Test scaling first at 2×, later at 4×.

3. Choose algorithms to compare

• Compare at least ScaleX/Scale2X and HQX.
• Optionally include ScaleFX/SFX as a variant.

4. Create source tiles

• Build textures with intentional patterns (e.g., divided bricks and regions of similar color to encourage HQX blending).
• Expand to a broader test set such as grass, water, sand, rocks/obsidian, carpet/rug, etc.

5. Automate asset processing with Python

• Use an existing HQX library (the creator notes it’s too complex to reimplement).
• Implement a simpler ScaleX yourself (using if-statements).
• Use Pillow to:
  • split larger images into individual tiles,
  • upscale each tile via the chosen algorithm,
  • recombine tiles into a final atlas/image.
• Avoid tile bleed:
  • ensure tile boundaries and color differences don’t cause excessive blending between adjacent tiles.

6. Evaluate in-game-like contexts

• Place upscaled tiles into a 10×10 grid (example resolution mentioned: 320×320).
• Compare overall sharpness vs. blur.
• Swap tile sets between upscalers to see which algorithm suits which art style.

7. Test additional asset types

• Create character sprites (e.g., zombie/shooter characters) with black borders.
• Compare how each upscaler preserves or overwrites border visibility.

8. Experiment with scale factor

• Repeat at 4× (e.g., 16×16 → 64×64).
• Use high-bright-color sprites (example: fish) to see how HQX/ScaleX behave at larger outputs.

9. Test with community art

• Download a public domain/community tile set (Minecraft-style).
• Compare HQX vs. ScaleX on plants, bricks, wood gradients, etc.

10. Conclude with practical rules of thumb

• Iterate with quick test tiles rather than going deep immediately.
• Palette choice is crucial for HQX:
  • Avoid outcomes that are either too sharp (no blending) or too blurry (excessive blending).
• Choose based on style preference:
  • Prefer ScaleX for a more retained pixel-art identity.
  • Prefer HQX for a painterly/grittier/blurred look.

Creators / contributors featured (as mentioned)

• LucasArts

  • Credited with developing Scale2X.

• Microsoft

  • Referenced regarding a “depixeling pixel art” concept/algorithm (plus related discussion).

• Wikipedia

  • Mentioned as a place to learn algorithm details and pseudocode.

• Python (Pillow library)

  • Used for splitting/upscaling/combining images.

• Open Game Art

  • Source of the community tile set tested.

• Public domain/community tile set creator(s)

  • Not specifically named in the subtitles (only the source is mentioned).

• ZSNES emulator

  • Referenced as the emulator context where the HQX-like filter was observed.

Notable reference: speaker identification

• No individual YouTuber name for the speaker is provided in the subtitles.