My 2025 Game Runs in Photoshop & It’s Unbelievable

What if I told you the next indie game you play wasn’t built in Unity or Unreal, but inside… Adobe Photoshop? You’d probably think I’ve been sniffing too many marker fumes or I’m confusing a prototype for a product. But I’m here to tell you it’s not a joke, a concept, or a tech demo. My upcoming 2025 game, Layer Zero, runs entirely, natively, and playably inside of Photoshop. And it’s the most creatively liberating project I’ve ever worked on.

For years, I’ve been a technical artist, living in the frustrating gap between art creation and engine implementation. That endless cycle: paint a texture, export, import into the engine, tweak a material, notice a seam, go back to Photoshop, rinse, repeat. It’s a workflow tax that drains creative momentum. One late night, staring at a particularly stubborn UV map, a ludicrous thought sparked: What if I just… skipped the engine? What if the creative tool *was* the game engine?

This post is the story of that insane idea. Let’s pull back the curtain, dive into the code, and explore how—and more importantly, *why*—you’d build a fully functional game inside the world’s most popular image editor.

The Genesis of a Crazy Idea

The motivation wasn’t just to be different; it was born from a deep-seated desire for a truly seamless workflow. I wanted to create a world where art and logic weren’t just linked, they were one and the same. Imagine painting a new platform into the level and being able to jump on it instantly. Or applying a Gaussian Blur filter to a distant mountain range not as a static effect, but as a dynamic, in-game “fog of war” that changes in real-time.

This isn't just about convenience. It’s about a new form of creative expression. When the barrier between creation and interaction is obliterated, you start thinking differently. Your game design decisions become intrinsically tied to your artistic ones. A brush stroke isn’t just a visual; it can be a collider, a trigger, or a piece of interactive story.

Deconstructing the Magic: How It Actually Works

Okay, let’s get technical. Photoshop isn’t exactly built for this. There’s no built-in physics engine, no native controller support, and its performance is optimized for deliberate, single-user actions, not 60-frames-per-second real-time rendering. So, how do you bend it to your will? The answer lies in a powerful, and often overlooked, feature: scripting.

The Game Loop in Layers

At the heart of any game is the game loop: a constant cycle of processing input, updating game state, and rendering the result. In an environment that has no concept of a game loop, I had to create one.

My engine uses a custom panel built with Photoshop's UXP (Unified Extensibility Platform), which is essentially modern JavaScript. This panel runs a script on a `setInterval` timer. Every 33 milliseconds (for a target of ~30fps), the main game loop function fires:

1. Input: The UXP panel listens for keyboard events. When you press the 'D' key, it sets a `player.velocity.x` variable to a positive value.
2. Update: The script then iterates through key game objects—which are just Photoshop layers. It reads their current state from stored metadata (more on that later), applies logic (like gravity or player input), and calculates their new position.
3. Render: This is the magic. The “render” step is simply the script telling Photoshop to move the layers. A command as simple as layer.translate(newX, newY) instantly updates the visuals on the canvas. The canvas *is* the game screen. There is no separate rendering pipeline.

It feels like being a digital puppeteer. You’re not compiling code and running an executable; you’re commanding the software’s own elements to perform in real-time.

State Management with Smart Objects and Metadata

So, where does all the game data live? How does the engine know a character’s health or that a specific layer is a solid platform?

• Smart Objects as Entities: Each character, enemy, or interactive object is a Smart Object. This is perfect because you can nest things inside. My player character’s Smart Object contains different layer groups for “idle,” “run,” and “jump” animations. The game script simply changes the visibility of these groups to play the animation.
• XMP Metadata as a Database: This was the biggest breakthrough. Photoshop allows you to embed custom XMP metadata into any layer. I use this to store an object’s state. The ‘Player’ layer has metadata fields like `hp: 100`, `isJumping: false`, and `colliderType: 'dynamic'`. The game script reads this data at the start of the update loop and writes it back at the end. The PSD file itself becomes your save file.

The Uphill Battle: Performance, Pitfalls, and 'Aha!' Moments

This journey wasn't all smooth sailing. My first attempts were laughably slow. Trying to move 50 layers individually every frame brought Photoshop to its knees. The key was optimization: I wrote a system to “bake” all static background and foreground layers into single, flat images at runtime, so the engine only has to worry about moving the dynamic objects.

The most bizarre challenge? The Undo command. What happens when a user accidentally hits Ctrl+Z? It doesn’t just undo the last brush stroke; it could revert a layer’s position, effectively rewinding game time and completely desyncing the game state from the script’s logic. My solution was to build a custom state manager that overrides the native Undo, giving me control over the game’s timeline.

The biggest “aha!” moment came when I realized I could use Photoshop’s own tools as game mechanics. This led to the core concept of my game, Layer Zero.

So, What Am I Building? Introducing 'Layer Zero'

Layer Zero is a 2D puzzle-platformer where you play as a sentient artist’s cursor, trapped within a corrupted PSD file. Your abilities aren’t swords and spells; they’re the tools from the Photoshop toolbar.

• Stuck behind a wall? Select the Eraser Tool ability to permanently delete it from the level.
• Need to cross a wide gap? Activate the Clone Stamp Tool to duplicate a nearby platform and create a bridge.
• An enemy is chasing you? Draw a box with the Marquee Tool and hit 'delete' to vanquish it.
• Face a river of impassable pixels? Use a Liquify filter-spell to bend its flow and redirect it.

The game becomes a meta-adventure about the very act of digital creation. The puzzles are designed to make you think like a digital artist, manipulating layers, blend modes, and selections to progress. It’s a concept that simply could not exist in a traditional game engine. It *has* to be in Photoshop because the toolset is the story.

The Takeaway: Creativity Loves Constraints

Is this the future of game development? Absolutely not. It’s a niche, experimental, and frankly, ridiculous way to build a game. It will never compete with the raw power and versatility of Unreal Engine 5 or the massive ecosystem of Unity.

But it’s also a powerful testament to the idea that creativity thrives under constraints. By forcing myself to work within this bizarre limitation, I discovered a new way to tell a story and a new type of game mechanic. It proves that innovation isn’t always about having the newest, most powerful tools, but about using the tools you have in ways no one ever intended.

It brought the joy and immediacy of sketching back into the cold, logical world of game development. And for me, that’s been the most unbelievable part of it all. So, the next time you’re facing a creative block, take a look at the tools you use every day. Maybe the most innovative thing you can do is use them completely wrong.