Making FiveM Props the Hard Way (Blender, Sollumz & CodeWalker)

Every FiveM developer eventually makes a prop the manual way, and I think every developer should do it at least once. Not because it’s efficient — it isn’t — but because once you’ve taken a model all the way from Blender to a working CreateObject, nothing about how GTA streams assets is a mystery any more.

This is that workflow, written honestly. What each step is actually for, where it takes longer than any tutorial admits, and the specific places a prop breaks without telling you. If you’d rather skip the manual route, how to make custom props in FiveM covers the faster options, and there’s an easy button at the end of this post.

What You’re Actually Building

A working FiveM prop is a small resource with a handful of files, and each one has one job:

• .ydr — the drawable: the 3D model, its materials and (usually) its textures and collision.
• .ytyp — the archetype definitions. This is what registers your model’s name with the game, so CreateObject(GetHashKey('my_prop')) resolves to something. Miss it and the prop streams but can never spawn.
• .ymap — optional. It places copies of your prop at fixed spots in the world.
• fxmanifest.lua — tells FiveM the resource exists and registers the .ytyp.

FiveM prop files explained goes deeper on each. For now, keep one rule in your head for the whole process: the model name has to match everywhere. The .ydr file name, the archetype name in the .ytyp, and the name you spawn. Most broken props are a name mismatch.

What You’ll Need

• Blender — free, blender.org
• Sollumz — the Blender add-on that reads and writes GTA V formats, github.com/Sollumz/Sollumz
• CodeWalker — for inspecting game assets and working with .ytyp and .ymap files, github.com/dexyfex/CodeWalker
• An image editor if you’ll touch textures — GIMP is free
• A test server you can restart freely. You’ll restart it a lot.

Expect your first prop to take an evening. Your tenth takes much less — but the restart loop never fully goes away.

Step 1: Get a Model

You have three choices, and each has a catch.

Model it yourself. Full control and no licence questions, but it’s a real skill. Even a simple object takes practice before it looks right in GTA’s lighting.

Download one. Sketchfab is where most tutorials send you, and there are good free models there. Read the licence on every single one. Some require attribution, some forbid modification, and some forbid commercial use — which matters if your server takes money for anything, VIP included. “It was free to download” and “I’m allowed to use this on my server” are not the same thing.

Generate one. AI image-to-3D services can produce a usable model from a photo. The catch is that they often produce very high polygon counts and messy geometry that you’ll need to clean up and reduce before it’s fit for a game.

Step 2: Prepare It in Blender

Import the model and fix the basics before anything GTA-specific:

1. Scale. GTA works in real metres. A can is about 12 cm tall; a chair is about a metre. A model that’s 100× too big is the most common first-timer surprise.
2. Orientation. Stand it upright the way the game expects, and apply your transforms so the scale and rotation are baked in rather than just displayed.
3. Origin, or pivot. This decides where the prop “stands”. Put it at the base for things that sit on the ground, or in the centre for things you’ll attach to a hand or hang on a wall. Getting this wrong is why props float or sink into the floor.
4. Polygon count. Keep it proportionate. A handheld item doesn’t need hundreds of thousands of triangles. Reduce heavy downloaded or AI models before going further.
5. Textures. Keep them reasonably sized. A 4K texture on a burger is wasted memory for every player who streams it.

Step 3: Set It Up With Sollumz

This is where the model becomes a GTA asset. With Sollumz installed, you convert your mesh into a Sollumz drawable, give it GTA-compatible shaders, and connect its textures. The exact buttons change between Sollumz versions, so follow the documentation for the version you install rather than a tutorial recorded against an older one — this is one of the most common places tutorials go stale.

The two things to get right here:

• Shaders. Use a shader appropriate for what the object is. A wrong shader is why a prop can look fine in Blender and flat, black or shiny in-game.
• Naming. Name the drawable what you intend the model name to be — lowercase, no spaces, and unique. Model names are global across your whole server, so burger is asking for a collision with someone else’s resource. Something like myserver_burger_special is safer.

Step 4: Build Collision

Without collision, players and vehicles pass straight through your prop. With the wrong collision, they hit invisible walls.

You have roughly three choices:

• A simple box around the object. Cheap and right for most props — it’s what most of the game’s own props use.
• Collision that follows the real shape. Needed when the gaps matter, but more expensive.
• No collision at all. The correct choice for flat signs, posters and decals — a sign with box collision puts an invisible slab the size of the whole picture in front of the wall.

