Pixel Art Doesn't Have to Be Just a PNG

Most pixel art workflows start with an image.

You open an editor, draw pixels, arrange sprites into a spritesheet, define animation frames, and eventually export a PNG.

That workflow works. Tools like Aseprite have made traditional pixel-art production remarkably accessible.

But I've been thinking about a different question:

What if pixel art could be treated as structured, programmable data instead of just a collection of pixels?

This question became the starting point for PIX2 and NOIRADIX Studio, two open-source projects I'm building to explore a different way of creating and managing pixel-art assets.

The problem with treating sprites as only images

A PNG is excellent at representing the final appearance of artwork. It is widely supported, easy to distribute, and understood by practically every game engine.

However, it does not inherently describe the structure behind the image.

Consider a character sprite. Its appearance might contain:

• A body
• Eyes and facial details
• Clothing and accessories
• Different visual states
• Multiple animation directions
• A palette shared across several sprites

Once everything is flattened into a raster image, the relationships between these elements are no longer explicitly represented in the file.

This becomes particularly inconvenient when working with programmatic generation, reusable components, version control, or workflows where artwork needs to be inspected and modified by software.

Git can tell you that a PNG changed. It cannot naturally explain which semantic part of the sprite changed or why.

I wanted to explore whether a sprite could have something closer to a source file.

Introducing PIX2: structured data for pixel art

PIX2 is an open structured language designed to represent pixel-art artwork as editable, machine-readable source.

Instead of treating the exported image as the only source of truth, a .pix2 document describes the artwork in a structured format.

The idea is to make pixel art:

• Structured: Artwork can contain meaningful organizational elements rather than being only a flat raster.
• Diffable: Text-based source can be inspected and compared through ordinary version-control workflows.
• Programmable: Software and external AI assistants can work with the source representation directly.
• Deterministic: The same valid source, rendering rules, and renderer configuration produce the same rendered output.
• Interoperable: The format is designed to support independent tools and implementations.

PIX2 also introduces structural concepts such as layers, groups, and regions.

These concepts provide a way to organize artwork beyond individual pixel coordinates.

The important distinction is that PIX2 is not intended to replace PNG. PNG remains useful as an output format. PIX2 addresses a different layer: how the artwork is represented, edited, and managed before export.

NOIRADIX Studio: the visual environment

A structured format needs a practical way to work with it.

That is why I built NOIRADIX Studio.

NOIRADIX Studio is a free, open-source, browser-based pixel-art editor and sprite animation environment built around PIX2.

It connects structured source authoring with visual editing.

The current workflow includes:

• Creating and editing pixel-art sprites.
• Organizing sprite sheets.
• Building 4-direction and 8-direction animations.
• Working with animation clips and structured artwork.
• Importing existing raster artwork into the workflow.
• Exporting assets for game development.

The editor is built using vanilla JavaScript, without runtime frameworks or external package dependencies.

It is designed to work offline after the application has been loaded, with local-first workflows and no account requirement.

I also wanted the project to remain accessible. You should not need to install a large development environment just to experiment with a pixel-art editor.

Connecting visual editing with programmatic authoring

One interesting possibility of having a text-based source format is that it creates another way to interact with artwork.

For example, an external AI coding assistant can help author or modify PIX2 source.

The resulting document can then be opened in NOIRADIX Studio, rendered, inspected, and refined visually.

This is not a built-in AI image generator. NOIRADIX does not currently generate artwork by itself.

Instead, the idea is to let AI tools work with a structured representation that humans can still inspect and edit.

I find this distinction important.

An AI-generated image can be useful, but a structured document gives developers something more practical to work with: source that can be examined, modified, version-controlled, and processed by software.

It also means that AI is optional. Artists can create and edit their work entirely through the visual editor.

From pixel art to game-ready assets

A pixel-art editor should not stop at producing an image.

The assets eventually need to enter a game engine.

NOIRADIX currently supports a Unity export workflow that includes:

1. Exporting the sprite atlas as PNG.
2. Exporting the associated metadata.
3. Using a custom Unity importer to slice sprites and generate native Unity AnimationClip assets.

For other 2D development workflows, the project also supports TexturePacker Standard JSON export, targeting tools and engines such as Godot, Phaser, PixiJS, Defold, Raylib, and GameMaker.

The intention is to reduce the gap between creating artwork and integrating it into an actual game project.

An open format matters more than vendor lock-in

I deliberately keep PIX2 separate from the NOIRADIX Studio application.

The licenses are also separated:

• NOIRADIX Studio: Apache License 2.0
• PIX2 Language Specification: Creative Commons Attribution 4.0
• PIX2 Reference Engine: Apache License 2.0

I do not want PIX2 to become a format that only one application can understand.

Other developers should be able to study the specification, build their own implementations, and experiment with their own tooling.

A format becomes more interesting when it can exist beyond the original application that introduced it.

NOIRADIX Studio is one way to author and work with PIX2, but it does not need to be the only one.

What I'm working on next

There is still a lot to improve.

I want to continue developing the editing experience, animation workflows, language tooling, documentation, and interoperability.

I am particularly interested in feedback from game developers, pixel artists, technical artists, and people working on creative developer tools.

Some questions I'm still exploring:

• What should a structured pixel-art language expose to developers?
• How should animation data be represented and shared?
• What would make a format practical for independent game engines?
• How can visual editors and programmatic authoring complement each other without making either workflow unnecessarily complicated?

These are not problems I expect to solve alone.

Try it out

Both projects are open source, and the current implementation is available publicly.

NOIRADIX Studio: https://noiradix.me/

GitHub repository: https://github.com/dotlinux26/noiradix-studio

PIX2 and project documentation: Available through the repository.

Community: https://discord.gg/SJwsdGWubF

I'm building NOIRADIX because I believe pixel art can be more than an image.

It can also be structured, programmable, version-controlled data that remains accessible to both artists and developers.

And I think there is room to explore what that could make possible.