Building a Custom FiveM Minimap the Hard Way (CodeWalker, Photoshop & YTD Editing)

If you’ve ever wondered why a custom FiveM minimap costs $30 to $40 per map on Fiverr — and why a full hood-map commission can run north of $500 — this post is the answer. It’s not price gouging. It’s that doing it properly, by hand, is a genuinely miserable amount of work, and the people who charge for it have earned every dollar.

I’m going to walk the entire manual workflow, start to finish, the way it actually happens. No skipping the parts that hurt. If you’re technical and you want to understand what’s really going on under a custom minimap, this is the deep end. Then, at the bottom, I’ll show you the shortcut I eventually built for myself because I got tired of the pain. Full disclosure up front: that shortcut is one of our own scripts, and I’ll flag exactly where the sales pitch starts so you can trust the rest.

If you want the gentler on-ramp version of this topic first, we wrote a lighter walkthrough over at how to make a custom minimap in FiveM. This post is the hard mode companion to it.

How GTA V’s minimap actually works

Before you touch a single file, you need the mental model, because most tutorials skip it and then everyone’s confused about why their edit didn’t show up.

The GTA V minimap — the radar in the corner — is not one image. The game draws the map from a set of tiled texture dictionaries, or YTDs. The world map is chopped into a grid, and each cell of that grid is a separate texture living inside a YTD file. When you zoom and pan the radar, the engine is stitching those tiles together in real time and drawing your blips, roads, and the player arrow on top.

There are two separate things people confuse:

The map imagery — the actual satellite/road art you see. This is the tiled textures inside the YTDs. This is what you edit for a visual restyle.
The Scaleform frame and HUD chrome — the .gfx file that draws the radar border, the health/armor bars, the compass. That’s a different beast entirely and you usually leave it alone for a map restyle.

For a custom map look — a blacked-out hood map, a stylized noir version, custom turf boundaries baked into the art — you’re working on the tiles. The textures inside the YTDs are DXT/BC compressed (think DDS under the hood), power-of-two dimensions, usually with mipmaps. Every one of those constraints will bite you later, so file them away now.

Step 1: Extract the vanilla minimap tiles

You can’t edit what you can’t open. Fire up OpenIV or CodeWalker’s RPF explorer and go digging into the game’s archives for the radar/minimap texture dictionaries. In CodeWalker, that’s the RPF Explorer navigating into the relevant x64 archives; in OpenIV it’s the same idea with a friendlier search.

Find the minimap tile YTDs, and export the textures out to a working folder. You’ll end up with a pile of DDS (or PNG, depending on how you export) files — one per tile — each representing one cell of the world grid. Name them carefully and keep the originals untouched in a separate backup folder. You will absolutely need to diff against vanilla later when a tile looks wrong, and you do not want to re-rip from the game every time.

This is also the step where you learn how many tiles you’re actually signing up for. A partial-area restyle might be a handful. A full-map restyle is dozens. Every one of them is a file you’re about to hand-edit and keep aligned with its neighbors.

Step 2: Edit the tiles in Photoshop (and why seams will haunt you)

Here’s where the hours go.

Open your tiles in Photoshop or GIMP. The naive approach is to edit each tile in isolation. Do that and you will produce a map that looks like a ransom note — every tile slightly different in brightness, contrast, and hue, with hard visible lines wherever two tiles meet. The radar pans across those boundaries constantly, so the seams are the first thing anyone notices.

The way you actually do it:

Stitch first, edit globally. Assemble the full grid into one giant canvas so you can see the whole map, apply your color grade and adjustment layers across the entire thing at once, then slice it back into tiles at the exact original boundaries. This keeps your grading consistent. It also means your canvas is enormous and your machine will hate you.
Mind the seams. Anything you draw that crosses a tile boundary — a road recolor, a zone fill, a turf outline, a text label for a neighborhood — has to line up pixel-perfect on both sides of the cut. One-pixel misalignment reads as a tear in the map.
Labels and zones are the real work. Baking postal areas, gang turf boundaries, or district labels directly into the art is what makes a custom map feel custom. It’s also the part most likely to span multiple tiles, which means the most careful seam work.
Respect the format going out. When you save each tile back out, you need the right dimensions (power of two, matching the original), the right compression, and correct mipmap handling. Save a tile as the wrong DXT format or forget mipmaps and it’ll either look blurry at distance or refuse to load.

Realistically, the grading pass is an afternoon. The label/zone/turf pass, done well, is days.

Step 3: Rebuild the YTDs

Edited tiles are just loose textures. The game wants them packed back into texture dictionaries. Three common routes:

OpenIV — import the edited textures back into a copy of the YTD, letting it handle recompression.
Folders2YTD — point it at a folder of your textures and it batches them into a YTD for you. For a many-tile map this is the sane choice, because doing it one texture at a time in a GUI is how you lose an evening.
CodeWalker’s texture tools — rebuild the dictionary directly in CodeWalker.

Whichever you use, this is where compression settings matter most. Pick the wrong format and your crisp Photoshop work turns to mush the moment the engine loads it. Get the mip chain wrong and the map gets blurry as you zoom the radar out. Keep the texture names identical to vanilla — the game finds tiles by name, and a renamed tile is an invisible tile.

Step 4: Package it as a streamed FiveM resource