Collision can be embedded in the drawable or shipped as a separate .ybn. Either way, if it’s embedded, it’s baked in — changing your mind later means rebuilding the model.

Step 5: Export the .ydr

Export from Sollumz. Check the exported file name matches the model name you chose. If you renamed anything in Blender after setting it up, check again.

Step 6: Create the .ytyp

The .ytyp holds one archetype definition per prop, and this is the step tutorials most often gloss over. Each archetype needs, among other things:

• The name, matching the .ydr exactly.
• The texture dictionary it uses.
• A bounding box and sphere, so the game knows the prop’s size for streaming and culling.
• A LOD distance — how far away the prop stays visible. Too low and it pops out of view; far too high and it costs performance for no visible gain.
• The physics dictionary, if the collision is embedded in the drawable, so the game actually honours it.

You can build and edit .ytyp files in CodeWalker, and Sollumz can work with them too. Many people copy an existing .ytyp and edit it. That works — just change every name in it.

Step 7: Package the Resource

Lay it out like this:

my_props/
├── fxmanifest.lua
└── stream/
    ├── my_props.ytyp
    └── myserver_burger_special.ydr

And the manifest:

fx_version 'cerulean'
game 'gta5'

this_is_a_map 'yes'

files {
    'stream/my_props.ytyp'
}

data_file 'DLC_ITYP_REQUEST' 'stream/my_props.ytyp'

Both of the last two lines are load-bearing. data_file 'DLC_ITYP_REQUEST' registers your archetypes, and this_is_a_map 'yes' is what makes FiveM actually read that entry. Drop either one and the .ydr still streams — so nothing looks broken in the console — but the model name never resolves and every spawn quietly fails. The .ytyp is listed in files because a data_file has to point at a file the client is allowed to download; the .ydr doesn’t need listing, because everything in stream/ streams automatically.

Step 8: Restart and Test

Add ensure my_props to server.cfg, then do a full server restart — archetypes register when the server starts, so restarting the resource isn’t enough. Then spawn it:

local model = GetHashKey('myserver_burger_special')
RequestModel(model)
while not HasModelLoaded(model) do Wait(0) end
local coords = GetEntityCoords(PlayerPedId())
CreateObject(model, coords.x, coords.y, coords.z, true, true, false)

If a prop appears, congratulations. Now look at it critically: the size, the pivot, the lighting, the collision. Then change something in Blender, and go round the whole loop again. That loop — edit, export, repackage, restart, fly to it, look — is the real cost of the manual route, and it’s why a prop that looked finished at step 5 takes another hour.

When It Doesn’t Work

The failures are rarely loud. Check, in this order:

1. Did you do a full server restart?
2. Are both this_is_a_map 'yes' and the DLC_ITYP_REQUEST line in the manifest?
3. Do the .ydr name, the archetype name and the spawned name all match exactly?
4. Are the files inside a folder named exactly stream, not flattened or double-nested?
5. Did you rename a file after building it? Rename it in the .ytyp too.
6. Is it black, missing textures or strangely shiny? Check the texture dictionary and shaders.
7. Does it float or sink? Fix the origin in Blender and re-export.
8. Do players walk through it, or hit an invisible wall? Revisit collision.

If you’re also adding custom interiors, the same streaming rules apply, and how to add custom MLOs to FiveM covers the interior side.

Or: The Easy Button

Full disclosure: this is our tool. I wrote this whole post because I think the manual route is worth understanding. But if you understand it and just need props — especially from photos and logos — it’s a lot of steps to repeat for every burger and sign.

The LMX Prop Creator does steps 2 to 7 for you, in-game. You drop in a photo, it removes the background and reads the shape, and it writes the .ydr, the .ytyp (name, bounds, physics dictionary and LOD distance included), a .ymap for anything you place, and a manifest with both of those load-bearing lines already in it. Spawn Live shows you the real model in the world in seconds, so the restart loop only happens once — when you install the finished pack.

It’s not the only tool that skips Blender. Our comparison of prop creators covers the free converters, the browser tools, and Apex’s in-game converter, which works from 3D models rather than photos. But if you’ve just read eight steps and thought “I need forty of these by Friday,” that’s exactly the situation it was built for.