What Changed in Foundry V14 and Why We Revisited Our Whole Map Pipeline

For a long time now, we have had a map workflow that simply worked. Like many things in module development, it was built through experience rather than theory. Over time we settled into a rhythm:

Paint our maps in Clip Studio Paint at high detail, export them, convert them to WebP, and move on to the next thing.

Reliable. Predictable. Good results.

Then Foundry V14 arrived. And suddenly we found ourselves wondering: Do we actually need to rethink everything?

The KTX2 Rabbit Hole

One of the quieter but very interesting changes in V14 was improved support for KTX2 textures.

Now, if you have not bumped into KTX2 before, it is not really a normal image format in the way PNG or WebP are. It is more of a game texture format, designed to be efficient for graphics hardware and massive game worlds.

That immediately made us curious.

Foundry has been getting more capable every version. Better visuals. More effects. More layering. Bigger scenes. And then there is Ember.

If Foundry is moving toward richer visual experiences, perhaps our old assumptions about maps needed revisiting too. So naturally, we did what any sensible module creator would do. We disappeared down a rabbit hole for far longer than planned 😄

The First Surprise: KTX2 Solves a Different Problem

At first glance, KTX2 seemed exciting. Better GPU handling. Mipmaps. Texture optimisation. Potentially smoother zooming and panning. This sounded perfect for Foundry.

So we built a small internal test tool and started converting maps. Some tiny. Some very large. Some very large.

One of our test maps was around 450 feet wide — roughly 90 grid squares across. Perfect for stress testing.

And then we immediately hit an error.

The map was too large. Cue confusion.

The Mystery of the Giant Map

At first, this felt like a bug. Why would a map work perfectly in Foundry as a PNG or WebP, but suddenly become “too large” during conversion?

After some digging, we realised we had wandered into the world of texture limits. Modern rendering systems tend to have practical maximum texture dimensions — often around 16,383 to 16,384 pixels. Suddenly something clicked.

For years we have painted our maps in Clip Studio Paint at 200 dpi, but exported them smaller for Foundry. Originally this was simply practical. Better performance. Smaller files. Faster loading.

What we had not realised is that this export step had quietly been protecting us from texture limits all along. Sometimes you accidentally make the right decision before you fully understand why it works.

A Funny Thing Happened During Testing

Going into all of this, we honestly thought KTX2 might change everything. But after a lot of testing, something unexpected happened.

WebP stubbornly refused to stop being good.

Very good. Annoyingly good 😄

We tested different KTX2 profiles.

High quality.

Balanced.

Smaller-file options.

Compared file sizes.

Compared loading.

Compared scrolling and zooming.

And in actual V14 play testing?

We found surprisingly little real-world difference once the maps had loaded. That was genuinely surprising. Years ago, giant maps could be painful. Some simply would not load properly. Players would stare at black screens while huge assets slowly arrived.

V14 feels different.

It feels much faster.

More forgiving.

More capable.

Which suddenly changed the question we were asking.

Instead of:

How aggressively can we optimise maps?

We started asking:

Can we spend some of this new performance budget on quality instead?

Looking at the Maps Again

This turned into one of those wonderfully nerdy experiments where you stare at tiny patches of grass for far too long. We started comparing map exports at different resolutions.

The sort of places that compression tends to struggle:

• muddy ground
• grass
• mushrooms
• soft mist
• subtle painterly textures

What surprised us was how close some of the results were.

The jump from 200 dpi to 180 dpi looked smaller than expected.

The jump from 180 to 160 dpi looked smaller again.

But by the time we got to 140 dpi, we started noticing a little more softness.

Not dramatic. Nothing players would suddenly complain about. But some of the richness in the painted detail began to soften. The grass blended together slightly more. Dark textured areas became just a touch more painterly.

The map still looked great.

But after staring at comparisons for far too long, we could see it. And once you see something…

Well.

You cannot unsee it.

Another Unexpected Discovery

One thing we discovered during all of this was just how good Clip Studio Paint is at resizing artwork.

We found ourselves consistently liking the quality of:

Paint high detail
↓
Resize carefully in Clip Studio
↓
Export PNG
↓
Convert with dedicated WebP tools

more than direct exports.

Interestingly, Clip Studio seemed to do a lovely job preserving the feel of the painted maps when reducing resolution. Then dedicated WebP tools gave us finer control over the final balance between quality and size. Without getting too deep into the secret sauce, let us just say there was a lot of:

“Wait… go back one version.”

“No, zoom in over here.”

“What about this patch of grass?”

😄

Layered Scenes Were the Real Concern

One of the reasons we started this whole process was concern over layers.

Modern Foundry scenes increasingly include:

• overlays
• canopies
• weather
• alternate scene states
• lighting tricks

A scene is rarely just one image anymore. Sometimes it becomes several. Years ago that would have made us nervous.

But after testing?

We are honestly much less worried than we expected to be. The improvements in V14 feel meaningful. That opens interesting possibilities. Maybe we do not always need to optimise as aggressively as we once did. Maybe we can allow ourselves a little more visual richness in the final experience.

So… Where Have We Landed?

For now? We are still experimenting. But we have come away from this process feeling surprisingly positive.

KTX2 is fascinating, and we can absolutely see why Foundry is supporting it, especially for very large worlds and graphics-heavy experiences. But for our modules? WebP still feels incredibly practical.

Reliable.

Efficient.

Hard to beat.

The bigger change may actually be this: We are now reconsidering just how much quality we can afford to keep. Because if Foundry V14 has genuinely moved the performance needle — and it certainly feels like it has — perhaps the best response is not simply:

“Make things smaller.”

Perhaps sometimes the answer is:

“Let the maps breathe a little more.”

We are still testing. Still comparing. Still occasionally staring at mushrooms far too closely.

But it has been fascinating revisiting assumptions we had not questioned in years. And if there is one thing this little adventure reminded us of, it is this:

Yesterday’s workflow is not always tomorrow’s workflow.

Especially in Foundry VTT.

Things move fast around here. 😄