Now make FiveM actually use your work instead of the vanilla tiles. You build a normal resource:

my-custom-minimap/
├── fxmanifest.lua
└── stream/
    ├── minimap_tile_0_0.ytd
    ├── minimap_tile_0_1.ytd
    └── ... (the rest of your rebuilt YTDs)

The stream/ folder is the whole trick. Anything in there gets streamed to clients and, if the file names match the vanilla assets, overrides them. Your fxmanifest.lua just needs to declare the manifest version and the game target — you don’t even list the stream files individually, FiveM picks up the folder.

fx_version 'cerulean'
game 'gta5'

author 'you'
description 'Custom minimap'
version '1.0.0'

Add it to your server.cfg, ensure it, and in theory your tiles now replace the defaults. In practice, that’s where step five begins.

Worth flagging here: streamed assets are not free. Every YTD you ship gets downloaded and held in client memory, and a heavy or badly compressed map can show up on the frame budget. If you’ve never audited streamed asset cost, our resmon performance guide covers how to actually measure what your stream folder is doing to clients.

Step 5: The iteration loop from hell

This is the part nobody warns you about, and it’s why the manual method is so expensive in real time.

You load in. A seam is off by two pixels on one tile. A road recolor looks great on one side of a boundary and wrong on the other. So you go back to Photoshop, fix the tile, re-export it, rebuild the YTD, drop it back into stream/, and try again. Here’s what “try again” actually involves:

Re-export the tile from Photoshop with correct format and mips.
Rebuild the YTD (OpenIV / Folders2YTD / CodeWalker).
Copy it into the resource’s stream/ folder.
Restart the resource — and often restart the whole server, because streamed asset changes don’t always hot-reload cleanly.
Clear the client cache, because FiveM happily serves you the old texture out of its cache and you’ll swear your edit didn’t apply when it actually did.
Rejoin, pan the radar to the exact spot, and check.

Call it 10 to 20 minutes per iteration once you’re fast — and you are never fast at first. Multiply that by every tile that needs a touch-up, and a full map is not an afternoon. It’s a project.

The failure modes that eat those iterations:

Misaligned tiles — seams that only show up in-game because your Photoshop stitch was a hair off.
Blurry compression — wrong DXT format or a broken mip chain, so the map softens as you zoom.
Cache not clearing — the single most common “why isn’t my change showing” bug. The edit worked; the cache lied.
Resource name / load order conflicts — another resource (or a base map) is also touching the minimap and winning, so your override never applies.
Wrong texture names — a renamed tile is an invisible tile. The game won’t tell you; it just draws vanilla.

None of these are hard individually. Stacked across dozens of tiles and dozens of restart cycles, they’re exhausting. That’s the $500 hood map, right there.

When the manual way is actually the right call

I’m not going to pretend the manual route is pointless — sometimes it’s exactly correct:

One-off artistic full-map restyles. If you want a completely reimagined map — a hand-painted noir Los Santos, a fully re-textured satellite look — you have to touch the tile art. There’s no shortcut to bespoke pixels.
Total visual control. Editing the source textures gives you control nothing else can: every road, every shade, every gradient is yours.
It’s free if your time is free. All the tools — OpenIV, CodeWalker, Folders2YTD, GIMP — cost nothing. If you’ve got more evenings than dollars, the manual method is a $0 path to a real result.

The catch is that last one is a trap for most server owners. Your time is not free, and the iteration loop is where it quietly disappears.

The easy button: LMX Minimap Creator

Here’s the sales-pitch section, flagged honestly: I built a tool to skip all of the above, and I sell it. Take the rest with that in mind.

LMX Minimap Creator is $29.99, one-time — no subscription. Everything I described across five painful steps happens live, in-game. You type /minimap, and you draw your zones, labels, postals, and turf boundaries directly on the real map with instant preview. When it looks right, you export a ready-to-ensure resource on the spot.

No YTD extraction. No tile-seam math. No Photoshop stitching. No rebuild-restart-clear-cache loop. The parts that make the manual method a multi-day slog are the parts it removes. It’s standalone and auto-detects ESX, QBCore, and Qbox, so it drops into most stacks without config surgery. You can see the full feature list and screenshots on the product page.

Fair note, because I’d rather you pick the right tool than just buy mine: fivem-tools.com offers a browser-canvas minimap editor on a freemium/subscription model. It’s a legitimate middle ground — more convenient than doing tiles by hand, less integrated than editing on the live map in-game.

Manual vs browser vs in-game: pick your pain

Manual (CodeWalker / Photoshop / Folders2YTD) — maximum control, zero software cost, and the steepest time cost. Right for one-off bespoke full-map art when you genuinely need custom pixels and have the hours.
Browser editor (e.g. fivem-tools.com) — a canvas in your browser, freemium/subscription. Easier than raw tiles, decent for zones and labels, but you’re working away from the live game and paying over time.
In-game (LMX Minimap Creator) — draw on the actual map, instant preview, export a working resource, one-time price. Best when you want zones/postals/turf done fast without ever opening OpenIV.

If you’re still comparing options across the whole category — not just editors but full minimap replacement scripts — we broke those down in the best FiveM minimap scripts compared.

Whichever path you take, at least now you know what’s under the hood. And if you ever meet someone charging $500 for a hood map, you’ll know they weren’t kidding.